Poin Penting
1. Kode bersih itu mudah dibaca, sederhana, dan ekspresif
Kode bersih selalu terlihat seperti ditulis oleh seseorang yang peduli.
Kejelasan adalah kunci. Kode bersih ditandai dengan keterbacaan dan kesederhanaannya. Kode tersebut harus mudah dipahami, dimodifikasi, dan dipelihara oleh programmer lain. Ini meliputi penggunaan nama yang jelas dan bermakna, menjaga fungsi dan kelas agar kecil dan fokus, serta mengorganisasi kode secara logis.
Kode ekspresif menyampaikan maksud. Kode bersih harus mampu mengungkapkan niat programmer tanpa perlu komentar yang berlebihan. Hal ini dicapai melalui pemilihan nama yang tepat, fungsi kecil yang melakukan satu hal dengan baik, dan struktur keseluruhan yang jelas. Kode itu sendiri harus bercerita, sehingga pembaca mudah mengikuti logika dan tujuan setiap komponennya.
Perbaikan berkelanjutan sangat penting. Menulis kode bersih adalah proses yang terus-menerus dan membutuhkan perhatian serta refaktorisasi secara rutin. Programmer sebaiknya mengikuti Aturan Pramuka: "Tinggalkan tempat perkemahan lebih bersih daripada saat kamu menemukannya." Artinya, selalu cari kesempatan untuk meningkatkan kejelasan dan struktur kode, meskipun hanya sedikit, setiap kali melakukan perubahan atau penambahan.
2. Nama yang bermakna meningkatkan kejelasan dan pemeliharaan kode
Nama variabel, fungsi, atau kelas harus menjawab semua pertanyaan besar. Harus memberi tahu mengapa ia ada, apa yang dilakukannya, dan bagaimana cara menggunakannya.
Pilih nama yang deskriptif. Nama harus bisa menjelaskan dirinya sendiri dan mengungkapkan maksud di balik variabel, fungsi, dan kelas. Hindari nama satu huruf, singkatan, atau kode yang membingungkan sehingga memerlukan pemetaan mental untuk memahami tujuannya.
Gunakan konvensi penamaan secara konsisten. Terapkan dan patuhi konvensi penamaan standar sesuai bahasa pemrograman dan tim Anda. Contohnya:
- CamelCase untuk nama kelas (misal: CustomerOrder)
- camelCase untuk nama variabel dan fungsi (misal: totalAmount)
- ALL_CAPS untuk konstanta (misal: MAX_SIZE)
Hindari informasi yang menyesatkan dan kebisingan. Jangan gunakan nama yang bisa membingungkan atau menyesatkan. Misalnya, jangan gunakan 'list' dalam nama variabel jika itu bukan sebuah List. Juga, hindari kata-kata yang berlebihan atau tidak bermakna seperti 'data' atau 'info' jika tidak menambah nilai.
3. Fungsi harus kecil, melakukan satu hal, dan beroperasi pada satu tingkat abstraksi
Fungsi harus melakukan satu hal. Mereka harus melakukannya dengan baik. Mereka hanya harus melakukannya.
Jaga fungsi agar kecil. Fungsi idealnya tidak lebih dari 20 baris. Ini membuatnya lebih mudah dibaca, dipahami, dan dipelihara. Fungsi yang kecil juga lebih mudah diberi nama yang tepat, diuji, dan digunakan ulang.
Prinsip tanggung jawab tunggal. Setiap fungsi harus memiliki satu tujuan yang jelas. Jika sebuah fungsi melakukan banyak hal, sebaiknya dipecah menjadi fungsi-fungsi yang lebih kecil dan fokus. Ini meningkatkan keterbacaan dan membuat kode lebih modular serta mudah diubah.
Tingkat abstraksi yang konsisten. Dalam sebuah fungsi, semua operasi harus berada pada tingkat abstraksi yang sama. Mencampur logika tingkat tinggi dengan detail tingkat rendah membuat fungsi sulit dipahami dan dipelihara. Gunakan teknik refaktorisasi "Extract Method" untuk memisahkan tingkat abstraksi yang berbeda ke fungsi terpisah.
4. Komentar harus minimal dan benar-benar diperlukan
Penggunaan komentar yang tepat adalah untuk mengkompensasi kegagalan kita dalam mengekspresikan diri melalui kode.
Kode harus bisa menjelaskan dirinya sendiri. Kode yang ditulis dengan baik, nama yang jelas, dan struktur yang rapi seringkali menghilangkan kebutuhan komentar. Sebelum menambahkan komentar, pertimbangkan apakah Anda bisa merombak kode agar maksudnya lebih jelas.
Gunakan komentar dengan bijak. Komentar yang baik menjelaskan mengapa sesuatu dilakukan, bukan bagaimana caranya. Komentar harus memberikan konteks atau klarifikasi yang tidak bisa diungkapkan hanya dengan kode. Jenis komentar yang berguna meliputi:
- Komentar legal (hak cipta, lisensi)
- Penjelasan maksud atau algoritma
- Peringatan konsekuensi
- Komentar TODO (digunakan dengan hemat)
Hindari komentar yang berlebihan atau menyesatkan. Jangan tulis komentar yang hanya mengulang apa yang sudah jelas dari kode. Komentar yang usang atau salah lebih buruk daripada tidak ada komentar sama sekali karena bisa menyesatkan pembaca. Selalu tinjau dan perbarui komentar bersamaan dengan kode yang dijelaskan.
5. Format yang tepat meningkatkan keterbacaan kode
Format kode adalah tentang komunikasi, dan komunikasi adalah prioritas utama pengembang profesional.
Gaya konsisten itu penting. Tetapkan dan ikuti gaya format yang konsisten di seluruh basis kode Anda. Ini meliputi:
- Indentasi
- Pemisah baris
- Penempatan kurung kurawal
- Spasi di sekitar operator dan kata kunci
Format vertikal. Susun kode secara vertikal untuk meningkatkan keterbacaan:
- Dekatkan konsep yang terkait
- Pisahkan konsep yang tidak terkait
- Deklarasikan variabel dekat dengan penggunaannya
- Tempatkan fungsi yang saling bergantung berdekatan
Format horizontal. Jaga agar baris kode tidak terlalu panjang (biasanya 80-120 karakter) agar tidak perlu menggulir horizontal. Pecah pernyataan panjang menjadi beberapa baris secara logis. Gunakan spasi putih untuk memisahkan blok logis dalam satu baris.
6. Objek dan struktur data memiliki tujuan yang berbeda
Objek menyembunyikan data mereka di balik abstraksi dan mengekspos fungsi yang beroperasi pada data tersebut. Struktur data mengekspos data mereka dan tidak memiliki fungsi bermakna.
Objek vs struktur data. Objek mengenkapsulasi data dan mengekspos perilaku melalui metode. Mereka cocok untuk menambah tipe baru (kelas) tanpa mengubah perilaku yang ada. Struktur data, sebaliknya, mengekspos data dan tidak memiliki perilaku signifikan. Mereka cocok untuk menambah perilaku baru tanpa mengubah tipe data yang ada.
Pilih pendekatan yang tepat. Gunakan objek ketika Anda ingin sering menambah tipe baru tetapi menjaga perilaku tetap stabil. Gunakan struktur data ketika Anda ingin sering menambah perilaku baru tetapi menjaga tipe tetap stabil. Memahami perbedaan ini membantu merancang sistem yang lebih fleksibel dan mudah dipelihara.
Hukum Demeter. Untuk objek, ikuti Hukum Demeter: sebuah metode hanya boleh memanggil metode pada:
- Objek itu sendiri
- Parameter yang diterima
- Objek yang dibuatnya
- Komponen langsung dari objek tersebut
Prinsip ini membantu mengurangi keterkaitan antar bagian sistem.
7. Penanganan kesalahan harus bersih dan informatif
Penanganan kesalahan itu penting, tapi jika mengaburkan logika, itu salah.
Gunakan pengecualian daripada kode kesalahan. Pengecualian memberikan cara yang lebih bersih untuk menangani kesalahan dibandingkan kode kesalahan tradisional. Mereka memisahkan logika penanganan kesalahan dari kode utama, sehingga keduanya lebih mudah dipahami dan dipelihara.
Buat pesan kesalahan yang informatif. Pesan kesalahan harus memberikan konteks yang cukup untuk memahami apa yang salah dan di mana. Sertakan detail relevan seperti:
- Operasi apa yang sedang dicoba
- Kesalahan spesifik apa yang terjadi
- Nilai atau informasi status yang relevan
Tulis blok try-catch-finally terlebih dahulu. Saat menulis kode yang bisa melempar pengecualian, mulailah dengan menulis blok try-catch-finally. Ini membantu memastikan kode tahan terhadap kesalahan sejak awal dan kasus kesalahan dipertimbangkan dengan baik.
8. Unit test sangat penting untuk menjaga kode tetap bersih
Kode pengujian sama pentingnya dengan kode produksi.
Tulis tes terlebih dahulu. Ikuti praktik Test-Driven Development (TDD):
- Tulis tes yang gagal
- Tulis kode minimum untuk membuat tes lulus
- Refaktorisasi kode sambil menjaga tes tetap lulus
Pendekatan ini memastikan kode Anda dapat diuji sejak awal dan membantu mendorong desain yang baik.
Jaga tes tetap bersih. Terapkan standar kebersihan yang sama pada kode tes seperti pada kode produksi. Tes yang bersih adalah:
- Mudah dibaca
- Mudah dipelihara
- Dapat dipercaya
Ikuti prinsip F.I.R.S.T untuk tes:
- Fast: Tes harus berjalan cepat
- Independent: Tes tidak bergantung satu sama lain
- Repeatable: Tes dapat diulang di lingkungan mana pun
- Self-Validating: Tes menghasilkan output boolean (lulus/gagal)
- Timely: Tes ditulis tepat sebelum kode produksi
9. Kelas harus kecil, fokus, dan mengikuti Prinsip Tanggung Jawab Tunggal
Aturan pertama kelas adalah harus kecil. Aturan kedua adalah harus lebih kecil dari itu.
Jaga kelas tetap fokus. Sebuah kelas harus memiliki satu tanggung jawab yang jelas. Jika Anda tidak bisa menjelaskan tujuan kelas dalam sekitar 25 kata tanpa menggunakan "dan" atau "atau," kemungkinan kelas tersebut melakukan terlalu banyak hal.
Usahakan kohesi tinggi. Metode dan variabel dalam kelas harus saling terkait erat dan bekerja sama untuk memenuhi tanggung jawab kelas. Kohesi rendah biasanya menandakan kelas mencoba melakukan terlalu banyak dan sebaiknya dipecah.
Prinsip Open-Closed. Rancang kelas agar terbuka untuk ekstensi tapi tertutup untuk modifikasi. Ini sering melibatkan penggunaan abstraksi dan antarmuka agar fungsionalitas baru bisa ditambahkan tanpa mengubah kode yang sudah ada.
10. Konkruensi memerlukan desain dan implementasi yang hati-hati
Menulis program konkuren yang bersih itu sulit—sangat sulit.
Pahami tantangan konkruensi. Pemrograman konkuren membawa kompleksitas seperti:
- Kondisi balapan
- Deadlock
- Masalah kelangsungan hidup (liveness)
- Dampak performa
Pisahkan kode terkait konkruensi. Isolasikan kode yang berhubungan dengan konkruensi. Ini memudahkan pemahaman, pengujian, dan pemeliharaan bagian konkuren dan non-konkuren dari sistem Anda.
Gunakan pustaka dan kerangka kerja yang ada. Manfaatkan pustaka dan kerangka kerja konkruensi yang sudah teruji (misal: java.util.concurrent di Java) daripada mencoba mengimplementasikan kontrol konkruensi tingkat rendah sendiri. Alat ini sudah dioptimalkan dan diuji untuk pola konkruensi umum.
Tulis tes yang menyeluruh. Menguji kode konkuren itu menantang tapi sangat penting. Tulis tes yang:
- Membuat banyak thread
- Mengubah waktu dan penjadwalan
- Dijalankan berulang kali untuk meningkatkan peluang menemukan masalah yang tidak konsisten
- Menggunakan alat seperti thread sanitizer dan analisis statis untuk membantu mengidentifikasi bug konkruensi potensial
Terakhir diperbarui:
FAQ
What's Clean Code: A Handbook of Agile Software Craftsmanship about?
- Focus on Software Craftsmanship: The book emphasizes the importance of writing clean, maintainable code as a hallmark of professionalism in software development.
- Principles and Practices: It outlines various principles, patterns, and practices that help programmers write code that is not only functional but also easy to read and understand.
- Real-World Examples: Numerous examples of both good and bad code are included, demonstrating how to transform messy code into clean code through refactoring and disciplined practices.
Why should I read Clean Code by Robert C. Martin?
- Improve Coding Skills: Reading the book can significantly enhance your programming skills by teaching you how to write code that is easier to maintain and understand.
- Professional Development: It is a valuable resource for anyone looking to advance their career in software development, instilling a mindset of craftsmanship and quality.
- Practical Advice: The book provides practical advice that can be applied immediately in your coding practices, making it a useful guide for both novice and experienced programmers.
What are the key takeaways of Clean Code?
- Meaningful Names: The book stresses the importance of using intention-revealing names for variables, functions, and classes to enhance code readability and maintainability.
- Small Functions: Functions should be small and focused on a single task, adhering to the principle of "Do One Thing" to improve clarity and reduce complexity.
- Error Handling: Martin advocates for using exceptions rather than return codes for error handling, which helps keep the main logic of the code clean and unobscured.
What are the best quotes from Clean Code and what do they mean?
- "Clean code is a matter of discipline.": This quote emphasizes that writing clean code requires consistent effort and adherence to best practices, rather than relying on luck or talent alone.
- "Comments do not make up for bad code.": This highlights the idea that if code is poorly written, no amount of commenting can compensate for its lack of clarity and structure.
- "Leave the campground cleaner than you found it.": This metaphor encourages developers to improve the codebase with every change, ensuring that the code remains clean and maintainable over time.
How does Clean Code define clean code?
- Readable and Understandable: Clean code is defined as code that is easy to read and understand, allowing other developers to quickly grasp its purpose and functionality.
- Minimal Complexity: It should have minimal complexity, with each function and class focused on a single responsibility, making it easier to test and maintain.
- Well-Structured: Clean code is well-structured, following consistent formatting and naming conventions that enhance its clarity and reduce the cognitive load on the reader.
What is the Boy Scout Rule in Clean Code?
- Continuous Improvement: The Boy Scout Rule states that developers should "leave the campground cleaner than you found it," meaning that every time you work on code, you should strive to improve it.
- Small Changes Matter: This can be as simple as renaming a variable for clarity or refactoring a small function, which contributes to the overall cleanliness of the codebase.
- Professional Responsibility: Adhering to this rule reflects a professional attitude towards code quality and maintenance, fostering a culture of continuous improvement within a team.
What is the Single Responsibility Principle (SRP) in Clean Code?
- Definition of SRP: The SRP states that "a class should have one, and only one, reason to change." This means that each class should focus on a single responsibility or functionality.
- Benefits of SRP: Adhering to SRP leads to better organization of code, making it easier to understand, test, and maintain. It reduces the risk of changes in one area affecting unrelated parts of the code.
- Implementation Guidance: Martin provides practical advice on how to identify responsibilities and refactor classes to adhere to SRP, ensuring that code remains clean and manageable.
How does Clean Code address error handling?
- Use Exceptions: The book advocates for using exceptions rather than return codes for error handling, which helps keep the main logic of the code clean and unobscured.
- Separation of Concerns: Error handling should be separated from the main logic of the code, allowing developers to focus on the primary functionality without being bogged down by error-checking clutter.
- Provide Context: Exceptions should provide enough context to understand the source and nature of the error, making it easier to diagnose and fix issues when they arise.
What role does testing play in Clean Code?
- Foundation of Clean Code: Testing is considered a fundamental discipline in writing clean code. It ensures that the code behaves as expected and helps catch issues early in the development process.
- Fast and Reliable Tests: The book emphasizes that tests should be fast and reliable to encourage frequent execution. This helps maintain a clean codebase and reduces the risk of introducing bugs.
- Self-Validating Tests: Tests should be designed to be self-validating, meaning they should clearly indicate whether the code is functioning correctly. This reduces ambiguity and increases confidence in the code.
How does Clean Code suggest handling dependencies?
- Dependency Inversion Principle (DIP): The book explains that "high-level modules should not depend on low-level modules. Both should depend on abstractions." This principle encourages the use of interfaces and abstract classes to reduce coupling.
- Use of Dependency Injection: Martin recommends using dependency injection to manage dependencies, allowing for more flexible and testable code. This approach decouples the creation of dependencies from their usage.
- Benefits of Managing Dependencies: By managing dependencies effectively, developers can create systems that are easier to maintain and extend, leading to cleaner and more robust code.
What are some common code smells identified in Clean Code?
- Duplicated Code: This is a major code smell that indicates a lack of abstraction. The book advises eliminating duplication to improve maintainability and reduce errors.
- Long Methods: Methods that are too long can be difficult to understand and maintain. The book suggests breaking them down into smaller, more manageable functions.
- Excessive Comments: While comments can be helpful, excessive or redundant comments often indicate that the code itself is not clear. The goal should be to write self-explanatory code that requires minimal comments.
How can I apply the principles from Clean Code in my own projects?
- Start with Small Changes: Begin by applying the principles of clean code to small sections of your codebase. Refactor one class or function at a time to improve readability and maintainability.
- Write Tests First: Adopt Test-Driven Development (TDD) practices by writing tests before implementing new features. This ensures that your code is always covered by tests and helps maintain quality.
- Regularly Refactor: Make refactoring a regular part of your development process. Continuously look for opportunities to improve code structure and eliminate duplication, keeping your codebase clean and efficient.
Ulasan
Clean Code sangat dihargai sebagai bacaan penting bagi para pengembang perangkat lunak, karena memberikan wawasan berharga tentang cara menulis kode yang mudah dibaca dan dipelihara. Meskipun dipuji atas saran praktisnya mengenai konvensi penamaan, desain fungsi, dan pengujian, beberapa pembaca merasa buku ini terlalu berfokus pada Java dan terkadang memberikan rekomendasi yang terkesan ekstrem. Studi kasus dalam buku ini mendapat tanggapan beragam; ada yang menganggapnya sangat membantu, namun ada pula yang kurang terkesan. Meski memiliki kekurangan, banyak pengembang menganggap buku ini sebagai bacaan wajib yang telah secara signifikan meningkatkan praktik pengkodean dan pemahaman mereka tentang keahlian dalam pengembangan perangkat lunak.
Similar Books
