Pola Desain Python: Untuk Kode yang Ramping dan Modis

Katakanlah lagi: Python adalah bahasa pemrograman tingkat tinggi dengan pengetikan dinamis dan pengikatan dinamis. Saya akan menggambarkannya sebagai bahasa dinamis tingkat tinggi yang kuat. Banyak pengembang jatuh cinta dengan Python karena sintaksnya yang jelas, modul dan paket yang terstruktur dengan baik, dan karena fleksibilitasnya yang luar biasa dan berbagai fitur modernnya.

Dalam Python, tidak ada yang mewajibkan Anda untuk menulis kelas dan membuat instance objek darinya. Jika Anda tidak memerlukan struktur kompleks dalam proyek Anda, Anda cukup menulis fungsi. Lebih baik lagi, Anda dapat menulis skrip datar untuk menjalankan beberapa tugas sederhana dan cepat tanpa menyusun kode sama sekali.

Pada saat yang sama Python adalah bahasa berorientasi objek 100 persen. Bagaimana dengan itu? Sederhananya, semua yang ada di Python adalah objek. Fungsi adalah objek, objek kelas satu (apa pun artinya). Fakta tentang fungsi sebagai objek ini penting, jadi harap diingat.

Jadi, Anda dapat menulis skrip sederhana dengan Python, atau cukup buka terminal Python dan jalankan pernyataan di sana (itu sangat berguna!). Tetapi pada saat yang sama, Anda dapat membuat kerangka kerja yang kompleks, aplikasi, perpustakaan, dan sebagainya. Anda dapat melakukan banyak hal dengan Python. Tentu saja ada sejumlah batasan, tetapi bukan itu topik artikel ini.

Namun, karena Python sangat kuat dan fleksibel, kita memerlukan beberapa aturan (atau pola) saat memprogram di dalamnya. Jadi, mari kita lihat apa itu pola, dan bagaimana hubungannya dengan Python. Kami juga akan melanjutkan untuk menerapkan beberapa pola desain Python yang penting.

Mengapa Python Bagus Untuk Pola?

Bahasa pemrograman apa pun bagus untuk pola. Faktanya, pola harus dipertimbangkan dalam konteks bahasa pemrograman apa pun. Baik pola, sintaksis bahasa, dan sifat memberikan batasan pada pemrograman kami. Keterbatasan yang berasal dari sintaksis bahasa dan sifat bahasa (dinamis, fungsional, berorientasi objek, dan sejenisnya) dapat berbeda, demikian pula alasan di balik keberadaannya. Keterbatasan yang datang dari pola ada karena suatu alasan, mereka memiliki tujuan. Itulah tujuan dasar dari pola; untuk memberitahu kita bagaimana melakukan sesuatu dan bagaimana tidak melakukannya. Kita akan berbicara tentang pola, dan terutama pola desain Python, nanti.

Filosofi Python dibangun di atas gagasan praktik terbaik yang dipikirkan dengan matang. Python adalah bahasa yang dinamis (apakah saya sudah mengatakannya?) dan dengan demikian, sudah mengimplementasikan, atau membuatnya mudah untuk diimplementasikan, sejumlah pola desain populer dengan beberapa baris kode. Beberapa pola desain dibangun ke dalam Python, jadi kami menggunakannya bahkan tanpa mengetahuinya. Pola lain tidak diperlukan karena sifat bahasa.

Misalnya, Pabrik adalah pola desain Python struktural yang ditujukan untuk membuat objek baru, menyembunyikan logika instantiasi dari pengguna. Tetapi pembuatan objek dengan Python dirancang secara dinamis, jadi penambahan seperti Pabrik tidak diperlukan. Tentu saja, Anda bebas menerapkannya jika Anda mau. Mungkin ada kasus di mana itu akan sangat berguna, tetapi itu pengecualian, bukan norma.

Apa yang bagus tentang filosofi Python? Mari kita mulai dengan ini (jelajahi di terminal Python):

 > >> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those!

Ini mungkin bukan pola dalam pengertian tradisional, tetapi ini adalah aturan yang mendefinisikan pendekatan "Pythonic" untuk pemrograman dengan cara yang paling elegan dan berguna.

