Bisakah seseorang menjelaskan keuntungan dari menghapus (atau menyimpan) kode yang tidak digunakan?

Saya telah mendengar berkali-kali bahwa kode yang tidak digunakan harus dihapus dari proyek. Namun tidak jelas bagi saya "mengapa?".

Poin saya untuk tidak menghapus adalah:

• Kode sudah ditulis, dan upaya telah dilakukan
• Kode dapat diuji pada lingkungan sintetik dan nyata
• Jika diatur dengan baik (dikelompokkan, paket terpisah, digabungkan secara longgar dll) itu tidak mengganggu Anda pada keseluruhan analisis kode atau pemfaktoran ulang
• Kode dapat digunakan di masa depan
• Saat dihapus, penulis mungkin merasa tidak nyaman

Bisakah seseorang menjelaskan keuntungan dari menghapus (atau menyimpan) kode yang tidak digunakan?

Berikut beberapa alasan mengapa kode yang tidak digunakan harus dihapus:

• Bagi siapa pun yang baru mengerjakan sebuah proyek, mereka tidak hanya harus memahami kode kerja, mereka juga harus memahami materi yang tidak digunakan. Ini membuang-buang waktu dan menimbulkan kebingungan.

• Ada bahaya bahwa suatu saat seseorang akan membuat perubahan yang secara tidak sengaja melibatkan kode 'tidak aktif' dan dapat menyebabkan bug. Saya tahu itu terjadi pada proyek yang saya kerjakan.

• Pemeliharaan kode apa pun merupakan beban administratif. Dengan mempertahankan kode redundan lama beban itu meningkat. Misalnya, menggabungkan perubahan di cabang utama menjadi lebih sulit karena ada lebih banyak kode yang harus dikerjakan dan lebih banyak kemungkinan untuk membuat kesalahan.

• Apa yang terjadi dari waktu ke waktu adalah semakin banyak kode lama yang tidak digunakan ditambahkan ke basis kode. Hal ini meningkatkan kebingungan, potensi kesalahpahaman, dan overhead administrasi.

• Kemungkinan kode yang tidak digunakan akan digunakan lagi sangat kecil kemungkinannya. Seiring waktu, kemungkinan penggunaan kembali berkurang. Jika kode akan dihapus dan dianggap cukup penting maka kode tersebut dapat bercabang dan didokumentasikan.

• Setiap perasaan pribadi yang mungkin dimiliki pembuat kode tentang kode yang mungkin telah mereka kerjakan dengan keras dapat dimengerti. Tetapi bagian dari menjadi profesional mensyaratkan bahwa pikiran-pikiran itu harus dikesampingkan untuk kebaikan yang lebih baik. Waktu tidak berarti siapa-siapa dan tidak ada tempat untuk melestarikan kode historis dalam basis kode yang berfungsi.

@suspectus telah melakukan pekerjaan yang sangat baik dalam memberikan alasan untuk menghapus kode; Saya ingin membahas poin pribadi Anda untuk menyimpan kode.

• Kode sudah ditulis, dan upaya telah dilakukan

Tetapi jika kode yang sudah tertulis tidak digunakan, ini hanya biaya tanpa nilai (masa depan). Ini adalah upaya yang diinvestasikan dengan sia-sia, dan melestarikan produk yang tidak terpakai dari upaya tersebut tidak memvalidasi upaya tersebut. Kami menyimpan kode karena berguna, sekarang, bukan sebagai peringatan atas upaya penulis.

• Kode dapat diuji pada lingkungan sintetik dan nyata

Maaf, saya tidak tahu apa yang Anda maksud dengan ini.

• Jika diatur dengan baik (dikelompokkan, paket terpisah, digabungkan secara longgar dll) itu tidak mengganggu Anda pada keseluruhan analisis kode atau pemfaktoran ulang

Jika ada di basis kode, tidak peduli seberapa baik terorganisir, itu berkontribusi pada beban pemeliharaan dan pemahaman. Benar, itu bisa diatur agar tidak terlalu membebani, tetapi jika hilang, itu bukan beban sama sekali.

• Kode dapat digunakan di masa depan

