Apa yang Anda lakukan ketika tinjauan kode terlalu sulit?

OK jadi banyak ulasan kode cukup rutin. Tetapi kadang-kadang ada perubahan yang secara luas berdampak pada kode yang rapuh dan kompleks yang ada. Dalam situasi ini, jumlah waktu yang diperlukan untuk memverifikasi keamanan perubahan, tidak adanya regresi, dll. Berlebihan. Mungkin bahkan melebihi waktu yang dibutuhkan untuk melakukan pengembangan itu sendiri.

Apa yang harus dilakukan dalam situasi ini? Menggabungkan dan berharap tidak ada yang lolos? (Tidak menganjurkan hal itu!) Apakah yang terbaik dapat dilakukan dan hanya mencoba untuk menemukan kesalahan yang jelas (mungkin ini yang paling dituju oleh ulasan kode?) Menggabungkan dan menguji secara menyeluruh sebagai alternatif yang lebih baik daripada tinjauan kode sama sekali?

Ini bukan pertanyaan khusus apakah pengujian harus dilakukan sebagai bagian dari tinjauan kode. Ini adalah pertanyaan yang menanyakan pilihan terbaik apa yang ada dalam situasi seperti yang dijelaskan, terutama dengan tenggat waktu yang mendesak, tidak ada rangkaian lengkap unit test yang tersedia atau unit test yang tidak layak untuk kode terfragmentasi yang diubah.

EDIT: Saya mendapat kesan bahwa beberapa jawaban / komentar sejauh ini telah mengambil frasa saya "dampak luas", dan mungkin menganggap itu berarti bahwa perubahan melibatkan sejumlah besar baris kode. Saya bisa mengerti ini adalah interpretasi, tapi itu bukan maksud saya. Dengan "dampak luas", maksud saya misalnya potensi regresi tinggi karena keterkaitan basis kode, atau ruang lingkup efek knock-on, belum tentu bahwa perubahan itu sendiri adalah perubahan besar. Misalnya, pengembang mungkin menemukan cara untuk memperbaiki bug dengan satu baris dengan memanggil rutin tingkat tinggi yang ada yang mengalirkan panggilan ke banyak rutinitas tingkat bawah. Menguji dan memverifikasi bahwa perbaikan bug berhasil adalah mudah. Memvalidasi secara manual (melalui tinjauan kode) dampak dari semua efek knock-on jauh lebih sulit.

Premis dari pertanyaan itu, sejujurnya, mencengangkan. Kami menganggap bahwa ada perubahan besar pada kode yang rapuh dan kompleks, dan tidak ada cukup waktu untuk memeriksanya dengan benar . Ini adalah kode terakhir yang harus Anda habiskan lebih sedikit untuk meninjau! Pertanyaan ini menunjukkan bahwa Anda memiliki masalah struktural tidak hanya dalam kode Anda sendiri, tetapi dalam metodologi Anda mengelola perubahan.

Lantas bagaimana menghadapi situasi ini? Mulailah dengan tidak masuk ke dalamnya sejak awal:

• Identifikasi sumber-sumber kompleksitas, dan terapkan refactoring yang benar-benar teliti, benar, untuk meningkatkan tingkat abstraksi. Kode tersebut harus dapat dipahami oleh karyawan baru yang baru lulus dari perguruan tinggi yang mengetahui sesuatu tentang domain bisnis Anda.

• Identifikasi sumber kerapuhan; ini bisa dengan meninjau kode itu sendiri, dengan memeriksa sejarah perbaikan bug ke kode, dan sebagainya. Tentukan subsistem mana yang rapuh dan membuatnya lebih kuat . Tambahkan logika debugging. Tambahkan pernyataan. Buat implementasi lambat dari algoritma yang sama dan jelas, dan dalam build debug Anda, jalankan keduanya dan verifikasi bahwa mereka setuju. Di build debug Anda, menyebabkan situasi langka terjadi lebih sering. (Misalnya, buat pengalokasi memori yang selalu memindahkan blok pada realokasi, atau selalu mengalokasikan blok di akhir halaman, atau apa pun.) Jadikan kode tersebut kuat dalam menghadapi perubahan konteksnya. Sekarang Anda tidak memiliki kode rapuh lagi; sekarang Anda memiliki kode yang menemukan bug, daripada menyebabkan bug.