Kami juga memiliki pedoman kode PEP-8 yang membantu menyusun kode kami. Ini adalah suatu keharusan bagi saya, dengan beberapa pengecualian yang sesuai, tentu saja. Omong-omong, pengecualian ini didorong oleh PEP-8 itu sendiri:

Tetapi yang paling penting: tahu kapan harus tidak konsisten – terkadang panduan gaya tidak berlaku. Jika ragu, gunakan penilaian terbaik Anda. Lihat contoh lain dan putuskan apa yang terlihat terbaik. Dan jangan ragu untuk bertanya!

Gabungkan PEP-8 dengan The Zen of Python (juga PEP - PEP-20), dan Anda akan memiliki dasar yang sempurna untuk membuat kode yang dapat dibaca dan dipelihara. Tambahkan Pola Desain dan Anda siap untuk membuat setiap jenis sistem perangkat lunak dengan konsistensi dan kemampuan evolusi.

Pola Desain Python

Apa Itu Pola Desain?

Semuanya dimulai dengan Gang of Four (GOF). Lakukan pencarian online cepat jika Anda tidak terbiasa dengan GOF.

Pola desain adalah cara umum untuk memecahkan masalah yang sudah dikenal. Dua prinsip utama yang menjadi dasar pola desain yang ditentukan oleh GOF:

• Program ke antarmuka bukan implementasi.
• Mendukung komposisi objek daripada pewarisan.

Mari kita lihat lebih dekat kedua prinsip ini dari perspektif programmer Python.

Program ke antarmuka bukan implementasi

Pikirkan tentang Mengetik Bebek. Dalam Python kami tidak suka mendefinisikan antarmuka dan kelas program sesuai dengan antarmuka ini, bukan? Tapi, dengarkan aku! Ini tidak berarti kami tidak memikirkan antarmuka, sebenarnya dengan Duck Typing kami melakukannya sepanjang waktu.

Katakanlah beberapa kata tentang pendekatan Pengetikan Bebek yang terkenal untuk melihat bagaimana itu cocok dengan paradigma ini: program ke antarmuka.

Kami tidak peduli dengan sifat objeknya, kami tidak peduli apa objeknya; kami hanya ingin tahu apakah itu dapat melakukan apa yang kami butuhkan (kami hanya tertarik pada antarmuka objek).

Bisakah objek bergetar? Jadi, biarkan dukun!

 try: bird.quack() except AttributeError: self.lol()

Apakah kita mendefinisikan antarmuka untuk bebek kita? Tidak! Apakah kami memprogram ke antarmuka alih-alih implementasi? Ya! Dan, saya menemukan ini sangat bagus.

Seperti yang ditunjukkan Alex Martelli dalam presentasinya yang terkenal tentang Pola Desain dengan Python, “Mengajar bebek untuk mengetik membutuhkan waktu, tetapi menghemat banyak pekerjaan setelahnya!”

Lebih suka komposisi objek daripada warisan

Nah, itulah yang saya sebut prinsip Pythonic ! Saya telah membuat lebih sedikit kelas/subkelas dibandingkan dengan membungkus satu kelas (atau lebih sering, beberapa kelas) di kelas lain.

Alih-alih melakukan ini:

 class User(DbObject): pass

Kita bisa melakukan sesuatu seperti ini:

 class User: _persist_methods = ['get', 'save', 'delete'] def __init__(self, persister): self._persister = persister def __getattr__(self, attribute): if attribute in self._persist_methods: return getattr(self._persister, attribute)

Keuntungannya jelas. Kami dapat membatasi metode apa dari kelas yang dibungkus untuk diekspos. Kami dapat menyuntikkan instance persisten di runtime! Misalnya, hari ini database relasional, tapi besok bisa apa saja, dengan antarmuka yang kita butuhkan (sekali lagi bebek sial itu).

Komposisi elegan dan alami untuk Python.

Pola Perilaku

Pola Perilaku melibatkan komunikasi antar objek, bagaimana objek berinteraksi dan memenuhi tugas yang diberikan. Menurut prinsip GOF, ada total 11 pola perilaku dalam Python: Rantai tanggung jawab, Perintah, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template, Visitor.

Saya menemukan pola-pola ini sangat berguna, tetapi ini tidak berarti bahwa kelompok pola lainnya tidak.

Pengulangan