Di sekolah Agile, kami mengatakan YAGNI : You Ain't Gonna Need It. Ya, Anda mungkin bisa menggunakannya di masa depan, tetapi kita tidak cukup tahu hari ini tentang kebutuhan hari esok untuk dapat memprediksinya dengan keandalan apa pun. Berpikir sebaliknya adalah arogansi cenderung ke arah keangkuhan. Apa yang dapat kita ketahui tentang hari esok adalah: kita ingin basis kode kita mudah dimodifikasi, dan kode yang tidak digunakan mengurangi karakteristik itu.

• Saat dihapus, penulis mungkin merasa tidak nyaman

Penulis harus melupakannya. Kita semua telah menulis hal-hal yang ternyata tidak berguna - jauh lebih baik dapat menunjukkan badan kode yang semuanya sedang digunakan (karena bagian yang tidak digunakan telah dihapus) daripada ke badan kode di mana Anda dapat mengatakannya beberapa metode, "dan yang satu itu benar-benar digunakan!"

Bukankah cukup sulit untuk mengambil beberapa kode dan mencari tahu maksudnya, tetapi sekarang Anda harus mencari tahu bagian mana yang tidak digunakan?

Kode sudah ditulis, dan upaya telah dilakukan

Itu juga tidak perlu. Jika Anda tidak menggunakannya untuk apa pun, itu (menurut definisi) tidak berguna, terlepas dari apa yang dilakukannya atau berapa banyak usaha yang dihabiskan untuk itu.

Kode dapat diuji pada lingkungan sintetik dan nyata

Jika tidak berguna, itu masih tidak berguna bahkan jika Anda telah mengujinya. Jika kode tidak berguna, pengujian untuk kode tersebut juga tidak berguna (jadi menyimpan kode yang diberi komentar di sana, menciptakan ambiguitas - apakah Anda menyimpan pengujian? Jika Anda memiliki kode klien dari kode yang diberi komentar, apakah Anda juga mengomentari kode klien? )

Jika diatur dengan baik (dikelompokkan, paket terpisah, digabungkan secara longgar dll) itu tidak mengganggu Anda pada keseluruhan analisis kode atau pemfaktoran ulang

Tidak begitu. Semua alat Anda (kontrol sumber, analisis statis, ekstraktor dokumentasi, kompiler, dll) akan berjalan lebih lambat, karena mereka harus memproses lebih banyak data (dan sebagian besar atau lebih kecil dari data itu adalah noise).

Jika kode tidak diatur dengan baik di sisi lain, itu akan mengacaukan analisis statis, pemfaktoran ulang, dan lainnya.

Anda memasukkan suara ke masukan alat Anda dan berharap mereka mengatasinya dengan benar.

Bagaimana jika alat analisis statis Anda menghitung rasio komentar / kode? Anda baru saja mengacaukannya, dengan sesuatu yang relevan hingga kemarin (atau setiap kali kode itu dikomentari).

Yang paling relevan dari semuanya, blok kode yang diberi komentar menyebabkan penundaan dalam memahami kode untuk pemeliharaan dan pengembangan lebih lanjut dan penundaan semacam itu hampir selalu menghabiskan banyak biaya. Tanyakan pada diri Anda ini: Jika Anda perlu memahami implementasi suatu fungsi, apa yang lebih Anda sukai? dua baris kode yang jelas, atau dua baris kode dan dua puluh enam komentar yang tidak lagi aktual?

Kode dapat digunakan di masa depan

Jika ya, Anda akan menemukannya di SCM pilihan tim Anda.

Jika Anda menggunakan SCM yang kompeten dan mengandalkannya untuk menyimpan kode yang mati (alih-alih mengacaukan sumbernya), Anda seharusnya tidak hanya melihat siapa yang menghapus kode itu (pembuat komit), tetapi untuk alasan apa (komit pesan), dan apa lainnya perubahan dibuat bersamaan dengan itu (sisa perbedaan untuk komit itu).

Saat dihapus, penulis mungkin merasa tidak nyaman

Begitu?

Anda (saya berasumsi) adalah seluruh tim pengembang yang dibayar untuk membuat perangkat lunak terbaik yang Anda tahu caranya, bukan "perangkat lunak terbaik yang Anda tahu cara melakukannya tanpa melukai perasaan X".