• Tulis serangkaian tes otomatis. Jelas sekali.

• Jangan melakukan perubahan besar. Buat serangkaian perubahan kecil yang ditargetkan, yang masing-masing dapat dianggap benar.

Tetapi pada dasarnya, skenario Anda adalah "kami telah menggali lubang hutang teknis dan setiap perubahan yang kompleks dan tidak ditinjau menggali kami lebih dalam; apa yang harus kita lakukan?". Apa yang Anda lakukan ketika Anda menemukan diri Anda berada di lubang itu? Berhenti menggali . Jika Anda memiliki begitu banyak hutang sehingga Anda tidak dapat melakukan tugas-tugas dasar seperti meninjau kode masing-masing, maka Anda harus berhenti membuat lebih banyak utang dan menghabiskan waktu melunasinya.

Salah satu tujuan utama dari tinjauan kode adalah untuk meningkatkan kualitas dan memberikan kode yang kuat . Kuat, karena 4 mata biasanya menemukan lebih banyak masalah daripada 2. Dan peninjau yang belum menulis kode tambahan lebih cenderung menantang asumsi (berpotensi salah).

Menghindari peer review akan dalam kasus Anda hanya berkontribusi untuk meningkatkan kerapuhan kode Anda. Tentu saja, pengujian penguat dengan rangkaian uji yang solid dan berulang dapat meningkatkan kualitas. Tetapi harus komplementer dengan peer review, bukan pengganti .

Saya pikir kompleksitas itu harus dipahami dan dikuasai, dan peer review lengkap adalah kesempatan untuk berbagi pengetahuan dan mencapainya. Investasi yang Anda lakukan untuk memiliki lebih banyak orang yang memahami kekuatan dan kelemahan kode rapuh, akan membantu menjadikannya lebih baik dari waktu ke waktu.

Kutipan untuk menyimpulkan:

"Jika kamu ingin pergi cepat, pergi sendiri. Jika kamu ingin pergi jauh, pergi bersama"

Selamat datang di dunia pengembangan perangkat lunak lama.

Anda memiliki 100 ribu, jutaan, 10 juta jutaan baris kode.

Baris-baris kode ini berharga, karena menghasilkan aliran pendapatan dan menggantikannya tidak dapat dihindari.

Model bisnis Anda didasarkan pada pengungkitan basis kode itu. Jadi tim Anda kecil, basis kode besar. Menambahkan fitur ke diperlukan untuk membuat orang membeli versi baru dari kode Anda, atau untuk membuat pelanggan yang ada senang.

Di dunia yang sempurna, basis kode besar Anda adalah unit yang diuji wazoo. Anda tidak hidup di dunia yang sempurna.

Di dunia yang kurang sempurna, Anda memiliki anggaran untuk memperbaiki utang teknis Anda - memecah kode Anda menjadi bagian-bagian yang dapat diuji unit, melakukan pengujian integrasi yang luas, dan beralih.

Ini, bagaimanapun, adalah membayar hutang tanpa menghasilkan fitur baru. Yang tidak cocok dengan kasus bisnis "menuai keuntungan dari kode yang ada, sambil memodifikasinya untuk menghasilkan insentif untuk meningkatkan".

Anda dapat mengambil potongan besar kode dan menulis ulang menggunakan teknik yang lebih modern. Tetapi di mana pun Anda berinteraksi dengan kode yang ada, Anda akan memaparkan kemungkinan titik istirahat. Retas dalam sistem yang Anda singkirkan sebenarnya dikompensasi dengan kekhasan dalam subsistem yang tidak Anda tulis ulang. Selalu.