Iterator dibangun ke dalam Python. Ini adalah salah satu karakteristik bahasa yang paling kuat. Bertahun-tahun yang lalu, saya membaca di suatu tempat bahwa iterator membuat Python luar biasa, dan saya pikir ini masih terjadi. Pelajari cukup banyak tentang iterator dan generator Python dan Anda akan tahu semua yang Anda butuhkan tentang pola Python khusus ini.

Rantai tanggung jawab

Pola ini memberi kita cara untuk menangani permintaan menggunakan metode yang berbeda, masing-masing menangani bagian tertentu dari permintaan tersebut. Anda tahu, salah satu prinsip terbaik untuk kode yang baik adalah prinsip Tanggung Jawab Tunggal .

Setiap bagian kode harus melakukan satu, dan hanya satu, hal.

Prinsip ini sangat terintegrasi dalam pola desain ini.

Misalnya, jika kita ingin memfilter beberapa konten, kita dapat menerapkan filter yang berbeda, masing-masing melakukan satu jenis pemfilteran yang tepat dan jelas. Filter ini dapat digunakan untuk menyaring kata-kata yang menyinggung, iklan, konten video yang tidak sesuai, dan sebagainya.

 class ContentFilter(object): def __init__(self, filters=None): self._filters = list() if filters is not None: self._filters += filters def filter(self, content): for filter in self._filters: content = filter(content) return content filter = ContentFilter([ offensive_filter, ads_filter, porno_video_filter]) filtered_content = filter.filter(content)

Memerintah

Ini adalah salah satu pola desain Python pertama yang saya terapkan sebagai programmer. Itu mengingatkan saya: Pola tidak ditemukan, mereka ditemukan . Mereka ada, kita hanya perlu menemukan dan menggunakannya. Saya menemukan ini untuk proyek luar biasa yang kami implementasikan bertahun-tahun yang lalu: editor XML WYSIWYM tujuan khusus. Setelah menggunakan pola ini secara intensif dalam kode, saya membaca lebih lanjut tentangnya di beberapa situs.

Pola perintah berguna dalam situasi ketika, untuk beberapa alasan, kita perlu memulai dengan mempersiapkan apa yang akan dieksekusi dan kemudian mengeksekusinya saat dibutuhkan. Keuntungannya adalah bahwa tindakan enkapsulasi sedemikian rupa memungkinkan pengembang Python untuk menambahkan fungsionalitas tambahan yang terkait dengan tindakan yang dieksekusi, seperti undo/redo, atau menyimpan riwayat tindakan dan sejenisnya.

Mari kita lihat seperti apa contoh sederhana dan sering digunakan:

 class RenameFileCommand(object): def __init__(self, from_name, to_name): self._from = from_name self._to = to_name def execute(self): os.rename(self._from, self._to) def undo(self): os.rename(self._to, self._from) class History(object): def __init__(self): self._commands = list() def execute(self, command): self._commands.append(command) command.execute() def undo(self): self._commands.pop().undo() history = History() history.execute(RenameFileCommand('docs/cv.doc', 'docs/cv-en.doc')) history.execute(RenameFileCommand('docs/cv1.doc', 'docs/cv-bg.doc')) history.undo() history.undo()

Pola Kreasi

Mari kita mulai dengan menunjukkan bahwa pola kreasi tidak umum digunakan dalam Python. Mengapa? Karena sifat bahasa yang dinamis.

Seseorang yang lebih bijak dari saya pernah mengatakan bahwa Pabrik dibangun ke dalam Python. Ini berarti bahwa bahasa itu sendiri memberi kita semua fleksibilitas yang kita butuhkan untuk membuat objek dengan cara yang cukup elegan; kita jarang perlu mengimplementasikan apa pun di atas, seperti Singleton atau Factory.

Dalam satu tutorial Pola Desain Python, saya menemukan deskripsi pola desain kreasi yang menyatakan desain ini "pola menyediakan cara untuk membuat objek sambil menyembunyikan logika pembuatan, daripada membuat objek langsung menggunakan operator baru ."

Itu cukup banyak meringkas masalahnya: Kami tidak memiliki operator baru di Python!

Namun demikian, mari kita lihat bagaimana kita dapat menerapkan beberapa, jika kita merasa kita dapat memperoleh keuntungan dengan menggunakan pola tersebut.