Ini adalah bagian dari pemrograman, yang sebagian besar kode yang ditulis pada akhirnya akan dibuang; misalnya, Joel Spolsky mengatakan di beberapa titik bahwa untuk perusahaannya, sekitar 2% dari kode tertulis melihat produksi.

Jika Anda memprioritaskan ego developer daripada kualitas code base, Anda akan mengorbankan kualitas produk Anda, untuk ... apa sebenarnya? Mempertahankan ketidakdewasaan sesama pengembang? Melindungi ekspektasi kolega Anda yang tidak realistis?

Sunting: Saya telah melihat satu alasan yang valid untuk meninggalkan kode yang dikomentari di sumbernya, dan ini adalah kasus yang sangat spesifik: ketika kode ditulis dalam bentuk yang aneh / tidak intuitif dan cara yang bersih untuk menulis ulang tidak bekerja untuk alasan yang sangat halus. Ini juga harus diterapkan hanya setelah upaya berulang kali dilakukan untuk memperbaiki masalah dan setiap kali upaya tersebut kembali memunculkan cacat yang sama. Dalam kasus seperti itu, Anda harus menambahkan kode intuitif yang diberi komentar sebagai komentar, dan menjelaskan mengapa itu tidak berfungsi (sehingga pengembang di masa mendatang tidak akan mencoba perubahan yang sama lagi):

// note by <author>: the X parameter here should normally
// be a reference:
// void teleport(dinosaur& X);
// but that would require that we raise another dinosaur and
// kill it every twelve hours
// as such, the parameter is passed by value
void teleport(dinosaur X);

Kode mati mengotori kode Anda

Kode mati mengurangi pemahaman dan keterbacaan.

Kode terbaik selalu digunakan kembali, dan jika Anda memiliki kode mati itu mengurangi dapat digunakan kembali

Kami didorong oleh pendekatan pengkodean modular, di mana kami merancang kode untuk interaksi dengan sesama pemrogram, bukan untuk mesin. Kita harus memberikan energi yang maksimal untuk membuatnya mudah bagi dia untuk memahami kode kita. Mesinnya akan baik-baik saja.

Kode mati atau dikomentari seperti tanda jejak palsu yang hanya membingungkan orang, jadi hindari dengan cara apa pun.

• Ketakutan . Ini membuat tim lebih khawatir dan menghasilkan lebih sedikit. Jumlah ketakutan meningkat secara eksponensial ketika lebih banyak kode mati diperkenalkan. "Kami tidak tahu apakah mata bor itu digunakan, jadi kami tidak berani melepas atau menyentuhnya."

• Perubahan besar . Jika sesuatu yang perlu diubah di mana-mana di sistem juga ada di kode mati, apakah Anda mengubahnya? Sangat sulit untuk mengetahui apakah itu pasti tidak digunakan di suatu tempat, jadi selalu berisiko. Dan bahkan jika itu tidak akan merusak apa pun, akankah kode yang mati itu berfungsi sama sekali jika itu akan diambil kembali untuk digunakan setelah perubahan ini?

  Ketika berhadapan dengan perubahan besar, pengembang juga harus memeriksa setiap tempat yang berisi kode dan dalam kasus kode mati ini berlebihan. Dan memeriksanya membutuhkan waktu lebih lama ketika kodenya mati karena sulit untuk memverifikasi bahwa itu tidak digunakan di mana pun.

• Beban mental . Setiap kali Anda perlu memikirkan apakah sesuatu digunakan atau apakah Anda harus melakukan sesuatu pada kode yang sudah mati, itu membutuhkan sebagian kekuatan otak Anda.
• Pengejaran angsa liar . "Saya perlu contoh tentang cara menggunakan Foobar. Oh, ada di tempat-tempat ini di basis kode. Saya akan memeriksa klik pertama dan mencari tahu di mana ini di UI. Hmm ... Tidak dapat menemukannya di mana pun."
• Laporan yang digembungkan (misalnya berapa banyak baris kode, kelas, rutinitas, perubahan). Mendistorsi visibilitas proyek dan keputusan tentang bagian mana dari basis kode yang harus dikerjakan dan perkiraan proyek masa depan.
• Kepercayaan yang melemah pada basis kode . Hal ini dapat mengakibatkan lebih banyak waktu yang dihabiskan untuk tugas-tugas yang berlebihan dan merusak aliran penggunaan basis kode. Pengembang mungkin harus memeriksa dengan sangat hati-hati bahwa semua yang mereka gunakan akan berfungsi sebagaimana mestinya.