Yang bisa Anda lakukan adalah bertindak hati-hati. Anda dapat menemukan beberapa bagian dari kode yang benar-benar Anda pahami, dan yang perilakunya dan interaksinya dengan seluruh sistem dipahami dengan baik. Anda dapat memodernisasi itu, menambahkan unit test dan menjadikan perilakunya lebih jelas.

Kemudian temukan bagian-bagian sisa aplikasi yang sebagian besar berinteraksi dengannya, dan serang mereka satu per satu.

Saat Anda melakukannya, Anda dapat meningkatkan subsistem, menambahkan fitur yang bersedia dibayar oleh pelanggan.

Singkatnya, ini adalah seni dari kemungkinan - membuat perubahan tanpa merusak hal-hal yang menyediakan kasus bisnis.

Tapi ini bukan pertanyaanmu. Pertanyaan Anda adalah, "Saya melakukan sesuatu yang besar, dan kemungkinan akan merusak barang, dan bagaimana saya mengikuti praktik terbaik?"

Ketika melakukan sesuatu yang besar, memang benar bahwa jika Anda ingin melakukannya dengan andal Anda akhirnya menghabiskan lebih banyak upaya untuk melacak bug dan memperbaikinya daripada Anda menulisnya. Ini adalah aturan umum pengembangan perangkat lunak: menulis barang itu mudah, membuatnya bekerja dengan sempurna itu sulit.

Anda mungkin memiliki kasus bisnis yang menggantung di atas kepala Anda, di mana Anda telah berjanji kepada beberapa pemangku kepentingan bahwa perubahan besar ini terjadi. Dan itu sudah "selesai", jadi Anda mendapatkan pushback dengan mengatakan "tidak, ini tidak dilakukan, itu hanya terlihat suka itu".

Jika Anda memiliki kekuatan dan anggaran, benar-benar menghabiskan upaya menghasilkan kepercayaan bahwa perubahan itu berhasil, atau cukup menolak perubahan. Ini akan menjadi masalah derajat, bukan kebaikan.

Jika Anda tidak memiliki kekuatan sebesar itu, tetapi masih memiliki beberapa, cobalah untuk bersikeras bahwa sistem baru ini dapat diuji unit . Jika Anda menulis ulang beberapa subsistem, bersikeras bahwa subsistem baru terdiri dari bagian-bagian kecil dengan perilaku yang ditentukan dengan baik dan tes unit di sekitarnya.

Lalu ada kasus terburuk. Anda masuk lebih dalam ke hutang. Anda meminjam terhadap masa depan program dengan memiliki lebih banyak kode yang rapuh dan lebih banyak bug untuk mendapatkan fitur keluar sekarang , dan sial konsekuensinya. Anda melakukan QA berbasis sweep untuk menemukan masalah terburuk, dan mengabaikan sisanya. Ini sebenarnya kadang-kadang jawaban yang tepat dari perspektif bisnis, karena paling murah sekarang. Masuk ke hutang untuk menghasilkan keuntungan adalah strategi bisnis yang valid, terutama jika membersihkan hutang melalui kebangkrutan (meninggalkan kode) ada di atas meja.

Masalah besar adalah bahwa jarang sekali insentif pemilik perusahaan selaras dengan pembuat keputusan dan pemrogram. Ada cenderung banyak tekanan untuk 'memberikan', dan melakukannya dengan menghasilkan hampir tak terlihat (untuk atasan Anda) utang teknis adalah besar strategi jangka menengah pendek dan kadang-kadang. Sekalipun atasan / pemangku kepentingan Anda akan lebih baik dilayani dengan tidak menciptakan semua hutang itu.

Memecahkan masalah yang lebih besar yang menyebabkan tinjauan kode terlalu sulit.

Yang saya lihat sejauh ini:

1. Tidak ada unit test suite
2. Penggabungan kode kompleks yang dapat dihindari dengan struktur kode yang lebih masuk akal dan pendelegasian tugas pengkodean
3. Kurangnya arsitektur yang belum sempurna

1. Anda dapat mengirim ulasan kode kembali dan memberitahu pengembang untuk memecahnya menjadi perubahan yang lebih kecil, lebih bertahap, dan mengirimkan ulasan kode yang lebih kecil.