lajang

Pola Singleton digunakan ketika kita ingin menjamin bahwa hanya satu instance dari kelas tertentu yang ada selama runtime. Apakah kita benar-benar membutuhkan pola ini dengan Python? Berdasarkan pengalaman saya, lebih mudah untuk membuat satu instance dengan sengaja dan kemudian menggunakannya daripada menerapkan pola Singleton.

Tetapi jika Anda ingin mengimplementasikannya, berikut adalah beberapa kabar baik: Dengan Python, kita dapat mengubah proses instantiasi (bersama dengan hampir semua hal lainnya). Ingat metode __new__() yang saya sebutkan sebelumnya? Ini dia:

 class Logger(object): def __new__(cls, *args, **kwargs): if not hasattr(cls, '_logger'): cls._logger = super(Logger, cls ).__new__(cls, *args, **kwargs) return cls._logger

Dalam contoh ini, Logger adalah Singleton.

Ini adalah alternatif untuk menggunakan Singleton dengan Python:

• Gunakan modul.
• Buat satu instance di suatu tempat di tingkat atas aplikasi Anda, mungkin di file konfigurasi.
• Berikan instance ke setiap objek yang membutuhkannya. Itu adalah injeksi ketergantungan dan merupakan mekanisme yang kuat dan mudah dikuasai.

Injeksi Ketergantungan

Saya tidak bermaksud untuk membahas apakah injeksi ketergantungan adalah pola desain, tetapi saya akan mengatakan bahwa ini adalah mekanisme yang sangat baik untuk menerapkan kopling longgar, dan ini membantu membuat aplikasi kita dapat dipelihara dan diperpanjang. Gabungkan dengan Duck Typing dan Force akan menyertai Anda. Selalu.

Saya mencantumkannya di bagian pola kreasi dari posting ini karena berkaitan dengan pertanyaan kapan (atau bahkan lebih baik: di mana) objek dibuat. Itu dibuat di luar. Lebih baik untuk mengatakan bahwa objek tidak dibuat sama sekali di tempat kita menggunakannya, jadi ketergantungan tidak dibuat di tempat yang dikonsumsi. Kode konsumen menerima objek yang dibuat secara eksternal dan menggunakannya. Untuk referensi lebih lanjut, silakan baca jawaban yang paling banyak dipilih untuk pertanyaan Stackoverflow ini.

Ini adalah penjelasan yang bagus tentang injeksi ketergantungan dan memberi kita ide bagus tentang potensi teknik khusus ini. Pada dasarnya jawabannya menjelaskan masalah dengan contoh berikut: Jangan minum sendiri dari lemari es, nyatakan kebutuhannya. Beri tahu orang tua Anda bahwa Anda perlu minum saat makan siang.

Python menawarkan semua yang kita butuhkan untuk mengimplementasikannya dengan mudah. Pikirkan tentang kemungkinan implementasinya dalam bahasa lain seperti Java dan C#, dan Anda akan segera menyadari keindahan Python.

Mari kita pikirkan tentang contoh sederhana injeksi ketergantungan:

 class Command: def __init__(self, authenticate=None, authorize=None): self.authenticate = authenticate or self._not_authenticated self.authorize = authorize or self._not_autorized def execute(self, user, action): self.authenticate(user) self.authorize(user, action) return action() if in_sudo_mode: command = Command(always_authenticated, always_authorized) else: command = Command(config.authenticate, config.authorize) command.execute(current_user, delete_user_action)

Kami menyuntikkan metode authenticator dan authorizer di kelas Command. Yang dibutuhkan kelas Command adalah menjalankannya dengan sukses tanpa mengganggu detail implementasi. Dengan cara ini, kita dapat menggunakan kelas Command dengan mekanisme otentikasi dan otorisasi apa pun yang kita putuskan untuk digunakan saat runtime.

Kami telah menunjukkan cara menyuntikkan dependensi melalui konstruktor, tetapi kami dapat dengan mudah menyuntikkannya dengan mengatur langsung properti objek, membuka lebih banyak potensi:

 command = Command() if in_sudo_mode: command.authenticate = always_authenticated command.authorize = always_authorized else: command.authenticate = config.authenticate command.authorize = config.authorize command.execute(current_user, delete_user_action)