Ini sangat berharga jika Anda mengetahui bahwa sebagian dari basis kode tidak digunakan karena Anda dapat menghapusnya. Jika Anda membiarkannya tetap ada maka di masa depan akan sulit atau hampir tidak mungkin untuk memastikan bahwa itu benar-benar tidak digunakan. Misalnya, beberapa hal yang menggunakan kode dengan cara yang mengejutkan: refleksi, secara dinamis memanggil rutinitas yang digabungkan dari string, eval, sihir kerangka kerja .

Namun, jika ada kemungkinan besar bahwa kode akan digunakan di masa mendatang, akan lebih mudah untuk menambahkannya jika kode itu ada di sepanjang kode lain daripada di sistem kontrol versi. Anda mungkin tidak ingat kata-kata yang dimiliki kode tersebut setelah beberapa saat sehingga akan sangat sulit untuk menemukan kode tersebut dari inti VCS. Tapi saya akan membiarkan kode mati jarang ada dan bahkan kemudian saya akan mengomentari kode itu.

• Kode yang tidak digunakan adalah ruang pencarian yang lebih besar untuk Anda baca dan hal lain yang biasanya memindai kode Anda. Misalnya compiler, IDE, find in file, debugging, static analysis, more to review, file inclusion, check out from VCS, dll. Ini memperlambat proses tersebut dan menambahkan noise yang signifikan.
• Kode yang tidak digunakan tidak selalu merupakan kode mati. Ini dapat dijalankan dalam keadaan tertentu. Ini tidak hanya menawarkan vektor untuk bug dan masalah kinerja tetapi juga dapat menjadi masalah keamanan. Berkenaan dengan kinerja, ini dapat mengekspresikan dirinya dengan cara yang tidak terduga seperti unduhan yang lebih besar.
• Kode yang tidak digunakan menghasilkan kode yang tidak digunakan. Jika Anda menghapus panggilan fungsi dan kemudian mencari penggunaan fungsi itu untuk melihat apakah masih diperlukan, Anda mungkin melihat kecocokan dari kode yang tidak digunakan sebelumnya dan menganggap Anda dapat menyimpannya. Kode yang lebih tidak digunakan Anda memiliki lebih banyak lompatan untuk menentukan apakah kode tidak digunakan.
• Kode yang tidak digunakan masih sering harus dipertahankan. Katakanlah A dan B bergantung pada C. Dari mereka B tidak digunakan. Anda mengubah C dan kemudian B tidak akan mengkompilasi karena Anda telah menghapus anggota dari struct di C yang dibutuhkan B, sekarang Anda harus memperbaiki B atau secara aktif menghapusnya dari kompilasi. Anda seharusnya hanya menghapusnya.

Daftar ini mungkin tampak sederhana tetapi masing-masing bermanifestasi dalam ratusan cara berbeda menambahkan hambatan yang bersinergi di seluruh proses pengembangan. Inefisiensi seringkali dapat dibuktikan atau didemonstrasikan secara langsung dan matematis.

Menanggapi poin Anda ...

• Kode sudah ditulis, dan upaya telah dilakukan

Namun seringkali harus dijaga. Itu juga akan muncul masih dalam hal-hal seperti temukan dalam file.

• Kode dapat diuji pada lingkungan sintetik dan nyata

Saya tidak yakin apa yang Anda maksud dengan yang ini. Saya pikir itu sama dengan yang terakhir. Maksud Anda kode tersebut sudah diuji dan membersihkannya mungkin berarti perlu pengujian ulang. Itu biaya yang biasanya sepadan karena akan melunasi 90% dari waktu dan untuk menghindari bahwa itu harus dibersihkan sebelum diproduksi. Hampir semua kode memiliki dua iterasi, buat berfungsi, bersihkan. Alasan harus diuji dua kali adalah karena seseorang melewatkan langkah terakhir. Jika kode Anda juga terlalu mahal untuk pembuktian membaca diff, uji (yang kemungkinan besar jika itu berantakan dengan banyak kode yang tidak digunakan), dll maka itu masalah lain.