2. Anda masih dapat memeriksa bau kode, pola dan anti-pola, standar pemformatan kode, prinsip SOLID, dll. Tanpa harus melalui setiap detail kode.

3. Anda masih dapat melakukan inspeksi kode taktis untuk validasi input yang tepat, manajemen penguncian / utas, kemungkinan pengecualian yang tidak ditangani, dll. Pada tingkat terperinci, tanpa harus memahami maksud keseluruhan dari keseluruhan perubahan.

4. Anda dapat memberikan penilaian area risiko keseluruhan yang Anda tahu dapat dipengaruhi oleh kode, dan meminta pengembang untuk mengonfirmasi bahwa area risiko ini telah diuji unit (atau meminta dia menulis tes unit otomatis, dan mengirimkannya untuk ditinjau juga. ).

Dalam situasi ini, jumlah waktu yang diperlukan untuk memverifikasi keamanan perubahan, tidak adanya regresi, dll. Berlebihan.

Ulasan kode seharusnya tidak terutama ditujukan pada kebenaran. Mereka ada di sini untuk meningkatkan keterbacaan kode, pemeliharaan dan kepatuhan terhadap standar tim.

Menemukan bug yang benar selama tinjauan kode adalah produk sampingan yang bagus untuk melakukannya, tetapi pengembang harus memastikan kode mereka berfungsi dengan baik (termasuk non regresi) sebelum mengirimkannya untuk ditinjau .

Kebenaran harus dibangun sejak awal. Jika satu pengembang tidak dapat mencapainya, minta mereka memasangkan program atau mencari tahu rencana dengan seluruh tim, tetapi jangan memperlakukannya sebagai sesuatu yang dapat Anda tambahkan sebagai renungan.

Jika Anda berpikir bahwa tinjauan kode terlalu sulit, karena itu mengubah kode rapuh yang hampir mustahil untuk diubah tanpa merusaknya, maka Anda memiliki masalah. Tetapi masalahnya bukan pada review kode. Masalahnya juga bukan pada pengujian unit, karena kode rapuh tidak dapat diuji unit! Jika kode Anda adalah unit yang dapat diuji, maka ia akan dipecah menjadi unit-unit kecil dan independen, yang masing-masing dapat diuji, dan yang bekerja bersama dengan baik, dan itulah yang sebenarnya tidak Anda miliki!

Jadi, Anda memiliki tumpukan kode sampah (alias "utang teknis"). Hal terburuk yang dapat Anda lakukan adalah mulai memperbaiki tumpukan kode sampah dan tidak menyelesaikan pekerjaan karena dengan begitu Anda akan mendapatkan tumpukan kode sampah yang lebih besar. Jadi, hal pertama adalah meminta manajemen Anda untuk memperbaikinya dan menyelesaikan pekerjaan. Atau tidak. Dalam hal ini Anda hanya tidak menyentuhnya.

Ketika Anda memperbaikinya, Anda mengekstrak satu unit dari kode, membuatnya menjadi sesuatu yang memiliki perilaku yang terdefinisi dengan baik dan terdokumentasi dengan baik, menulis tes unit untuk unit itu, mengkaji kode itu, dan berdoa agar tidak ada yang rusak. Dan kemudian Anda melakukan hal yang sama dengan unit berikutnya, dan seterusnya.

Agak sulit datang ketika Anda mengalami bug. Kode sarang tikus Anda akan melakukan hal yang salah dalam beberapa kasus karena semuanya sangat rapuh dan rumit, semuanya akan salah. Saat Anda mengekstrak unit, kode yang tersisa akan menjadi lebih jelas. (Saya punya kasus di mana setelah beberapa refactoring, sebuah fungsi dimulai dengan "if (condition1 && condition2 && condition3) crash ();" yang persis perilaku sebelum refactoring, hanya lebih jelas. Saya kemudian menghapus baris itu :-) Anda akan melihat perilaku aneh dan tidak diinginkan dengan jelas, sehingga Anda dapat memperbaikinya. Di sisi lain, di situlah Anda harus mengubah perilaku kode yang ada, sehingga perlu dilakukan dengan hati-hati).

