Bagaimana perpustakaan open source besar dipertahankan sementara memiliki kode yang jauh dari praktik "kode bersih"?

Saya masih belum berpengalaman untuk menulis kode berkualitas tinggi, jadi saya membaca buku-buku yang membahas masalah seperti Clean Code oleh Robert C. Martin, dan terus memeriksa kode perpustakaan terkenal untuk meningkatkan keterampilan saya.

Meskipun banyak perpustakaan open source telah dipelihara selama bertahun-tahun, yang berarti sangat tidak mungkin mereka tidak berada di jalur yang benar, saya menemukan kode di banyak dari mereka jauh dari prinsip-prinsip yang ditujukan untuk menulis kode bersih - misalnya metode yang mengandung ratusan baris kode.

Jadi pertanyaan saya adalah: Apakah prinsip-prinsip kode bersih terlalu dibatasi, dan kita dapat melakukannya tanpa banyak perpustakaan seperti ini? Jika tidak, bagaimana perpustakaan besar dikelola tanpa mempertimbangkan banyak dari prinsip-prinsip ini?

Saya akan menghargai klarifikasi singkat apa pun. Saya minta maaf jika pertanyaan itu tampaknya konyol dari seorang pemula.

SUNTING

Lihat contoh ini di perpustakaan Butterknife - salah satu perpustakaan paling terkenal di komunitas Android.

Jawaban yang bagus sudah ada di sini, tetapi izinkan saya mengatakan sesuatu tentang contoh butterknife Anda : meskipun saya tidak tahu kode apa yang dilakukan, pada pandangan pertama, itu tidak terlihat benar-benar tidak dapat dipertahankan bagi saya. Variabel dan nama metode tampaknya dipilih dengan sengaja, kode diindentasi dan diformat dengan benar, memiliki beberapa komentar dan metode panjang setidaknya menunjukkan beberapa struktur blok.

Ya, itu tidak mengikuti aturan "kode bersih" Paman Bob, dan beberapa metode pasti terlalu lama (mungkin seluruh kelas). Tetapi melihat kode saya masih melihat struktur yang cukup sehingga mereka dapat dengan mudah "dibersihkan" dengan mengekstraksi blok-blok itu ke dalam metode mereka sendiri (dengan risiko rendah memperkenalkan bug ketika menggunakan alat refactoring).

Masalah sebenarnya dengan kode tersebut adalah, menambahkan satu blok dan blok lain dan blok lainnya berfungsi sampai batas tertentu, terkadang selama bertahun-tahun. Tetapi setiap hari kodenya semakin sulit berkembang sedikit, dan butuh sedikit lebih lama untuk memodifikasi dan mengujinya. Dan ketika Anda benar-benar harus mengubah sesuatu yang tidak dapat diselesaikan dengan "menambahkan blok lain", tetapi membutuhkan restrukturisasi, maka Anda akan berharap seseorang mulai membersihkan kode lebih awal.

Prinsip-prinsip yang dinyatakan dalam "Kode Bersih" tidak selalu disetujui secara umum. Sebagian besar adalah akal sehat, tetapi beberapa pendapat penulis agak kontroversial dan tidak dimiliki oleh semua orang.

Secara khusus, preferensi untuk metode pendek tidak disetujui oleh semua orang. Jika kode dalam metode yang lebih lama tidak diulangi di tempat lain, mengekstraksi beberapa dari itu ke metode yang terpisah (sehingga Anda mendapatkan beberapa metode yang lebih pendek) meningkatkan kompleksitas keseluruhan, karena metode ini sekarang terlihat untuk metode lain yang seharusnya tidak mempedulikannya. Jadi ini merupakan trade-off, bukan perbaikan objektif.

Nasihat dalam buku ini juga (seperti semua saran) diarahkan untuk jenis perangkat lunak tertentu: Aplikasi perusahaan. Jenis perangkat lunak lain seperti permainan atau sistem operasi memiliki kendala yang berbeda dari perangkat lunak perusahaan, sehingga pola dan prinsip desain yang berbeda ikut berperan.

Bahasa juga merupakan faktor: Clean Code mengasumsikan Java atau bahasa yang serupa - jika Anda menggunakan C atau Lisp banyak saran tidak berlaku.