Masih banyak yang harus dipelajari tentang injeksi ketergantungan; orang yang penasaran akan mencari IoC, misalnya.

Tetapi sebelum Anda melakukannya, baca jawaban Stackoverflow lainnya, yang paling banyak dipilih untuk pertanyaan ini.

Sekali lagi, kami baru saja mendemonstrasikan bagaimana menerapkan pola desain yang luar biasa ini dengan Python hanyalah masalah penggunaan fungsionalitas bawaan dari bahasa tersebut.

Jangan lupa apa artinya semua ini: Teknik injeksi ketergantungan memungkinkan pengujian unit yang sangat fleksibel dan mudah. Bayangkan sebuah arsitektur di mana Anda dapat mengubah penyimpanan data dengan cepat. Mengejek database menjadi tugas yang sepele, bukan? Untuk informasi lebih lanjut, Anda dapat melihat Pengantar Toptal untuk Mengejek dengan Python.

Anda mungkin juga ingin meneliti pola desain Prototipe , Pembuat , dan Pabrik .

Pola Struktural

Tatapan

Ini mungkin pola desain Python yang paling terkenal.

Bayangkan Anda memiliki sistem dengan jumlah objek yang cukup banyak. Setiap objek menawarkan serangkaian metode API yang kaya. Anda dapat melakukan banyak hal dengan sistem ini, tetapi bagaimana dengan menyederhanakan antarmuka? Mengapa tidak menambahkan objek antarmuka yang mengekspos subset semua metode API yang dipikirkan dengan matang? Sebuah Fasad!

Contoh pola desain Fasad Python:

 class Car(object): def __init__(self): self._tyres = [Tyre('front_left'), Tyre('front_right'), Tyre('rear_left'), Tyre('rear_right'), ] self._tank = Tank(70) def tyres_pressure(self): return [tyre.pressure for tyre in self._tyres] def fuel_level(self): return self._tank.level

Tidak mengherankan, tidak ada trik, kelas Car adalah Fasad , dan itu saja.

Adaptor

Jika Fasad digunakan untuk penyederhanaan antarmuka, Adaptor semuanya tentang mengubah antarmuka. Seperti menggunakan sapi ketika sistem mengharapkan bebek.

Katakanlah Anda memiliki metode kerja untuk mencatat informasi ke tujuan tertentu. Metode Anda mengharapkan tujuan memiliki metode write() (seperti yang dimiliki setiap objek file, misalnya).

 def log(message, destination): destination.write('[{}] - {}'.format(datetime.now(), message))

Saya akan mengatakan itu adalah metode yang ditulis dengan baik dengan injeksi ketergantungan, yang memungkinkan untuk diperpanjang. Katakanlah Anda ingin masuk ke beberapa soket UDP alih-alih ke file, Anda tahu cara membuka soket UDP ini tetapi satu-satunya masalah adalah objek socket tidak memiliki metode write() . Anda membutuhkan Adaptor !

 import socket class SocketWriter(object): def __init__(self, ip, port): self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._ip = ip self._port = port def write(self, message): self._socket.send(message, (self._ip, self._port)) def log(message, destination): destination.write('[{}] - {}'.format(datetime.now(), message)) upd_logger = SocketWriter('1.2.3.4', '9999') log('Something happened', udp_destination)

Tapi mengapa saya menemukan adaptor begitu penting? Nah, ketika secara efektif dikombinasikan dengan injeksi ketergantungan, itu memberi kita fleksibilitas yang besar. Mengapa mengubah kode kami yang telah teruji untuk mendukung antarmuka baru ketika kami hanya dapat mengimplementasikan adaptor yang akan menerjemahkan antarmuka baru ke antarmuka yang sudah dikenal?

Anda juga harus memeriksa dan menguasai pola desain jembatan dan proxy , karena kesamaannya dengan adapter . Pikirkan betapa mudahnya penerapannya dalam Python, dan pikirkan berbagai cara Anda dapat menggunakannya dalam proyek Anda.

Penghias