Sayangnya, tidak banyak yang dapat Anda lakukan mengenai hal ini di ulasan kode selain mendapatkan secangkir kopi. Solusi aktual untuk masalah ini adalah mengatasi utang teknis yang telah Anda akumulasikan: desain rapuh, kurangnya tes. Semoga, Anda setidaknya memiliki semacam QA fungsional. Jika Anda tidak memilikinya maka selalu ada doa untuk tulang ayam.

Jika Anda tidak puas mengirim dengan perangkat lunak tidak berfungsi dan memperbaikinya nanti, maka upaya V&V HARUS lebih lama dari upaya pengembangan!

Jika kode yang ada rapuh, maka pertanyaan pertama adalah "haruskah Anda mengubahnya?" Manajemen perlu menelepon apakah biaya / risiko mendesain ulang dan mengimplementasikan kembali kode ini lebih besar daripada biaya / risiko memperbaiki tumpukan sampah yang goyah. Jika hanya satu kali, mungkin lebih mudah untuk menambalnya saja. Jika ada kemungkinan lebih banyak perubahan diperlukan di masa depan, menerima pukulan sekarang untuk menghindari lebih banyak rasa sakit di masa depan mungkin merupakan keputusan yang lebih baik. Anda harus menyampaikan ini dengan manajemen Anda, karena memberikan informasi yang baik kepada manajer Anda adalah bagian dari pekerjaan Anda. Mereka perlu membuat keputusan itu, karena itu adalah keputusan strategis yang berada di atas tingkat tanggung jawab Anda.

Dari pengalaman saya, saya akan sangat menyarankan Anda untuk menutupi kode Anda dengan sejumlah tes, baik unit dan integrasi, SEBELUM ada perubahan yang dilakukan pada sistem yang bersangkutan. Penting untuk diingat bahwa saat ini ada sejumlah alat yang sangat bagus untuk tujuan itu, tidak masalah bahasa yang Anda kembangkan.

Juga, ada alat semua alat untuk membuat tes integrasi Anda. Ya, saya berbicara tentang kontainer dan khususnya Docker dan Docker Compose . Ini dengan indah memberi kita cara cepat mengatur lingkungan aplikasi yang kompleks, dengan infrastruktur (database, mongodb, server antrian dll) dan aplikasi.

Alat tersedia, gunakan! :)

Saya tidak tahu mengapa itu belum disebutkan, tetapi 2 ini adalah bagian yang paling penting:

• Anda membagi daftar perubahan menjadi beberapa daftar perubahan yang lebih kecil, yang kemudian Anda tinjau satu demi satu. *
• Jika peninjauan daftar perubahan tidak menghasilkan keputusan bahwa daftar perubahan tampaknya baik, Anda jelas menolak perubahan itu.

* Contoh: Anda mengganti perpustakaan A dengan perpustakaan B. Satu daftar perubahan memperkenalkan perpustakaan B, berbagai daftar perubahan yang berbeda menggantikan penggunaan A dengan sepotong demi sepotong (misalnya satu daftar perubahan per modul), dan daftar perubahan terakhir menghapus perpustakaan A.

Apakah yang terbaik dapat dan hanya mencoba untuk menemukan kelemahan yang jelas (mungkin ini yang paling dituju oleh ulasan kode)?

Jangan meremehkan nilai potensial dari revues kode. Mereka pandai mendeteksi bug:

• Temukan bug yang akan sulit dideteksi saat pengujian
• Temukan bug yang akan sulit diidentifikasi / diperbaiki melalui pengujian

Mereka juga berguna karena alasan lain:

• Membantu melatih anggota tim
• Bantu untuk memastikan bahwa kode memenuhi metrik kualitas lain, mis. Bantuan untuk memastikan bahwa kode itu dapat dimengerti dan dipelihara dan bukan hanya bebas dari bug

Apa yang harus dilakukan dalam situasi ini?

