Haruskah saya menghapus kode yang tidak direferensikan?

Saya sedang mengerjakan basis kode berukuran sedang (100k baris), semuanya kode yang relatif baru (kurang dari setahun) dan memiliki cakupan uji unit yang baik.

Saya terus menemukan metode yang tidak lagi digunakan di mana saja atau hanya direferensikan dalam unit test yang hanya menguji metode tertentu.

Haruskah saya menghapus kode ini jika saya yakin tidak diperlukan lagi?

Alasan untuk menghapusnya:

• Lebih sedikit kode, lebih sedikit bug
• Lebih sedikit kode lebih mudah dicerna orang lain
• Itu masih di bawah kendali sumber

Alasan untuk menyimpannya:

• Dapat digunakan sebagai referensi
• Mungkin berguna kadang-kadang
• Itu mungkin telah ditulis untuk 'melengkapi' fungsionalitas untuk suatu kelas

Sebagian besar alasan Anda untuk mempertahankannya sama sekali tidak relevan, sederhananya. Jika kode tersebut tidak digunakan, buang saja - semua manfaat yang terlibat dalam menjaga kode tersebut dapat diperoleh dari kontrol sumber. Paling banyak, tinggalkan komentar yang mengatakan revisi untuk menemukannya.

Sederhananya, semakin cepat Anda memotong kode, semakin cepat Anda tidak perlu membuang waktu untuk mempertahankannya, mengompilasinya, dan mengujinya. Keuntungan-keuntungan itu secara masif melebihi manfaat-manfaat sepele yang telah Anda uraikan, yang semuanya dapat diturunkan dari kendali sumber.

Semua alasan untuk menghapusnya berdiri.

Alasan untuk menyimpannya:

• Dapat digunakan sebagai referensi
• Mungkin berguna kadang-kadang
• Itu mungkin telah ditulis untuk 'melengkapi' fungsionalitas untuk suatu kelas

Semua alasan untuk mempertahankannya akan dikelola oleh kontrol sumber. Hapus dari kode langsung dan Anda akan dapat mengambilnya jika diperlukan.

Kode yang tidak direferensikan sama dengan menjaga baterai yang agak, agak datar kalau-kalau Anda membutuhkannya suatu hari untuk obor.

Selama Anda menggunakan semacam kontrol versi, saya akan mengatakan membuangnya dari kode langsung dan menggunakan riwayat versi jika itu ternyata berguna.

Satu-satunya alasan bagus saya dapat melihat untuk menjaga kode yang saat ini tidak digunakan adalah jika itu adalah bagian dari modul mandiri: Sementara beberapa bagian dari kode mungkin tidak digunakan saat ini, mungkin saja mereka akan menjadi digunakan di masa depan.

Ini mungkin benar terutama untuk perpustakaan yang Anda gunakan di berbagai proyek: Anda tidak ingin terus-menerus melempar potongan-potongan kode, sesuai dengan apa yang Anda butuhkan untuk proyek tertentu: Saya menemukan ini memakan waktu dan rawan kesalahan.

Pendekatan saya adalah: (1) jika Anda menggunakannya sekali, hanya simpan apa yang benar-benar Anda butuhkan; (2) jika Anda menggunakannya dua kali, salin dan sesuaikanlah saat Anda menggunakannya kedua kali; (3) jika Anda menggunakannya lebih dari dua kali, buatlah modul stabil yang terdefinisi dengan baik darinya, dan gunakan modul ini sesuai kebutuhan.

Meringkas: Saya akan membuang semua kode yang tidak digunakan kecuali itu adalah bagian dari modul tujuan umum yang telah Anda rancang sedemikian rupa dan Anda tahu Anda akan menggunakan kembali beberapa kali.

Catatan : Tentu saja, solusi yang lebih bersih adalah membuat proyek terpisah untuk perpustakaan, dan menambah ketergantungan antar proyek.

Secara umum, saya akan tunduk pada YAGNI tentang ini. Jika "Anda tidak membutuhkannya", maka itu hanya mengambil ruang dalam basis kode Anda, unit test, dan rakitan. Anda mungkin pada akhirnya membutuhkannya, tetapi Anda juga mungkin akhirnya harus menulis ulang sepenuhnya karena antara sekarang dan ketika Anda membutuhkannya, banyak yang dapat berubah.

Namun, itu agak berubah ketika Anda sedang menulis utilitas atau API yang dimaksudkan untuk konsumsi umum. Sama seperti Anda tidak pernah dapat mengharapkan pengguna akhir perangkat lunak untuk berinteraksi dengan perangkat lunak dengan cara yang Anda inginkan, Anda tidak pernah dapat mengharapkan konsumen kode Anda untuk ingin menggunakan kode Anda persis seperti yang Anda pikirkan. Dalam kasus seperti itu, selama Anda dapat membenarkan keberadaan metode dengan "itu adalah cara yang valid untuk ingin berinteraksi dengan objek saya" maka itu mungkin harus masuk, karena bahkan jika Anda tidak akan membutuhkannya, kemungkinan ada yang akan melakukannya. .