Singkatnya, buku ini adalah pendapat satu orang tentang kelas perangkat lunak tertentu. Itu tidak akan berlaku di mana-mana.

Adapun proyek-proyek open source, kualitas kode berkisar dari buruk ke brilian. Lagi pula, siapa pun dapat mempublikasikan kode mereka sebagai sumber terbuka. Tetapi jika Anda melihat proyek open source yang matang dan sukses dengan banyak kontributor, Anda dapat yakin mereka secara sadar memilih gaya yang sesuai untuk mereka. Jika gaya ini bertentangan dengan beberapa pendapat atau pedoman, maka (terus terang) itu adalah pedoman yang salah atau tidak relevan, karena kode kerja mengalahkan pendapat.

Ringkasan

Seperti yang ditulis JacquesB, tidak semua orang setuju dengan "Kode Bersih" Robert C. Martin.

Proyek sumber terbuka yang Anda temukan "melanggar" prinsip-prinsip yang Anda harapkan cenderung hanya memiliki prinsip lain.

Perspektif saya

Saya kebetulan mengawasi beberapa basis kode yang sangat mematuhi prinsip Robert C. Martin. Namun, saya tidak benar-benar mengklaim bahwa mereka benar , saya hanya bisa mengatakan mereka bekerja dengan baik untuk kami - dan bahwa "kami" sebenarnya merupakan kombinasi dari setidaknya

• ruang lingkup dan arsitektur produk kami,
• target pasar / harapan pelanggan,
• berapa lama produk dipelihara,
• metodologi pengembangan yang kami gunakan,
• struktur organisasi perusahaan kami dan
• kebiasaan, pendapat, dan pengalaman masa lalu pengembang kami.

Pada dasarnya, ini bermuara pada: setiap tim (baik itu perusahaan, departemen atau proyek open source) adalah unik. Mereka akan memiliki prioritas dan sudut pandang yang berbeda, dan tentu saja mereka akan membuat pengorbanan yang berbeda. Pengorbanan ini, dan gaya kode yang mereka hasilkan, sebagian besar adalah masalah selera dan tidak dapat dibuktikan "salah" atau "benar". Tim hanya dapat mengatakan "kami melakukan ini karena itu bekerja untuk kami" atau "kami harus mengubah ini karena tidak bekerja untuk kami".

Yang mengatakan, saya percaya bahwa untuk dapat berhasil mempertahankan basis kode yang besar selama bertahun-tahun, setiap tim harus menyetujui serangkaian konvensi kode yang mereka pikir cocok untuk aspek-aspek yang diberikan di atas. Itu mungkin berarti mengadopsi praktik-praktik oleh Robert C. Martin, oleh penulis lain, atau menciptakan praktik mereka sendiri; itu mungkin berarti menuliskannya secara formal atau mendokumentasikannya "dengan contoh". Tetapi mereka harus ada.

Contoh

Pertimbangkan praktik "pemisahan kode dari metode panjang menjadi beberapa metode pribadi".

Robert C. Martin mengatakan bahwa gaya ini memungkinkan untuk membatasi isi dari setiap metode untuk satu tingkat abstraksi - sebagai contoh sederhana, metode umum akan mungkin hanya terdiri dari panggilan ke metode pribadi seperti verifyInput(...), loadDataFromHardDisk(...), transformDataToJson(...)dan akhirnya sendJsonToClient(...), dan metode ini akan detail implementasi.

• Beberapa orang menyukai ini karena pembaca dapat memperoleh ikhtisar cepat dari langkah-langkah tingkat tinggi dan dapat memilih detail mana yang ingin mereka baca.
• Beberapa orang tidak menyukainya karena ketika Anda ingin mengetahui semua detail, Anda harus melompat-lompat di kelas untuk mengikuti alur eksekusi (inilah yang merujuk JacquesB ketika ia menulis tentang menambah kompleksitas).

Pelajarannya adalah: semuanya benar, karena mereka berhak memiliki pendapat.