Oh betapa beruntungnya kita! Dekorator sangat bagus, dan kami sudah mengintegrasikannya ke dalam bahasa. Yang paling saya sukai di Python adalah menggunakannya mengajarkan kita untuk menggunakan praktik terbaik. Bukannya kita tidak harus sadar tentang praktik terbaik (dan pola desain, khususnya), tetapi dengan Python saya merasa seperti mengikuti praktik terbaik, terlepas dari itu. Secara pribadi, saya menemukan praktik terbaik Python bersifat intuitif dan alami, dan ini adalah sesuatu yang dihargai oleh pengembang pemula dan elit.

Pola dekorator adalah tentang memperkenalkan fungsionalitas tambahan dan khususnya, melakukannya tanpa menggunakan pewarisan.

Jadi, mari kita lihat bagaimana kita mendekorasi sebuah metode tanpa menggunakan fungsionalitas Python bawaan. Berikut adalah contoh langsung.

 def execute(user, action): self.authenticate(user) self.authorize(user, action) return action()

Apa yang tidak begitu baik di sini adalah bahwa fungsi execute melakukan lebih dari sekadar mengeksekusi sesuatu. Kami tidak mengikuti prinsip tanggung jawab tunggal untuk surat itu.

Akan lebih baik untuk menulis hanya sebagai berikut:

 def execute(action): return action()

Kami dapat menerapkan fungsi otorisasi dan otentikasi apa pun di tempat lain, di dekorator , seperti:

 def execute(action, *args, **kwargs): return action() def autheticated_only(method): def decorated(*args, **kwargs): if check_authenticated(kwargs['user']): return method(*args, **kwargs) else: raise UnauthenticatedError return decorated def authorized_only(method): def decorated(*args, **kwargs): if check_authorized(kwargs['user'], kwargs['action']): return method(*args, **kwargs) else: raise UnauthorizeddError return decorated execute = authenticated_only(execute) execute = authorized_only(execute)

Sekarang metode execute() adalah:

• Sederhana untuk dibaca
• Hanya melakukan satu hal (setidaknya ketika melihat kode)
• Dihiasi dengan otentikasi
• Dihiasi dengan otorisasi

Kami menulis hal yang sama menggunakan sintaks dekorator terintegrasi Python:

 def autheticated_only(method): def decorated(*args, **kwargs): if check_authenticated(kwargs['user']): return method(*args, **kwargs ) else: raise UnauthenticatedError return decorated def authorized_only(method): def decorated(*args, **kwargs): if check_authorized(kwargs['user'], kwargs['action']): return method(*args, **kwargs) else: raise UnauthorizedError return decorated @authorized_only @authenticated_only def execute(action, *args, **kwargs): return action()

Penting untuk dicatat bahwa Anda tidak terbatas pada fungsi sebagai dekorator. Seorang dekorator dapat melibatkan seluruh kelas. Satu-satunya persyaratan adalah mereka harus dapat dipanggil . Tapi kami tidak punya masalah dengan itu; kita hanya perlu mendefinisikan metode __call__(self) .

Anda mungkin juga ingin melihat lebih dekat modul functools Python. Ada banyak yang bisa ditemukan di sana!

Kesimpulan

Saya telah menunjukkan betapa alami dan mudahnya menggunakan pola desain Python, tetapi saya juga telah menunjukkan bagaimana pemrograman dengan Python juga harus mudah.

"Sederhana lebih baik daripada rumit," ingat itu? Mungkin Anda telah memperhatikan bahwa tidak ada pola desain yang dijelaskan secara lengkap dan formal. Tidak ada implementasi skala penuh yang kompleks yang ditampilkan. Anda perlu "merasakan" dan menerapkannya dengan cara yang paling sesuai dengan gaya dan kebutuhan Anda. Python adalah bahasa yang hebat dan memberi Anda semua kekuatan yang Anda butuhkan untuk menghasilkan kode yang fleksibel dan dapat digunakan kembali.

Namun, itu memberi Anda lebih dari itu. Ini memberi Anda "kebebasan" untuk menulis kode yang sangat buruk . Jangan lakukan itu! Jangan Ulangi Diri Sendiri (KERING) dan jangan pernah menulis baris kode lebih dari 80 karakter. Dan jangan lupa untuk menggunakan pola desain jika ada; ini adalah salah satu cara terbaik untuk belajar dari orang lain dan memperoleh kekayaan pengalaman mereka secara gratis.