Mengingat basis kode kurang dari satu tahun, mungkin masih dalam banyak fluks (ya?) - sehingga gagasan bahwa beberapa bit mungkin perlu dibangkitkan dalam waktu dekat tidak masuk akal.

Untuk bit yang sulit untuk diperbaiki sejak awal dan tampaknya lebih mungkin untuk dibangkitkan, saya akan membuatnya sedikit lebih "hidup" daripada hanya dalam kontrol sumber. Orang tidak akan tahu / ingat bahwa mereka ada - mengatakan "Anda bisa menemukannya di kontrol sumber" mengandaikan bahwa Anda tahu / ingat bahwa itu ada! Dalam kasus seperti ini, pertimbangkan penghentian (dengan showstopper "menegaskan (salah)") atau berkomentar.

Jika kode itu sepele dan tidak menarik, saya hanya membuangnya untuk menghilangkan kelembaman yang tidak perlu dari sistem perangkat lunak.

Untuk mayat kode yang menarik, saya menggunakan archivecabang di sistem kontrol versi saya.

"Dapat digunakan sebagai referensi" Saya tidak akan cenderung setuju dengan alasan yang baik untuk meninggalkan kode yang tidak digunakan. Seringkali, hanya sebagian kecil dari kode yang tidak digunakan yang benar-benar menunjukkan sesuatu yang menarik. Ada beberapa cara untuk mendokumentasikan dan menyimpan kode yang bermanfaat tetapi tidak digunakan.

Meskipun kontrol versi akan berisi riwayat yang dengan mudah akan memungkinkan Anda untuk mengembalikan fungsionalitas tertentu jika nanti Anda memutuskan kode diperlukan, mengetahui bahwa Anda perlu mencari di riwayat kontrol versi untuk menemukan xy atau z dari siapa yang tahu apa revisi sebelumnya dapat sedikit membosankan, dan sering diabaikan kecuali Anda memiliki ide yang cukup spesifik apa yang Anda cari.

Kode dapat dikomentari dengan catatan tentang kapan itu dihapus dan mengapa itu tidak dihapus dari kode. Namun, ini umumnya dianggap gaya yang buruk, dan kode yang tidak digunakan dan tidak dipelihara dengan benar dapat memperkenalkan semua jenis bug jika tidak dicommentasikan nanti, jadi ini umumnya lebih baik sebagai langkah debugging / pengujian sementara sementara mid-refactoring daripada cara untuk meninggalkan kode produksi.

Cara favorit saya untuk menyimpan kode yang dihapus, jika tampaknya bermanfaat di masa depan, adalah membuat dokumen referensi sekunder yang berisi semua potongan kode yang dihapus. Setiap blok kode diberi label dengan menyebutkan secara singkat dari mana asalnya atau hal lain yang perlu diingat seperti ketika dihapus atau nomor revisi yang terakhir dalam kode di. Semuanya dihapus tetapi "berpotensi bermanfaat" ada di satu tempat, mudah dicari, tetapi tidak memerlukan upaya terus-menerus untuk memelihara dan menguji secara berkelanjutan (bahwa pengujian ditunda ke titik mana pun kode tersebut diperkenalkan kembali).

Salah satu alasan bagus untuk mempertahankan metode yang tidak digunakan adalah: mereka dapat digunakan pada cabang / tag lain!

Jelajahi semua cabang dan tag aktif Anda sebelum menghapusnya.

Jika Anda menggunakan sistem kontrol versi, maka jangan khawatir tentang referensi di masa depan, karena Anda hanya dapat melihat melalui sejarah kode itu dan menemukan bagian yang dihapus. Jika Anda tidak dan Anda berpikir itu akan digunakan suatu hari nanti, maka hanya membiarkannya tinggal di sana, tapi komentar itu dengan deskripsi yang menjelaskan mengapa hal itu berkomentar.

Namun, jika Anda yakin tidak akan menggunakannya di lain waktu, hapus saja . Saya pikir alasan yang Anda sebutkan cukup mudah untuk menghapus kode.

Tapi tolong sebelum menghapusnya, pastikan itu tidak digunakan di mana pun. Visual Studio memiliki fitur yang disebut Find All References yang mencari seluruh solusi dan menemukan referensi ke variabel saat ini, metode, properti, kelas, antarmuka, dll. Saya selalu memastikan bahwa tidak ada referensi di tempat sebelum menghapus bagian dari kode saya.