Banyak pustaka sumber terbuka yang sebenarnya menderita dari praktik pengkodean yang buruk secara objektif dan dikelola dengan kesulitan oleh sekelompok kecil kontributor jangka panjang yang dapat menangani keterbacaan yang buruk karena mereka sangat akrab dengan bagian-bagian kode yang paling sering mereka pertahankan . Kode Refactoring untuk meningkatkan keterbacaan setelah fakta seringkali merupakan upaya Hercules karena semua orang perlu berada di halaman yang sama, itu tidak menyenangkan dan tidak membayar karena tidak ada fitur baru yang diterapkan.

Seperti yang dikatakan orang lain, buku apa pun tentang kode bersih yang menyatakan apa pun tentu berisi saran yang tidak disetujui secara universal. Secara khusus, hampir semua aturan dapat diikuti dengan semangat berlebihan, menggantikan masalah keterbacaan dengan aturan lain.

Secara pribadi, saya menghindari membuat fungsi bernama jika saya tidak memiliki nama yang baik untuk mereka. Dan nama yang bagus harus singkat dan menggambarkan dengan setia apa fungsinya bagi dunia luar. Ini juga terkait dengan mencoba untuk memiliki argumen fungsi sesedikit mungkin dan tidak ada data yang dapat ditulis secara global. Mencoba untuk memotong fungsi yang sangat kompleks menjadi fungsi yang lebih kecil sering menghasilkan daftar argumen yang sangat panjang ketika fungsi tersebut benar - benar kompleks. Membuat dan memelihara kode yang dapat dibaca adalah latihan dalam keseimbangan antara aturan akal sehat yang saling bertentangan. Membaca buku itu baik, tetapi hanya pengalaman yang akan mengajarkan Anda bagaimana menemukan kerumitan yang salah , yang merupakan tempat keuntungan keterbacaan nyata dibuat.

Sebagian besar proyek open source dikelola dengan buruk. Jelas ada pengecualian untuk itu, tetapi Anda akan menemukan banyak sampah di dunia open-source.

Ini bukan kritik dari semua pemilik / manajer proyek yang proyeknya saya bicarakan, itu hanya masalah waktu yang digunakan. Orang-orang ini memiliki hal-hal yang lebih baik untuk dilakukan dengan waktu mereka, seperti pekerjaan bayaran mereka yang sebenarnya.

Pada mulanya kodenya adalah karya satu orang dan mungkin kecil. Dan kode kecil tidak perlu bersih. Atau lebih tepatnya, upaya yang diperlukan untuk membuat kode bersih lebih besar daripada manfaatnya.

Seiring berjalannya waktu, kode ini lebih merupakan tumpukan tambalan oleh banyak orang yang berbeda. Penulis tambalan merasa tidak memiliki kode, mereka hanya ingin fitur yang satu ini ditambahkan atau bug yang satu ini diperbaiki dengan cara termudah mungkin.

Pemilik tidak punya waktu untuk membersihkan dan tidak ada orang lain yang peduli.

Dan kodenya semakin besar. Dan jelek.

Ketika semakin sulit untuk menemukan jalan Anda di sekitar kode, orang-orang mulai menambahkan fitur di tempat yang salah. Dan alih-alih memperbaiki bug, mereka menambahkan solusi di tempat lain dalam kode.

Pada titik ini bukan hanya orang tidak peduli, mereka tidak lagi berani membersihkan karena mereka takut merusak barang-barang.

Saya memiliki orang yang menggambarkan basis kode sebagai "hukuman yang kejam dan tidak biasa".

Pengalaman pribadi saya tidak terlalu buruk, tetapi saya telah melihat beberapa hal yang sangat aneh.

Sepertinya saya, Anda bertanya bagaimana hal ini bahkan bekerja jika tidak ada yang melakukan apa yang seharusnya mereka lakukan. Dan jika itu berhasil, lalu mengapa kita melakukan hal-hal ini ?

Jawabannya, IMHO, adalah itu berfungsi "cukup baik" , juga dikenal sebagai filosofi " lebih buruk lebih baik " . Pada dasarnya, terlepas dari sejarah berbatu antara open source dan Bill Gates, mereka berdua secara de facto mengadopsi ide yang sama, bahwa kebanyakan orang peduli tentang fitur, bukan bug .

Hal ini tentu saja juga menuntun kita untuk " normalisasi penyimpangan " yang mengarah ke situasi seperti Heartbleed , di mana, tepatnya seolah untuk menjawab pertanyaan Anda, besar-besaran, ditumbuhi spaghetti tumpukan kode sumber terbuka yang disebut OpenSSL pergi " uncleaned " untuk sesuatu seperti sepuluh tahun , berakhir dengan cacat keamanan besar yang mempengaruhi ribuan juta orang .