Dalam kasus terbaik / ideal, melewati pemeriksaan kode tidak hanya berarti "tidak ada bug yang jelas": itu berarti "jelas tidak ada bug" (walaupun tentu saja Anda juga ingin mengujinya).

Jika Anda tidak dapat memverifikasi basis kode baru melalui inspeksi kode maka perlu pengujian "kotak hitam" yang lebih luas. Anda mungkin terbiasa dengan siklus pengembangan di mana Anda memasukkan kode ke dalam produksi setelah lulus inspeksi, tetapi jika tidak dapat "lulus inspeksi" maka Anda tidak dapat "memasukkannya ke dalam produksi" dan memerlukan siklus yang lebih lama: mis. Tes integrasi , tes sistem, tes alfa, tes penerimaan, tes beta, dll.

tidak ada rangkaian lengkap unit test yang tersedia atau unit test tidak layak untuk kode terfragmentasi yang diubah

Bagaimana dengan tes integrasi, sistem, dan penerimaan?

Bagaimanapun, Anda mungkin harus memberi tahu manajer proyek dan manajer produk bahwa kode itu hampir pasti bermasalah, dengan jumlah bug yang tidak diketahui; dan bahwa mereka akan "mendapatkan apa yang mereka periksa" daripada hanya mendapatkan "apa yang mereka harapkan" - yaitu bahwa kualitas kode tidak lebih baik daripada pengujian mereka (karena kualitas kode belum dan tidak dapat dijamin oleh inspeksi kode) .

Mereka mungkin harus menyampaikan pesan itu kepada pelanggan atau pengguna, sehingga mereka melakukan pengujian beta (jika mereka bersedia menjadi pengguna awal), atau menggunakan versi yang lebih lama sampai versi baru keluar dari beta (jika tidak).

Banyak kode ditulis dan digabung tanpa peninjauan kode yang tepat. Itu bisa bekerja. Ada alasan mengapa itu disebut kode bau bukan "kode rusak" atau sesuatu untuk efek itu. Kurangnya tinjauan kode adalah tanda peringatan, bukan pertanda malapetaka.

Solusi untuk masalah ini adalah tidak ada satu solusi yang cocok untuk semua case yang dapat kami masukkan ke dalam jawaban gaya StackExchange. Ini adalah konsensus yang kuat dari komunitas pengembangan perangkat lunak bahwa tinjauan kode merupakan "praktik terbaik" yang penting, dan dalam hal ini sedang dilewati. Perkembangan Anda tidak lagi dalam saluran sempit "mengikuti semua praktik terbaik". Anda harus menemukan cara Anda sendiri.

Apa itu "praktik terbaik"? Ketika Anda benar-benar melakukannya, itu adalah serangkaian praktik yang menurut orang umumnya membuat kode lebih baik. Apakah mereka membuat kode yang benar? Tidak! Internet dipenuhi dengan cerita-cerita dari perusahaan-perusahaan yang mengikuti "praktik terbaik" dan membuat mereka macet karenanya. Mungkin sudut pandang yang lebih baik dari "praktik terbaik" adalah bahwa mereka adalah "api dan lupakan" solusi dunia perangkat lunak. Saya tidak tahu apa-apa tentang perusahaan Anda, proyek Anda, tim Anda, dan dapat mengatakan "praktik terbaik" sebagai hal-hal yang akan membantu Anda. Mereka adalah saran umum "jangan membahayakan".

Anda jelas telah menyimpang dari rencana ini. Untungnya, Anda mengenalinya. Kerja bagus! Mereka mengatakan pengetahuan adalah setengah dari pertempuran; jika demikian, kesadaran lebih dari setengahnya! Sekarang solusi diperlukan. Dari uraian Anda, jelas bahwa lingkungan bisnis tempat Anda berkembang telah berevolusi ke titik di mana saran membosankan "lakukan tinjauan kode, praktik terbaik" tidak akan memotongnya. Untuk ini, saya merekomendasikan aturan kunci yang saya gunakan ketika datang ke praktik terbaik perangkat lunak:

