Poin Penting
1. Tulis kode yang bersih, mudah dibaca, dan mudah dipelihara
Satu-satunya ukuran yang valid untuk kualitas kode: WTFs/menit
Keterbacaan adalah hal yang utama. Kode yang bersih harus mudah dipahami oleh pengembang lain. Kode tersebut harus sederhana, elegan, dan bebas dari kekacauan. Usahakan untuk menulis kode yang jelas menyatakan maksudnya tanpa perlu komentar yang berlebihan. Gunakan nama variabel dan fungsi yang bermakna, jaga agar fungsi tetap kecil dan fokus, serta atur kode secara logis.
Pemeliharaan memungkinkan evolusi. Kode yang sulit diubah menjadi beban. Rancang kode Anda agar fleksibel dan modular sehingga dapat beradaptasi dengan kebutuhan yang berubah. Ikuti prinsip-prinsip seperti DRY (Don't Repeat Yourself) dan SOLID untuk menciptakan sistem yang loosely coupled dan highly cohesive. Refactor tanpa ampun untuk meningkatkan struktur kode tanpa mengubah perilakunya.
Kode yang bersih memberikan keuntungan. Meskipun menulis kode yang bersih memerlukan usaha lebih di awal, ini menghemat waktu dan mengurangi sakit kepala dalam jangka panjang. Kode yang bersih lebih mudah untuk di-debug, diperluas, dan dipelihara. Ini memungkinkan pengembang bekerja lebih efisien dan mengurangi risiko memperkenalkan bug saat melakukan perubahan. Jadikan kode yang bersih sebagai bagian inti dari praktik pengembangan Anda.
2. Ikuti konvensi penamaan yang bermakna
Nama variabel, fungsi, atau kelas harus menjawab semua pertanyaan besar. Nama tersebut harus memberi tahu Anda mengapa ia ada, apa yang dilakukannya, dan bagaimana cara menggunakannya.
Gunakan nama yang mengungkapkan maksud. Pilih nama yang jelas menyampaikan tujuan dan perilaku variabel, fungsi, dan kelas. Hindari nama satu huruf atau singkatan yang membingungkan. Gunakan nama yang dapat diucapkan dan mudah dicari. Contohnya:
- Buruk: d (waktu yang berlalu dalam hari)
- Baik: elapsedTimeInDays
Konsisten dan tepat. Gunakan konvensi penamaan yang konsisten di seluruh basis kode Anda. Jadilah tepat untuk menghindari ambiguitas - misalnya, gunakan perbedaan yang bermakna seperti getActiveAccounts() dan getActiveAccountInfo(). Hindari pengkodean atau awalan yang menambah kebisingan tanpa nilai. Nama kelas harus berupa kata benda, nama metode harus berupa kata kerja.
Panjang nama harus sesuai dengan cakupan. Gunakan nama yang lebih panjang dan deskriptif untuk variabel dan fungsi dengan cakupan yang lebih besar. Nama pendek dapat diterima untuk cakupan kecil dan lokal. Panjang nama harus proporsional dengan cakupan penggunaannya. Optimalkan untuk keterbacaan dan pemahaman dalam konteks di mana nama tersebut digunakan.
3. Jaga agar fungsi tetap kecil dan fokus
Fungsi harus melakukan satu hal. Mereka harus melakukannya dengan baik. Mereka harus melakukannya saja.
Kecil itu indah. Fungsi harus kecil - biasanya 5-10 baris panjangnya. Mereka harus muat di satu layar dan langsung dapat dipahami. Ekstrak kode ke dalam fungsi pembantu yang diberi nama dengan baik daripada menulis fungsi yang panjang dan kompleks. Fungsi kecil lebih mudah dipahami, diuji, dan dipelihara.
Lakukan satu hal dengan baik. Setiap fungsi harus memiliki satu tujuan yang jelas. Jika sebuah fungsi melakukan beberapa hal, ekstrak hal-hal tersebut ke dalam fungsi terpisah. Tanda-tanda bahwa sebuah fungsi melakukan terlalu banyak termasuk:
- Beberapa tingkat abstraksi
- Beberapa bagian atau blok kode
- Banyak parameter
Pertahankan satu tingkat abstraksi. Pernyataan dalam sebuah fungsi harus berada pada tingkat abstraksi yang sama. Jangan campurkan logika tingkat tinggi dengan detail tingkat rendah. Ekstrak operasi tingkat rendah ke dalam fungsi terpisah. Ini meningkatkan keterbacaan dengan menjaga fungsi tetap fokus dan sederhana secara konseptual.
4. Praktikkan pemformatan dan organisasi yang tepat
Pemformatan kode adalah tentang komunikasi, dan komunikasi adalah urusan utama pengembang profesional.
Pemformatan yang konsisten itu penting. Gunakan indentasi, pemisahan baris, dan spasi yang konsisten di seluruh kode Anda. Ini meningkatkan keterbacaan dan mengurangi beban kognitif. Sepakati standar pemformatan dengan tim Anda dan gunakan alat otomatis untuk menegakkannya. Pedoman pemformatan kunci meliputi:
- Indentasi yang tepat
- Penempatan kurung yang konsisten
- Pemisahan baris yang logis
- Ruang kosong yang sesuai
Atur kode secara logis. Kelompokkan kode yang terkait bersama dan pisahkan kode yang tidak terkait. Gunakan baris kosong untuk membuat pemisahan "paragraf" antara bagian logis. Tempatkan fungsi yang terkait berdekatan satu sama lain. Jaga agar file tetap fokus pada satu konsep atau komponen. Pecah file besar menjadi file yang lebih kecil dan lebih fokus jika perlu.
Ikuti konvensi standar. Patuhi konvensi standar untuk bahasa dan komunitas Anda. Ini membuat kode Anda lebih familiar dan dapat diakses oleh pengembang lain. Misalnya, dalam Java:
- Nama kelas menggunakan PascalCase
- Nama metode menggunakan camelCase
- Konstanta menggunakan ALL_CAPS
5. Kelola ketergantungan dan hindari duplikasi
Duplikasi mungkin adalah akar dari semua kejahatan dalam perangkat lunak.
Hilangkan duplikasi. Kode yang diduplikasi adalah kesempatan yang terlewat untuk abstraksi. Ketika Anda melihat duplikasi, ekstrak kode yang umum ke dalam fungsi atau kelas yang dapat digunakan kembali. Ini meningkatkan pemeliharaan dengan memusatkan logika dan mengurangi risiko perubahan yang tidak konsisten. Jenis duplikasi yang perlu diperhatikan:
- Blok kode identik
- Algoritma serupa dengan variasi kecil
- Rantai switch/case atau if/else yang diulang
Kelola ketergantungan dengan hati-hati. Minimalkan ketergantungan antara modul untuk mengurangi coupling. Gunakan dependency injection dan inversion of control untuk membuat kode lebih modular dan dapat diuji. Ikuti Prinsip Inversi Ketergantungan - bergantung pada abstraksi, bukan konkret. Ini membuat kode Anda lebih fleksibel dan lebih mudah diubah.
Gunakan prinsip pengetahuan minimal. Sebuah modul tidak boleh mengetahui tentang bagian dalam objek yang dimanipulasinya. Ini mengurangi coupling antara modul. Misalnya, gunakan Hukum Demeter - sebuah metode hanya boleh memanggil metode pada:
- Objeknya sendiri
- Objek yang diteruskan sebagai parameter
- Objek yang dibuatnya
- Objek komponen langsungnya
6. Tangani kesalahan dengan baik
Penanganan kesalahan itu penting, tetapi jika mengaburkan logika, itu salah.
Gunakan pengecualian daripada kode kesalahan. Pengecualian lebih bersih dan tidak mengacaukan logika utama kode Anda. Mereka memungkinkan penanganan kesalahan dipisahkan dari jalur yang baik. Saat menggunakan pengecualian:
- Buat pesan kesalahan yang informatif
- Berikan konteks dengan pengecualian
- Definisikan kelas pengecualian berdasarkan kebutuhan pemanggil
Jangan kembalikan null. Mengembalikan null menyebabkan pengecualian pointer null dan mengacaukan kode dengan pemeriksaan null. Sebagai gantinya:
- Kembalikan koleksi kosong daripada null untuk daftar
- Gunakan pola Objek Null
- Gunakan Optional dalam Java atau Maybe dalam bahasa fungsional
Tulis pernyataan try-catch-finally terlebih dahulu. Mulailah dengan try-catch-finally saat menulis kode yang bisa melempar pengecualian. Ini membantu mendefinisikan cakupan dan harapan untuk kode pemanggil. Ini memastikan bahwa sumber daya dikelola dan dilepaskan dengan benar, bahkan dalam skenario kesalahan.
7. Tulis unit test yang menyeluruh
Kode uji sama pentingnya dengan kode produksi.
Ikuti tiga hukum TDD. Test-Driven Development (TDD) meningkatkan kualitas dan desain kode:
- Tulis uji yang gagal sebelum menulis kode produksi
- Tulis hanya cukup dari uji untuk menunjukkan kegagalan
- Tulis hanya cukup kode produksi untuk lulus uji
Jaga agar uji tetap bersih dan dapat dipelihara. Terapkan standar kualitas kode yang sama pada uji Anda seperti pada kode produksi Anda. Refactor dan tingkatkan kode uji secara teratur. Uji yang terstruktur dengan baik berfungsi sebagai dokumentasi dan memungkinkan refactoring kode produksi tanpa rasa takut.
Targetkan cakupan uji yang komprehensif. Tulis uji yang mencakup kasus tepi, kondisi batas, dan skenario kesalahan - bukan hanya jalur yang baik. Gunakan alat cakupan kode untuk mengidentifikasi celah dalam cakupan uji. Ingat bahwa cakupan 100% tidak menjamin kode bebas bug, tetapi memberikan kepercayaan dalam refactoring dan perubahan.
8. Refactor kode secara terus-menerus
Tinggalkan tempat perkemahan lebih bersih daripada saat Anda menemukannya.
Refactor secara oportunistik. Tingkatkan struktur kode kapan pun Anda bekerja pada sepotong kode. Ikuti Aturan Pramuka: tinggalkan kode lebih baik daripada saat Anda menemukannya. Perbaikan kecil dan bertahap akan terakumulasi seiring waktu dan mencegah kerusakan kode. Teknik refactoring umum meliputi:
- Mengekstrak metode atau kelas
- Mengganti nama untuk kejelasan
- Menyederhanakan kondisi yang kompleks
- Menghapus duplikasi
Refactor dengan aman menggunakan uji. Selalu miliki rangkaian uji yang solid sebelum melakukan refactoring. Lakukan perubahan kecil dan bertahap dan jalankan uji secara berkala. Ini memberi Anda kepercayaan bahwa perubahan Anda tidak merusak fungsionalitas yang ada. Gunakan alat refactoring otomatis jika tersedia untuk mengurangi risiko memperkenalkan kesalahan.
Seimbangkan refactoring dengan memberikan nilai. Meskipun refactoring yang berkelanjutan itu penting, jangan biarkan hal itu menghambat kemajuan. Targetkan "cukup baik" daripada kesempurnaan. Fokuskan upaya refactoring pada area kode yang paling bermasalah atau sering diubah. Komunikasikan nilai refactoring kepada pemangku kepentingan untuk memastikan dukungan untuk perbaikan kode yang berkelanjutan.
9. Terapkan prinsip pemrograman berorientasi objek dan fungsional
Objek menyembunyikan data mereka di balik abstraksi dan mengekspos fungsi yang beroperasi pada data tersebut. Struktur data mengekspos data mereka dan tidak memiliki fungsi yang bermakna.
Gunakan prinsip berorientasi objek dengan bijak. Terapkan prinsip seperti enkapsulasi, pewarisan, dan polimorfisme untuk menciptakan desain yang fleksibel dan modular. Ikuti prinsip SOLID:
- Prinsip Tanggung Jawab Tunggal
- Prinsip Terbuka-Tertutup
- Prinsip Substitusi Liskov
- Prinsip Pemisahan Antarmuka
- Prinsip Inversi Ketergantungan
Manfaatkan konsep pemrograman fungsional. Bahkan dalam bahasa berorientasi objek, teknik pemrograman fungsional dapat menghasilkan kode yang lebih bersih:
- Fungsi murni tanpa efek samping
- Data yang tidak dapat diubah
- Fungsi tingkat tinggi
- Komposisi fungsi
Pilih pendekatan yang tepat untuk masalah. Paradigma berorientasi objek dan fungsional masing-masing memiliki kekuatan dan kelemahan. Gunakan desain berorientasi objek ketika Anda perlu memodelkan domain yang kompleks dengan perilaku. Gunakan pendekatan fungsional untuk transformasi data dan jalur pemrosesan. Banyak bahasa modern mendukung pendekatan hibrida, memungkinkan Anda menggunakan alat terbaik untuk setiap bagian dari sistem Anda.
10. Pertimbangkan konkurensi dengan hati-hati
Konkurensi adalah strategi pemisahan. Ini membantu kita memisahkan apa yang dilakukan dari kapan itu dilakukan.
Pahami tantangan konkurensi. Pemrograman konkuren memperkenalkan kompleksitas dan potensi bug yang halus. Masalah umum meliputi:
- Kondisi balapan
- Deadlock
- Sinyal yang terlewat
- Masalah visibilitas memori
Pisahkan kekhawatiran konkurensi. Jaga agar kode yang terkait dengan konkurensi terpisah dari kode lainnya. Ini membuatnya lebih mudah untuk dipahami dan diuji. Gunakan abstraksi seperti Executors, Futures, dan Actors untuk mengelola konkurensi daripada bekerja dengan thread mentah.
Utamakan ketidakberubahan dan fungsi murni. Objek yang tidak dapat diubah dan fungsi murni secara inheren aman untuk thread. Mereka menghilangkan banyak masalah konkurensi dengan menghindari keadaan yang dapat diubah yang dibagikan. Ketika keadaan yang dapat diubah diperlukan, gunakan teknik sinkronisasi yang tepat dan pertimbangkan untuk menggunakan variabel atom atau koleksi konkuren.
Terakhir diperbarui:
FAQ
What's "Clean Code: A Handbook of Agile Software Craftsmanship" about?
- Focus on Clean Code: "Clean Code" by Robert C. Martin emphasizes writing code that is easy to read, understand, and maintain.
- Professionalism in Coding: It argues that clean code is a hallmark of professionalism in software development.
- Practical Advice: The book provides guidelines, examples, and case studies to help developers write clean and efficient code.
Why should I read "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Improve Coding Skills: It teaches how to write code that is clean, efficient, and maintainable.
- Learn from Experts: Part of the Robert C. Martin series, known for its technical and pragmatic approach.
- Long-term Benefits: Writing clean code reduces maintenance costs and makes you a more valuable developer.
What are the key takeaways of "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Code Readability: Emphasizes that code should be easy to read and understand.
- Single Responsibility Principle: Advocates for each class or function to have one reason to change.
- Continuous Improvement: Encourages developers to continuously improve their code, following the Boy Scout Rule.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" define clean code?
- Elegance and Efficiency: Clean code is described as elegant and efficient, with minimal dependencies.
- Readable and Maintainable: It should read like well-written prose, making the designer's intent clear.
- Focused and Single-minded: Each function, class, and module should have a single, clear purpose.
What is the Single Responsibility Principle in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- One Reason to Change: A class or module should have one, and only one, reason to change.
- Improves Cohesion: Ensures that classes are cohesive, with closely related methods and variables.
- Facilitates Maintenance: Makes the code easier to maintain and extend, reducing the impact of changes.
What is the "Boy Scout Rule" mentioned in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Suggests leaving the codebase cleaner than you found it.
- Small, Incremental Changes: Encourages making small improvements, like renaming variables or breaking up functions.
- Professional Responsibility: Presented as a professional responsibility to ensure maintainability.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" approach Test-Driven Development (TDD)?
- Fundamental Discipline: TDD is crucial for writing clean, reliable code.
- Three Laws of TDD: Write a failing test first, write code to pass the test, then refactor.
- Benefits: Helps catch bugs early and improves code design.
What are "code smells" according to "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Definition: Indicators of potential problems that hinder readability or maintainability.
- Examples: Long methods, large classes, and duplicated code.
- Addressing Smells: Provides heuristics and refactoring techniques to improve code quality.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" suggest handling exceptions?
- Prefer Exceptions: Use exceptions instead of error codes for better context and management.
- Provide Context: Include meaningful messages and context when throwing exceptions.
- Avoid Checked Exceptions: Suggests using unchecked exceptions for cleaner code.
What role do unit tests play in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Ensure Code Quality: Unit tests ensure code works as intended and remains maintainable.
- Test-Driven Development: Advocates writing tests before production code.
- Clean and Readable Tests: Tests should be as clean and readable as production code.
What is the role of refactoring in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Refactoring improves code structure and readability without changing functionality.
- Techniques: Provides techniques like Extract Method and Rename Variable to enhance code quality.
- Fearless Refactoring: With comprehensive tests, developers can refactor confidently.
What are the best quotes from "Clean Code: A Handbook of Agile Software Craftsmanship" and what do they mean?
- "Clean code does one thing well." Emphasizes focus and clarity in code.
- "Leave the campground cleaner than you found it." Encourages continuous improvement of the codebase.
- "You know you are working on clean code when each routine you read turns out to be pretty much what you expected." Highlights the importance of readability and predictability.
Ulasan
Clean Code mendapatkan ulasan yang sebagian besar positif berkat prinsip-prinsipnya dalam menulis kode yang dapat dibaca dan dipelihara. Pembaca menghargai saran praktis mengenai penamaan, fungsi, dan pengujian. Fokus buku ini pada Java dan beberapa pedoman yang terlalu ketat sering menjadi kritik. Banyak yang menganggapnya sebagai bacaan wajib bagi para pengembang, meskipun beberapa merasa kurang berguna bagi programmer berpengalaman. Studi kasus dan contoh refactoring dipuji oleh sebagian orang, tetapi dikritik oleh yang lain sebagai berlebihan. Secara keseluruhan, para peninjau sepakat bahwa buku ini menawarkan wawasan berharga tentang kualitas kode, meskipun tidak semua saran dapat diterapkan secara universal.
Similar Books