The solusi adalah untuk menciptakan sistem baru yang disebut LibreSSL , yang akan menggunakan kode yang bersih-ish , dan tentu saja hampir tidak ada yang menggunakannya .

Jadi bagaimana proyek-proyek open source kode besar buruk dipertahankan? Jawabannya ada di pertanyaan. Banyak dari mereka tidak dipelihara dalam keadaan bersih. Mereka ditambal secara acak oleh ribuan orang yang berbeda untuk menutupi kasus penggunaan pada berbagai mesin aneh dan situasi yang tidak akan pernah dapat diakses oleh pengembang . Kode berfungsi "cukup baik" sampai tidak , ketika semua orang panik dan memutuskan untuk membuang uang pada masalah .

Jadi mengapa Anda harus repot-repot melakukan sesuatu ' jalan yang benar ' jika tidak ada orang lain?

Jawabannya adalah Anda seharusnya tidak. Baik Anda lakukan atau tidak , dan dunia terus berubah , karena sifat manusia tidak berubah dalam skala seumur hidup manusia . Secara pribadi, saya hanya mencoba menulis kode bersih karena saya suka cara rasanya melakukannya.

Apa yang merupakan kode yang baik tergantung pada konteksnya, dan buku-buku klasik yang membimbing Anda tentang hal itu, jika tidak terlalu tua untuk membahas open-source, setidaknya merupakan bagian dari tradisi yang melancarkan perang tanpa henti melawan basis kode in-house yang buruk. Jadi mudah untuk mengabaikan fakta bahwa perpustakaan memiliki tujuan yang sangat berbeda, dan mereka ditulis sesuai. Pertimbangkan masalah berikut, tanpa urutan tertentu:

• Ketika saya mengimpor perpustakaan, atau dari perpustakaan, saya mungkin tidak cukup ahli dalam struktur internalnya untuk mengetahui dengan tepat fraksi kecil mana dari toolkit yang saya butuhkan untuk apa pun yang saya kerjakan, kecuali saya menyalin apa Jawaban Stack Exchange menyuruh saya melakukannya. Jadi saya mulai mengetik from A import(jika menggunakan Python, katakan) dan lihat apa yang muncul. Tapi itu berarti apa yang saya lihat perlu mencerminkan tugas logis yang harus saya pinjam, dan itulah yang harus ada dalam basis kode. Metode pembantu yang tak terhitung jumlahnya yang membuatnya lebih pendek hanya akan membingungkan saya.
• Perpustakaan ada untuk programmer yang paling tidak mahir mencoba menggunakan beberapa algoritma yang kebanyakan orang hanya mendengar samar-samar. Mereka membutuhkan dokumentasi eksternal, dan itu perlu mencerminkan kode secara tepat, yang tidak bisa dilakukan jika kita terus refactoring semuanya untuk membuat metode pendek dan melakukan-satu-hal penganut senang.
• Setiap metode perpustakaan yang dipinjam orang dapat memecahkan kode dunia dengan konsekuensi yang merusak jika itu diturunkan atau bahkan diganti namanya. Tentu, saya berharap sklearn akan memperbaiki kesalahan ketik di Calinski-Harabasz , tapi itu bisa menyebabkan insiden pad kiri lainnya . Bahkan, dalam pengalaman saya, masalah terbesar dengan evolusi perpustakaan adalah ketika mereka berusaha terlalu keras untuk mengadopsi beberapa "perbaikan" kode-baik baru untuk bagaimana mereka menyusun segalanya.
• Di rumah, komentar sebagian besar merupakan kejahatan yang perlu di terbaik, untuk semua alasan saya tidak perlu memuntahkan (meskipun poin-poin itu agak melebih-lebihkan). Komentar yang bagus mengatakan mengapa kode itu bekerja, bukan bagaimana. Tetapi perpustakaan tahu bahwa pembacanya adalah programmer yang kompeten yang tidak bisa, katakanlah, menulis-aljabar linier keluar dari kantong kertas. Dengan kata lain, semuanya perlu dikomentari ulang: mengapa ia bekerja! (Oke, itu melebih-lebihkan lain.) Jadi itu sebabnya Anda melihat baris tanda tangan, blok komentar 100-baris, 1 baris kode yang bisa benar-benar pergi pada baris tanda tangan (bahasa mengizinkan, tentu saja).
• Katakanlah Anda memperbarui sesuatu di Github dan menunggu untuk melihat apakah kode Anda akan diterima. Harus jelas mengapa perubahan kode Anda berfungsi. Saya tahu dari pengalaman bahwa refactoring untuk menjadikan perkemahan lebih bersih sebagai bagian dari komitmen fungsional sering kali berarti banyak penghematan garis, penataan ulang, dan penggantian nama, yang membuat pekerjaan pengawas tanpa gaji Anda lebih sulit, dan menyebabkan masalah lain yang disebutkan di atas.