Saya relatif sering memiliki pengalaman menemukan fungsi yang sepertinya akan melakukan apa yang saya butuhkan, dan mempercayainya untuk berfungsi karena sudah dalam produksi untuk waktu yang lama, hanya untuk mengetahuinya belum benar-benar digunakan dalam beberapa tahun. Kode yang tidak digunakan tidak dipelihara, dan meskipun mungkin telah bekerja bertahun-tahun yang lalu, API di sekitarnya telah cukup berubah sehingga Anda tidak bisa mempercayainya.

Paling-paling, Anda akhirnya menghabiskan banyak waktu untuk memastikan itu benar-benar masih melakukan apa yang Anda inginkan. Paling buruk, kelihatannya berfungsi sampai Anda digigit bug jahat nanti, dan butuh waktu lebih lama untuk melacaknya karena Anda menganggap kode "teruji produksi" berfungsi sehingga masalahnya harus ada di tempat lain dalam kode baru Anda. Dalam pengalaman saya, hampir selalu lebih cepat hanya untuk menulis fungsi baru sendiri.

Jika Anda menghapusnya, tetapi mengetahuinya dalam waktu dekat Anda benar-benar membutuhkannya, itu ada di sana dalam kontrol sumber. Jika Anda tidak memerlukannya sampai waktu berlalu begitu lama sehingga Anda tidak ingat itu dalam kontrol sumber, Anda mungkin lebih baik menulisnya dari awal.

Tidak ada yang menghabiskan waktu lebih sedikit daripada tidak ada kode.

Jika Anda harus menyelam ke dalam basis kode, Anda perlu waktu untuk mencari tahu, untuk apa kode itu digunakan, dan jika digunakan tanpa apa-apa, Anda perlu lebih banyak waktu.

Ok - ini bisa disembuhkan menjadi komentar, tetapi sekali lagi, semua orang akan alasan mengapa kode yang tidak digunakan ini masih dalam basis kode, apakah itu harus dihapus atau tidak.

Jika tidak ada, tidak ada yang akan kehilangan waktu dengannya.

Jika sulit untuk memperbaikinya, Anda memerlukan dokumentasi yang baik, bahwa kode ini ada, tetapi jika basis kode berkembang melalui beberapa iterasi, mungkin itu tidak akan berfungsi lagi, jika diaktifkan kembali.

Hapus kode yang tidak digunakan - lebih sedikit kekacauan, pemahaman yang lebih baik. Sistem kontrol versi Anda akan ditangani. Juga, jika Anda menggunakan sesuatu yang lebih baik daripada notepad, lingkungan Anda akan memungkinkan Anda untuk menggunakan kode yang lebih lama untuk referensi.

Komentar panjang kode lama mengganggu dan menyulitkan navigasi.

Salam

Ikuti algoritma sederhana ini:

1. Apakah ini didukung dalam SCM? Jika ya, lompat ke 3.
2. Siapkan SCM.
3. Buang barang-barang itu .

Semua poin Anda yang mendukung penghapusan valid.

Semua poin Anda demi menjaga kekacauan tidak valid begitu Anda memiliki SCM untuk mencarinya atau mengembalikannya. Sebenarnya, SCM Anda seharusnya dapat membantu Anda menentukan mengapa kode itu ada di sini dan tidak digunakan, jika digunakan dengan benar.

Ini disebut "kode mati" karena suatu alasan. Biarkan mati dan istirahatlah dengan tenang.

Itu akan tetap dalam kontrol sumber; seharusnya tidak tetap di basis kode aktif.

Satu-satunya pengecualian adalah jika kode menyelesaikan desain dan sementara Anda tidak menggunakan kode, Anda berencana untuk akhirnya membuat kode publik dan orang lain mungkin menginginkan fungsi dasar itu. Kemudian, cukup rancang tes untuk memastikan bagian-bagian kode ini bekerja yang meniru cara Anda mengusulkan orang lain untuk menggunakan bagian-bagian kode ini. Namun, jika Anda bahkan mempertimbangkan untuk menghapus kode dan tidak dapat mengemukakan alasan yang kuat untuk menyimpannya, itu harus dilakukan. Kode yang tidak digunakan membuat lebih banyak pekerjaan untuk semua orang (lebih sulit untuk membaca kode; kode mungkin rusak; lebih banyak pekerjaan untuk mempertahankan; dll)

Dalam pengalaman saya, menghapus kode yang tidak digunakan juga dapat menjadi bumerang. Anda mungkin lupa memiliki kode itu dan Anda tidak akan mencarinya di riwayat. Atau Anda mungkin bahkan tidak tahu seseorang telah menerapkan kode itu dan kemudian menghapusnya nanti. Sekali lagi, Anda tidak akan mencarinya dalam sejarah ...

Tidak diragukan lagi, memiliki kode yang tidak digunakan adalah bau busuk.

UPDATE: Saya baru saja melihat Ed Staub memberikan jawaban yang sangat mirip.