• Jika diatur dengan baik (dikelompokkan, paket terpisah, digabungkan secara longgar dll) itu tidak mengganggu Anda pada keseluruhan analisis kode atau pemfaktoran ulang

Kode Anda harus seperti ini, tetapi itu hanya mengurangi masalah secara moderat. Ini adalah argumen yang paling aneh untuk mendengar bahwa sesuatu harus diatur namun najis. Adalah normal untuk mencoba menjaga kode tetap modular dan mengurangi ketergantungan tetapi Anda juga menginginkan kode yang dapat digunakan kembali dan jika semua modul Anda adalah pulau, kemungkinan besar Anda belum KERING. Anda mungkin juga menemukan diri Anda melakukan decoupling berlebihan yang tidak melakukan apa pun selain mengurangi masalah kode berantakan yang tidak digunakan.

• Kode dapat digunakan di masa depan

Banyak orang terlalu menghargai kode tertulis. Jika tidak digunakan sekarang ini adalah bobot mati dan pada kenyataannya ketika Anda melalui jalur ini seringkali hanya sebagian kecil dari kode yang tidak digunakan menjadi kode yang digunakan. Kemungkinan besar kode yang tidak digunakan tidak mungkin menjadi kode yang dapat digunakan atau digunakan. Kode yang paling mungkin digunakan kembali adalah kode yang sudah digunakan yang melakukan sesuatu.

Yang lebih buruk adalah kode yang tidak digunakan tidak memiliki tujuan. Ketika seseorang datang dan harus mengubah sesuatu yang pada akhirnya berdampak pada kode yang tidak digunakan, mereka akan bingung duduk di sana mencoba mencari tahu apa yang perlu dilakukan kode yang tidak digunakan ini tanpa tujuan.

Sangat mudah bagi orang untuk merasa seperti ini ketika memulai karena kode membutuhkan banyak usaha. Namun begitu fasih dan terbiasa dengan kode itu menjadi seperti mengendarai sepeda. Anda akan mendapati bahwa karena biaya penulisan kode semacam itu merosotkan biaya untuk menjaganya tetap naik.

• Saat dihapus, penulis mungkin merasa tidak nyaman

Ini adalah masalah penulis. Di satu sisi, egois untuk meninggalkan banyak kode yang tidak digunakan untuk ditangani orang lain. Di sisi lain, jika seorang penulis lebih mengutamakan kualitas kode maka mereka mungkin tidak seharusnya membuat kode. Anda menempuh jalan dengan ini, Anda tidak dapat memperbaiki kode mereka ketika rusak karena itu akan melukai perasaan mereka. Bukan pertanda baik jika seseorang terikat pada kode hanya karena itu milik mereka, bukan karena itu bagus. Seorang penulis harus merasa senang dengan kode mereka dibersihkan. Ini seperti seseorang mengeluarkan sampah untuk Anda dan membuangnya ke tempat sampah.

Saya akan sangat senang jika seseorang melakukan itu untuk saya. Apa yang mungkin membuatnya lebih mudah untuk melupakan perasaan itu adalah daripada menunggu orang lain melakukannya, coba lakukan sendiri. Teruslah menulis ulang sepotong kode yang telah Anda lakukan secara berulang, membuatnya bekerja lebih baik, bergerak ringkas, dengan lebih sedikit kelebihan dan lebih fleksibel namun dengan lebih sedikit kode setiap kali. Cobalah untuk tidak merasa nyaman tentang kuantitas kode tetapi seberapa banyak yang dapat Anda capai dengan kode sekecil apa pun. Ini sedang digiling untuk naik level dan setelah Anda melakukannya semua kode Anda akan keluar pada level yang baik mengikuti sehingga tidak perlu sering diratakan.