Tidak ada praktik terbaik pengembangan perangkat lunak melampaui kebutuhan bisnis.

Terus terang, mereka membayar gaji Anda, dan kelangsungan hidup bisnis biasanya jauh lebih penting daripada kualitas perangkat lunak. Kami tidak suka mengakuinya, tetapi perangkat lunak yang ditulis dengan sempurna tidak ada gunanya jika terperangkap dalam tubuh perusahaan yang sekarat karena upaya mempertahankan perangkat lunak yang ditulis dengan sempurna itu.

Jadi kemana kamu pergi? Ikuti jejak kekuatan. Anda telah menunjukkan bahwa, karena alasan yang tidak disebutkan, tidak masuk akal untuk menjalani peninjauan kode untuk beberapa tugas. Dalam pengalaman saya, alasan itu selalu bersifat sementara. Itu selalu "tidak cukup waktu" atau "tidak cukup uang untuk menjaga gaji tetap mengalir saat Anda menghabiskan waktu." Ini bisnis; tidak masalah. Jika mudah, semua orang akan melakukannya. Ikuti jejak kekuatan ke atas, dan temukan manajemen yang berada dalam posisi untuk membantu Anda memahami mengapa peninjauan kode bukan opsi. Bahasa sulit, dan cukup sering sebuah dekrit akan mengalir dari manajemen tingkat atas dan terdistorsi. Solusi untuk masalah Anda mungkin tersembunyi dalam distorsi itu.

Jawabannya adalah, tentu saja, skenario kasus tertentu. Ini mirip dengan mencoba memprediksi apakah lemparan koin akan menjadi kepala atau ekor. Praktik terbaik mengatakan untuk membalikkannya 100 kali dan harapannya akan menjadi sekitar 50 kepala dan 50 ekor, tetapi Anda tidak punya waktu untuk membalikkannya 1 kali. Di sinilah detail situasi Anda penting. Tahukah Anda bahwa koin biasanya akan mendarat dalam orientasi yang sama dengan yang dilemparkan dari sekitar 51% dari waktu? Apakah Anda meluangkan waktu untuk mengamati ke arah mana koin itu sebelum melemparkan? Itu bisa membuat perbedaan.

Salah satu solusi umum yang mungkin tersedia bagi Anda adalah mencoba menemukan cara untuk menarik keluar proses peninjauan kode dan menjadikannya upaya yang sangat murah. Sebagian besar biaya proses tinjauan kode adalah bahwa setiap orang 100% didedikasikan untuk tinjauan kode saat Anda melakukannya. Ini harus terjadi karena, setelah peninjauan kode selesai, kode diberkati. Mungkin Anda bisa meletakkan kode di cabang yang berbeda, dan melakukan review kode secara paralel dengan pengembangan di trunk utama. Atau mungkin Anda bahkan dapat mengaturnya sehingga perangkat lunak melakukan pengujian untuk Anda. Mungkin Anda berada dalam lingkungan bisnis di mana pelanggan Anda dapat menjalankan kode "baru" secara paralel dengan yang lama, dan meminta mereka membandingkan hasilnya. Ini mengubah pelanggan menjadi sekelompok perangkat pembuatan kasus penggunaan.

Kunci dari semua yang menjalankan "maybes" ini adalah Anda harus berusaha membuat kode Anda dengan mudah dipecah menjadi beberapa bagian. Anda mungkin dapat "membuktikan" kepingan kode tanpa mengandalkan tinjauan kode formal dengan menggunakannya dalam proyek yang kurang penting. Lebih mudah untuk melakukan ini jika perubahannya dalam potongan yang lebih kecil, bahkan jika jumlah totalnya terlalu besar untuk ditinjau oleh rekan.

Secara umum, cari solusi khusus untuk proyek Anda, perusahaan Anda, tim Anda. Jawaban tujuan umum adalah "praktik terbaik." Anda tidak menggunakan itu, jadi Anda harus mencari lebih banyak solusi khusus untuk masalah ini, kali ini. Ini bisnis. Jika semuanya berjalan seperti yang kami harapkan sepanjang waktu, IPO akan jauh lebih mudah untuk menetapkan nilai, bukan?