Saya yakin orang-orang dengan pengalaman lebih dari saya dapat menyebutkan poin lainnya.

Sudah ada banyak jawaban bagus - saya ingin memberikan perspektif tentang pengelola open source.

Perspektif saya

Saya seorang pengelola banyak proyek semacam itu dengan kode yang kurang bagus. Kadang-kadang saya bahkan dicegah untuk memperbaiki kode seperti itu karena masalah kompatibilitas karena perpustakaan diunduh jutaan kali setiap minggu.

Itu membuat pemeliharaan menjadi lebih sulit - sebagai anggota inti Node.js ada bagian dari kode yang saya rasa tidak enak untuk disentuh tetapi ada banyak pekerjaan yang harus dilakukan terlepas dan orang-orang menggunakan platform dengan sukses dan menikmatinya. Yang paling penting adalah itu berhasil.

Pada kode yang dapat dibaca

Ketika Anda mengatakan:

Saya menemukan kode di banyak dari mereka jauh dari prinsip-prinsip yang ditujukan untuk menulis kode bersih - misalnya metode yang berisi ratusan baris kode.

Baris kode bukan ukuran yang bagus tentang seberapa mudah dibaca itu. Dalam penelitian ini saya terhubung ke kernel linux dianalisis dan survei programmer menemukan kode "biasa" (kode yang orang harapkan pada dasarnya) dan kode yang konsisten lebih baik daripada kode "bersih" dalam pemahaman. Ini juga sejalan dengan pengalaman pribadi saya.

Beberapa proyek sumber terbuka tidak terlalu ramah

Linus "terkenal" mengatakan bahwa linux seharusnya tidak memiliki debugger bawaan karena orang yang menggunakan debugger tidak cukup baik untuk bekerja di linux dan dia tidak ingin menarik lebih banyak dari mereka.

Secara pribadi saya benar-benar tidak setuju dengan sikapnya di sana - tetapi itu juga sesuatu yang dilakukan orang.

Perangkat lunak open source tidak selalu berarti bahwa banyak penulis terlibat. Ketika sebuah perangkat lunak (atau unit perangkat lunak) ditulis oleh seorang penulis tunggal, fungsi panjang sering muncul.

Ini berasal dari sifat proses pengembangan. Metode sederhana akan diperpanjang dari waktu ke waktu, fitur baru sedang ditambahkan dan bug diperbaiki.

Metode panjang sangat mengurangi pemahaman fungsionalitas untuk penulis baru. Namun, dengan satu penulis ini jarang merupakan masalah dan masalahnya cenderung diabaikan. Sifat lain dari open source adalah kenyataan bahwa banyak perangkat lunak tidak dikembangkan secara aktif sehingga tidak ada pekerjaan refactoring yang akan, misalnya, membagi metode kompleks menjadi beberapa metode sederhana.

Anda belum menunjukkan contoh apa pun tetapi dari pemahaman saya ini juga sering terhubung ke bahasa pengembangan. Beberapa bahasa memberlakukan aturan linting yang ketat dari awal dan pengujian unit berat (atau bahkan TDD). Baik tes linting maupun unit biasanya mencegah masalah itu (sulit untuk menguji metode yang kompleks / panjang).

Secara umum, lebih sulit untuk membuat kode bersih jika perangkat lunak dikembangkan oleh penulis tunggal dan kontributor lain hanya memperbaiki masalah kecil.