Pertama-tama, Anda harus selalu menggunakan alat kendali sumber untuk mengelola proyek Anda dan karenanya menghapus kode yang tidak digunakan adalah praktik yang baik karena Anda selalu dapat kembali menggunakan kendali sumber untuk mendapatkan kode yang dihapus. Bagi saya alasan untuk menghapus kode yang tidak terpakai adalah karena hanya orang yang mengetahui kode yang tidak terpakai yang tahu tentang itu, orang lain dalam tim akan menemukan kode itu dan mencoba untuk mencari tahu apa fungsinya dan bagaimana itu cocok di seluruh aplikasi dan akan merasa kecewa setelah begitu banyak usaha sehingga kode tersebut tidak digunakan sama sekali :)

Diskusi ini sudah berlangsung beberapa tahun, tetapi saya baru saja menemukannya ...

Satu hal yang tidak saya lihat disebutkan adalah pekerjaan yang harus dilakukan untuk menghapus kode yang tidak digunakan. Dalam banyak kasus, waktu dan upaya untuk menghapus kode yang tidak digunakan bukanlah hal yang sepele, ditambah lagi biasanya ada biaya tambahan untuk menguji dan mendokumentasikan sistem yang direfraktorisasi. Hanya hal lain yang perlu dipertimbangkan dalam proses pengambilan keputusan.

Saya pikir Anda dapat memiliki dua kasus: - kode aplikasi: jika tidak digunakan mungkin belum teruji dan tidak dikelola dari waktu ke waktu, mungkin Anda dapat beralih ke "repositori kode internal" - Kode API: jika Anda menulis perpustakaan maka IMHO itu pilihan yang lebih baik untuk mempertahankannya tetapi di dalam proses pengembangan aktif Anda

Apakah Anda yakin kode tersebut tidak digunakan?

Tidaklah cukup untuk memeriksa kode yang masih dikompilasi. Dalam C ++, jika Anda menghapus metode yang didefinisikan secara implisit "tidak terpakai" seperti operator=Anda tidak akan mendapatkan kesalahan kompilator, kelas akan diam-diam mulai menggunakan implementasi default (yang berpotensi tidak benar). Di Java atau C # kode dapat digunakan melalui refleksi. Dalam bahasa berorientasi objek, pewarisan dapat memainkan peran (kelas dasar sekarang dapat disebut). Di hampir semua bahasa, fungsi lain yang kelebihan beban mungkin telah mengambil alih.

Periksa usia kode dalam kontrol versi, bukan hanya kode yang tidak digunakan. Saya telah melihat kode yang tampak tidak digunakan tetapi baru saja dilakukan, dan sebenarnya merupakan langkah pertama dalam proyek pengembang lain.

Hapus kode yang tidak digunakan secara agresif

Anda membayar untuk memelihara kode:

• Memperbaiki bangunan yang rusak (waktu rekayasa). Kami baru-baru ini mengalami rantai #includeperubahan yang rumit , memperkenalkan kelebihan muatan baru pada kode yang tidak digunakan, yang menyebabkan sakit kepala yang cukup besar bagi setiap insinyur di tim yang terdiri dari lusinan pengembang.
• Di resource mesin pada pengujian (dengan asumsi Anda memiliki build berkelanjutan yang menguji diri sendiri). Tim saya baru-baru ini melihat semua pengujian kami yang paling lambat, dan banyak di antaranya yang merupakan kode yang tidak digunakan. Teknisi yang menjalankan pengujian secara lokal atau sebagai bagian dari integrasi berkelanjutan sedang menunggu pengujian pada kode yang tidak digunakan.
• Dalam hal keterbacaan (rekayasa waktu lagi). File header Anda mewakili API. Jika mereka menyertakan fungsi yang tidak ingin digunakan siapa pun tetapi semua orang harus membaca, kurva pembelajaran kode Anda jauh lebih sulit.
• Dalam pencarian kode (waktu rekayasa lagi). Apakah Anda akan membersihkan rumah, hard drive, atau Google Drive Anda? Semakin sering Anda mencari domain, semakin penting domain tersebut memiliki konten yang relevan untuk menghindari kesalahan positif (atau Anda menggunakan pencarian yang lebih canggih seperti mesin pencari web).

Saya akan mengatakan pada dasarnya semua kode yang ditulis rata-rata pengembang menjadi tidak digunakan dalam jangka waktu lima tahun sehingga aktivitas ini tidak pernah berhenti. Jangan biarkan ini menjadi Anda; hanya tulis kode berkualitas tinggi dan benar-benar diperlukan.