Saya ingin menanyakan beberapa pertanyaan tentang kode kotor. Ada beberapa pemula yang berkode pada proyek menengah. Kode itu adalah bola lumpur yang sangat besar. Mereka bukan pemrogram tingkat lanjut. Mereka hanya tahu cara menggunakan keyboard sedikit tentang java. Mereka hanya menulis kode dengan 12.000 baris di kelas utama mereka, meskipun, 6.000 baris milik NetBeans sendiri.
Pekerjaan saya adalah menganalisis kode dan menyarankan cara yang baik untuk mempertahankan kode tersebut. Ide saya adalah untuk membatalkan proyek dan memulai yang baru dengan metodologi OOP. Baru-baru ini saya mengumpulkan beberapa catatan dan ide tentang masalah, dari situs ini dan beberapa lainnya.
Sekarang, saya punya pertanyaan berikut:
- Haruskah kita memperbaiki kodenya, dan mengubahnya menjadi OOP? Kami sekarang sedang men-debug-nya.
- Kode tidak memiliki komentar, tidak ada dokumentasi, tidak ada gaya pemrograman tertentu, dan sebagainya. Mengubahnya sangat mahal dan memakan waktu. Apa yang bisa kita lakukan tentang ini?
- Bagaimana saya bisa mengajar mereka untuk mengikuti semua aturan (berkomentar, OOP, kualitas kode yang baik, dll.)?
- Kode ini salah dan rentan kesalahan. Apa yang bisa kita lakukan? Pengujian? Kami hampir menulis dua atau tiga kertas A4 untuk koreksi, tetapi sepertinya tidak ada habisnya.
Saya harus mengatakan bahwa saya baru dengan mereka. Saya pikir saya telah melanggar aturan tentang menambahkan orang terlambat ke proyek, juga. Apakah Anda pikir saya harus meninggalkan mereka?
sumber
Jawaban:
Langkah 0: Cadangkan ke SCM
Karena, seperti yang ditunjukkan oleh JBRWilkinson dalam komentar, kontrol versi adalah garis pertahanan pertama Anda terhadap bencana (yang tidak dapat diubah).
Lakukan juga pencadangan detail konfigurasi perangkat lunak, prosedur untuk membuat kiriman, dll ...
Langkah 1: Tes Pertama
Kemudian mulailah dengan menulis tes :
Tidak peduli apa yang Anda putuskan untuk dilakukan, Anda dilindungi. Anda sekarang dapat:
Saran saya adalah memulai arsitektur umum dari awal , tetapi ekstrak dari kekacauan bagian-bagian yang memvalidasi pos pemeriksaan dan untuk memperbaiki ini sesuai keinginan Anda.
Langkah 2: Verifikasi dan Monitor
Siapkan sistem Integrasi Berkelanjutan (untuk melengkapi langkah 0 dan langkah 1 ) DAN sistem Inspeksi Berkelanjutan (untuk mempersiapkan langkah 4 ).
Langkah 3: Berdiri di Pundak Giants
(seperti biasa ...)
Langkah 4: Bersihkan
Semacam itu tidak perlu dikatakan lagi, tetapi alih-alih membaca sendiri kode, Anda mungkin ingin menjalankan linter / analisa statis dan alat-alat lain pada basis kode yang rusak untuk menemukan kesalahan dalam desain dan implementasi.
Maka Anda mungkin juga ingin menjalankan pemformat kode, yang akan sedikit membantu dalam tata graha.
Langkah 5: Tinjau
Sangat mudah untuk memperkenalkan bug kecil dengan refactoring atau membersihkan berbagai hal. Hanya membutuhkan pilihan yang salah dan klik cepat pada tombol, dan Anda mungkin menghapus sesuatu yang cukup penting tanpa disadari pada awalnya. Dan terkadang efeknya akan muncul hanya beberapa bulan kemudian. Tentu saja, langkah-langkah di atas membantu Anda menghindari hal ini (terutama dengan menerapkan alat uji yang kuat), tetapi Anda tidak pernah tahu apa yang bisa dan akan lolos. Jadi, pastikan agar refactoring Anda ditinjau oleh setidaknya satu pasang bola mata khusus lainnya (dan lebih disukai lebih dari itu).
Langkah 6: Bukti Masa Depan Proses Pengembangan Anda
Ambil semua hal di atas, dan jadikan itu bagian yang tak terpisahkan dari proses pengembangan Anda yang biasa, jika sudah tidak. Jangan biarkan ini terjadi lagi di jam tangan Anda, dan bekerja sama dengan tim Anda untuk menerapkan perlindungan dalam proses Anda dan menegakkan ini (jika itu mungkin) dalam kebijakan Anda. Jadikan memproduksikan Kode Bersih sebagai prioritas.
Tapi sungguh, tes . Banyak .
sumber
Secara pribadi, saya tidak akan memulai proyek ini sampai saya memiliki salinan Bekerja Efektif dengan Legacy Code . Serius, itu ditulis untuk hal seperti ini. Ini penuh dengan strategi untuk berurusan dengan kode rumit, dan jauh lebih detail daripada yang bisa saya berikan di sini.
sumber
Saya pernah ke sana beberapa kali. Aturan saya adalah: jika perangkat lunaknya tidak sepele (lebih dari 1 minggu berfungsi untuk sumber daya yang Anda miliki) dan itu berfungsi, maka simpan dan lanjutkan dengan refactoring tambahan.
Jika perangkat lunak tidak benar-benar berfungsi (jumlah bug sangat tinggi, persyaratan tidak jelas, dll.) Daripada lebih baik untuk menulis ulang dari awal. Sama jika itu cukup kecil.
Intinya dalam refactoring (seperti dalam buku Fowler dan yang Kerievsky http://www.industriallogic.com/xp/refactoring/ ) adalah bahwa hal itu membuat sistem bekerja, mungkin refactoring akan memakan waktu dua kali lipat tetapi risikonya nol.
Menulis ulang dari awal dapat menimbulkan banyak risiko, mulai dari kesalahpahaman persyaratan hingga implementasi yang salah (toh sebagian besar tim akan sama).
Saya benar-benar melihat prosedur kompleks yang ditulis ulang dari awal dua kali dan masih tidak berfungsi seperti yang diharapkan.
sumber
Saya akan menulis ulang sepenuhnya. Terkadang tidak mungkin untuk memperbaiki kode semacam itu. Pilihan lain adalah membuatnya berfungsi, tanpa menambahkan fitur baru. Untuk mengajar tim menulis kode yang baik (dirancang dengan baik, didokumentasikan, dengan tes) biarkan mereka memperbaiki kode yang Anda miliki sekarang. Biarkan semua orang untuk memperbaiki bug / meninjau kode pengembang lain, bukan bagiannya. Setelah beberapa upaya mereka akan memahami bahwa hampir tidak mungkin untuk meninjau / memperbaiki kode tersebut.
Menambahkan orang ke proyek yang terlambat sangat jarang membantu. Biasanya itu melanggar tenggat waktu. Anda harus melakukan apa saja untuk menyelesaikan proyek dengan sukses, dan kemudian berpikir untuk pergi.
sumber
Saran saya adalah untuk tidak menghapus seluruh kode sepenuhnya. Ini adalah masalah kehidupan sehari-hari, yang dihadapi oleh setiap tim pengembangan. Serang satu bagian kode sekaligus. Perbaiki, bersihkan, dokumentasikan. Dan kemudian pindah ke bagian lain. Hal utama adalah selalu menyimpan beberapa kode yang dapat dikirim di tangan. Menulis ulang seluruh kode dari awal akan mengambil jumlah waktu yang telah dihabiskan sampai sekarang dan tidak akan ada jaminan bahwa itu akan lebih baik daripada saat ini.
Tetapi kemudian juga orang-orang harus menghindari penulisan kode dengan cara ini. Luangkan lebih banyak waktu dalam ulasan kode. Beradaptasi dengan beberapa gaya pengkodean seragam. Diskusikan desain terlebih dahulu dan kemudian tulis kodenya. Hal-hal sederhana seperti itu akan membuat perubahan besar.
Blog yang bagus menceritakan mengapa Netscape longgar
sumber
Jika berhasil, refactor saja. Ada alat untuk membantu Anda melakukan itu. Jika tidak berhasil, gunakan perintah peningkatan kode magis, yaitu
deltree
pada Windows resp.rm -rf
di Linux.sumber
Aku pernah ke sana, kau punya simpati. Saya bahkan menulis artikel tentang ini yang mungkin bisa membantu Anda mendapatkan perspektif. Namun singkatnya:
Jika kode berisi banyak duplikasi, Anda harus menulis ulang. Jika tidak ada struktur yang dapat dilihat (tidak ada antarmuka yang jelas, spageti), refactoring akan gagal dan Anda mungkin harus menulis ulang.
Mulailah dengan menjelaskan mengapa mereka mungkin ingin melakukan itu dengan menunjukkan kepada mereka apa yang dapat mereka peroleh darinya secara pribadi. Ketika mereka setuju dengan ini dan mau belajar, mulailah mengajar mereka menggunakan shuhari .
sumber
Saran saya adalah kombinasi dari jawaban @ duros & @Manoj R.
Mulai dari awal, ingat untuk membuat kode yang baik / OOP / berkomentar / dll kali ini, lihat / salin & tempel dari kode lama Anda. Ketika Anda memenuhi bagian-bagian buruk dari kode lama Anda, tulis ulang / perbaiki mereka.
Jika pengembang Anda tidak terlatih dengan baik, saya pikir bagus untuk mengirim mereka ke kursus. Ini penting untuk pelatihan ulang reguler di industri TI yang cepat berubah
sumber