Jika mengganti tinjauan kode adalah perjuangan, ingatlah bahwa tidak pernah ada satu pun kode yang terbukti bekerja dalam tinjauan kode. * Semua yang dilakukan tinjauan kode adalah memberi Anda kepercayaan diri pada kode, dan kesempatan untuk melakukan koreksi sebelum mereka menjadi masalah. Kedua produk berharga dari tinjauan kode ini dapat diperoleh dengan cara lain. Tinjauan kode hanya memiliki nilai yang diakui karena sangat baik dalam hal itu.

* Yah, hampir: microkernel L4 mendapat review kode beberapa waktu lalu oleh sistem bukti otomatis yang membuktikan kode-nya, jika dikompilasi oleh kompiler C ++ yang sesuai, akan melakukan apa yang dikatakan oleh dokumentasi.

Seperti yang ditunjukkan oleh @EricLippert dalam jawaban yang luar biasa, perubahan semacam ini membutuhkan lebih banyak perhatian, bukan kurang . Jika Anda menyadari perubahan yang sedang Anda kerjakan akan menjadi perubahan seperti itu, ada beberapa strategi yang mungkin membantu:

• Berkomitmen untuk mengontrol versi sering. Peninjauan dapat berlanjut berdasarkan komitmen-per-komitmen, dan mungkin lebih bisa dimengerti ketika Anda memiliki komitmen yang lebih kecil.
• Pastikan Anda mengomentari alasan untuk setiap perubahan sejelas mungkin.
• Jika mungkin, gunakan pemrograman pasangan untuk jenis perubahan ini. Memiliki tiga pandangan tentang masalah daripada 2 dapat membantu menghindari masalah yang mungkin terlewatkan secara normal, dan memiliki pasangan saat Anda bekerja dapat membantu Anda meningkatkan komentar pada kode yang Anda pikir sudah jelas tetapi ternyata kurang jelas. dari yang Anda yakini, yang pada gilirannya akan membantu peninjau nanti. Bantuan dalam (a) mengurangi kesalahan selama pengembangan dan (b) dokumentasi yang lebih baik sebenarnya berarti bahwa lebih sedikit jam kerja dihabiskan untuk hal ini, meskipun lebih banyak orang yang terlibat.

Lebih banyak jawaban membahas bagaimana Anda sampai pada titik ini. Banyak dari mereka memberikan beberapa saran untuk memperbaiki situasi, tetapi saya ingin memasukkan jawaban saya untuk memberikan jawaban singkat.

Apa yang harus dilakukan ketika ulasan kode "terlalu sulit?"

1. Kembali ke cabang kode baris utama
2. Tulis tes untuk fungsi yang telah Anda refactored (mis. Tes fungsional)
3. Dapatkan tes untuk lulus
4. Gabungkan tes ke dalam kode yang "sulit untuk diuji"
5. Apakah tes masih lulus?

Iya

Anda para pengembang hebat! Kucing kembali untuk semua orang!

(atau bagi mereka yang tidak tumbuh dewasa menonton " The Simpsons " di televisi AS: Jika tes lulus, lewati mencoba untuk melihat perbedaan dan mintalah pengembang membimbing Anda melakukan tur perubahan)

Tidak

Terus refactoring dan menambahkan cakupan tes sampai tes berlalu.

Seperti perkalian, tinjauan kode memberikan hasil nol bila diterapkan ke nol. Itu tidak meningkatkan nilai dalam kasus seperti itu, sementara dalam kebanyakan kasus lain itu akan meningkatkan.

Kode yang Anda perlukan untuk bekerja terlalu buruk dirancang untuk mendapat manfaat dari proses peninjauan kode selama pengembangan lebih lanjut. Gunakan proses peninjauan kode untuk memperbaiki atau mengembangkannya kembali.

Mungkin juga kodenya masih tertahankan tetapi tugasnya tidak baik. Itu terlalu luas dan seharusnya dilakukan dengan peningkatan yang lebih kecil.