Kapan melakukan review kode ketika melakukan integrasi berkelanjutan?

Kami mencoba untuk beralih ke lingkungan integrasi berkelanjutan tetapi tidak yakin kapan harus melakukan tinjauan kode. Dari apa yang saya baca tentang integrasi berkelanjutan, kita harus berusaha memeriksa kode sesering beberapa kali sehari. Saya berasumsi, ini bahkan berarti untuk fitur yang belum lengkap.

Jadi pertanyaannya adalah, kapan kita melakukan review kode?

Kita tidak dapat melakukannya sebelum memeriksa kode, karena itu akan memperlambat proses di mana kita tidak akan dapat melakukan checkin setiap hari, apalagi beberapa checkin per hari.

Juga, jika kode yang kita periksa hanya kompilasi tetapi tidak lengkap fitur, melakukan tinjauan kode maka tidak ada gunanya, karena sebagian besar ulasan kode paling baik dilakukan ketika fitur tersebut selesai. Apakah ini berarti kita harus melakukan review kode ketika fitur selesai, tetapi kode yang tidak direview akan masuk ke repositori?

IMO, Anda harus meninjau kode sebelum dipublikasikan ke jalur utama sehingga jalur utama hanya memiliki kode kualitas tertinggi.

OTOH, poin yang baik dapat dibuat bahwa 'mengapa repot-repot meninjau jika otomasi uji CI tidak berjalan di atasnya?', Jadi mungkin yang terbaik adalah memberi pengembang masing-masing cabang pribadi yang akan dibangun dan diuji oleh server CI untuk mereka . Dengan cara itu mereka pertama kali melakukan dan mendorong di sana, kemudian setelah melewati memeriksanya, kemudian bergabung ke jalur utama (di mana ia akan menjalankan lagi melalui server CI).

Anda harus meninjau kode non-fitur lengkap untuk memastikan bahwa perancah untuk fitur masa depan sudah ada, atau setidaknya tidak ada yang dimasukkan yang akan mencegah fitur masa depan tersebut diimplementasikan.

Perhatikan juga bahwa tinjauan kode tidak harus lambat, atau sinkron - alat seperti gerrit atau papan ulasan atau sejenisnya dapat membuatnya tidak sinkron dan tidak menyakitkan.

(Pengungkapan penuh: Saya pernah bekerja untuk SmartBear, pembuat Code Collaborator, alat peninjau kode)

Siapkan pemrograman pasangan?

Semua kode ditinjau karena sedang diketik tanpa memperpanjang proses atau memperkenalkan langkah lain.

Berikut adalah kutipan dari penulis pengiriman berkelanjutan:

Jez Humble Menulis sebagai:

Saat ini saya sedang menulis posting blog tentang topik ini. Jawaban singkatnya adalah ini:

• Cara terbaik untuk meninjau kode adalah melalui pemrograman pasangan
• Merupakan ide yang buruk untuk menggabungkan gerbang ke jalur utama - dengan membuat cabang terpisah, misalnya - pada proses peninjauan formal. Ini menghambat integrasi berkelanjutan (cara terbaik untuk mengurangi risiko perubahan buruk, yang ingin Anda capai).
• Saya pikir Gerrit adalah alat yang bagus, tetapi harus digunakan setelah check-in (sebenarnya memang dirancang demikian). Bagian dari tugas pengembang senior adalah meninjau semua lapor-masuk. Mereka dapat, misalnya, berlangganan umpan.

Untuk meringkas: review kode bagus. Jadi bagus, kita harus melakukannya terus menerus, melalui pemrograman pasangan dan mengkaji komitmen. Jika seorang senior dev menemukan komitmen buruk, dia harus berpasangan dengan orang yang berkomitmen untuk membantu mereka memperbaiki masalah.

Gating bergabung ke arus utama pada tinjauan formal itu buruk, dan membuat cabang untuk melakukannya adalah ekstra buruk, karena alasan yang sama bahwa cabang fitur buruk.

Terima kasih,

Jez.

tautan asli adalah: https://groups.google.com/forum/#!msg/continuousdelivery/LIJ1nva9Oas/y3sAaMtibGAJ

Saya tidak tahu apakah itu cara terbaik untuk melakukannya ... tapi saya akan menjelaskan bagaimana kami melakukannya. Satu atau lebih pengembang bekerja pada cabang tertentu dan melakukan kode mereka sesering mungkin untuk menghindari buang waktu penggabungan yang tidak akan terjadi sebaliknya. Hanya ketika kode sudah siap, kode tersebut dimasukkan ke dalam kepala. Nah, itu untuk komit dan hal cabang / kepala.

Sedangkan untuk tinjauan kode, kami menggunakan Sonar sebagai alat integrasi berkelanjutan kami (dan Maven / Jenkins untuk berinteraksi dengan Sonar) untuk memberikan kami hasil pengujian baru, cakupan kode, dan tinjauan kode otomatis setiap pagi (pembuatan dilakukan setiap malam) sehingga kami dapat pengembang dapat menghabiskan maksimal satu jam setiap pagi untuk memperbaiki masalah mereka / bau kode. Setiap pengembang bertanggung jawab (bangga juga!) Untuk fitur yang ia tulis. Sekarang, itu tinjauan kode otomatis, yang hebat untuk menemukan potensi masalah teknis / arsitektur, tetapi yang lebih penting adalah menguji apakah fitur-fitur baru yang diimplementasikan melakukan apa yang diinginkan oleh bisnis, dengan benar.

Dan untuk itu, ada dua hal: tes integrasi dan tinjauan kode rekan. Tes integrasi membantu untuk menjadi cukup percaya diri bahwa kode baru tidak merusak kode yang ada. Adapun tinjauan kode rekan, kami melakukannya pada sore hari Jumat, yang merupakan waktu yang sedikit lebih santai untuk melakukan itu :-) Setiap pengembang ditugaskan ke cabang yang tidak dikerjakannya, membutuhkan waktu untuk membaca persyaratan dari fitur baru terlebih dahulu, lalu periksa apa yang telah dilakukan. Pekerjaannya yang paling penting adalah memastikan bahwa kode baru berfungsi seperti yang diharapkan dengan persyaratan, tidak melanggar "aturan" kita sendiri (gunakan objek ini untuk itu, dan bukan yang itu), mudah dibaca, dan memungkinkan untuk ekstensi mudah.

Jadi kami memiliki dua ulasan kode, satu otomatis dan satu "manusia" dan kami mencoba menghindari melakukan kode yang tidak ditinjau ke dalam cabang HEAD. Sekarang ... Itu kadang-kadang terjadi karena berbagai alasan, kami jauh dari sempurna, tetapi kami mencoba untuk menjaga keseimbangan yang adil antara kualitas dan biaya (waktu!)

@ pjz memberikan jawaban yang bagus juga, dan ia menyebutkan alat peninjau kode. Saya tidak pernah menggunakan apapun, jadi saya tidak bisa mengatakan apa-apa tentang itu ... walaupun saya telah tergoda di masa lalu untuk bekerja dengan Crucible karena kita sudah menggunakan JIRA .

Saya pikir konsep utama yang akan membantu adalah area "Pementasan".

Ya, Anda tidak ingin memeriksa kode yang rusak. Tetapi Anda juga harus sering memeriksa kode. Apakah ini menyiratkan kesempurnaan? ;) Tidak. Cukup gunakan beberapa area dan DVCS seperti git.
Dengan cara ini Anda membuat perubahan (secara lokal) dan sering melakukannya saat Anda menguji dan mengembangkan sampai tes berlalu. Kemudian Anda mendorong ke area pementasan untuk meninjau kode.

Anda kemudian harus mendorong dari Staging ke upaya QA lain seperti tes browser dan tes pengguna. Akhirnya Anda dapat pergi ke area pengujian volume, lalu akhirnya produksi.

Ada juga alur kerja di sini seperti setiap orang bekerja di cabang utama atau menggunakan cabang individu untuk semua upaya.

Integrasi yang berkelanjutan itu sendiri juga dapat terjadi di berbagai tingkatan. Ini bisa bersifat lokal ke mesin pengembang 'sampai tes lulus' dan juga bisa di area stage dan qa ketika kode masuk ke mereka.

Tinjau kode terpisah dan integrasi berkelanjutan!

Mengapa Anda menggabungkannya?

Kami menggunakan aliran git untuk repositori kami, dan kami melakukan tinjauan kode ketika datang untuk bergabung ke dalam cabang pengembangan.

Apa pun yang dikembangkan selesai, dapat digunakan, dan ditinjau kode.

Kami juga telah menyiapkan CI untuk cabang-cabang pengembangan dan master kami.

Saya benar-benar-benar-benar berpikir Anda akan membutuhkan DVCS (misalnya lincah, git) untuk melakukan ini secara alami. Dengan CVCS Anda akan membutuhkan cabang dan berharap untuk dewa apa pun yang Anda miliki tidak ada neraka yang menyatu.

Jika Anda menggunakan DVCS, Anda dapat meningkatkan proses integrasi sehingga kode sudah membuatnya ditinjau sebelum sampai ke server CI. Jika Anda tidak memiliki DVCS, well, kode akan tiba di server CI Anda sebelum ditinjau kecuali pengulas kode meninjau kode pada setiap mesin pengembang sebelum mereka mengirimkan perubahan mereka.

Cara pertama untuk melakukannya, khususnya jika Anda tidak memiliki perangkat lunak manajemen repositori yang dapat membantu mempublikasikan repositori pribadi (misalnya bitbucket, github, rhodecode), adalah memiliki peran integrasi hirarkis. Dalam diagram berikut, Anda dapat meminta letnan untuk meninjau pekerjaan pengembang, dan menjadikan diktator sebagai integrator utama yang meninjau bagaimana letnan menggabungkan pekerjaan.

Cara lain untuk melakukannya jika Anda memiliki perangkat lunak manajemen repositori, adalah dengan menggunakan alur kerja seperti berikut:

Perangkat lunak manajemen repositori biasanya membantu memancarkan pemberitahuan ketika ada aktivitas di repositori (mis. Email, rss) serta memungkinkan permintaan-tarik . Tinjauan kode dapat terjadi secara organik selama permintaan tarik, karena permintaan tarik biasanya membuat orang terlibat dalam percakapan untuk membuat kode terintegrasi. Ambil permintaan tarik publik ini sebagai contoh. The manajer integrasi sebenarnya tidak bisa membiarkan kode untuk tiba ke repositori diberkati (alias "repositori pusat") jika kebutuhan kode untuk dikoreksi.

Yang paling penting, dengan DVCS Anda masih dapat mendukung alur kerja yang terpusat, Anda tidak perlu memiliki alur kerja mewah-hebat jika Anda tidak ingin ... tetapi dengan DVCS Anda dapat memisahkan repositori pengembangan pusat dari CI server dan memberi seseorang wewenang untuk mendorong perubahan dari repo dev ke repo CI setelah sesi peninjauan kode telah dilakukan .

PS: Kredit untuk gambar-gambar itu pergi ke git-scm.com

Mengapa tidak memiliki lebih dari satu repositori? Satu untuk pekerjaan "harian", mengendarai server integrasi berkelanjutan, menjalankan semua tes unit & tes integrasi untuk mendapatkan loop umpan balik ketat yang bagus, dan satu lagi untuk pekerjaan "stabil", di mana komit lebih jarang dilakukan, tetapi harus melalui peninjauan.

Bergantung pada jalur yang diambil perubahan saat mereka bergerak melalui sistem, ini bisa berakhir menjadi sedikit solusi yang kompleks, dan mungkin bekerja paling baik saat menggunakan alat seperti Git, atau Mercurial Queue, (peringatan: Saya tidak menggunakan kemarahan) tetapi banyak organisasi melakukan hal serupa.

Apakah ini berarti kita harus melakukan review kode ketika fitur selesai, tetapi kode yang tidak direview akan masuk ke repositori?

Jauh di atas adalah cara saya melihatnya dilakukan dalam setidaknya tiga proyek yang secara intensif menggunakan integrasi berkelanjutan dan per ingatan saya itu bekerja seperti pesona. Praktik ini dikenal sebagai ulasan kode pasca-komitmen - cari web untuk istilah ini jika Anda tertarik dengan detail.

• ^{Di sisi lain, satu-satunya kasus ketika saya berada di proyek mencoba untuk "menikah" ulasan kode pra-komit dengan CI ternyata agak menyakitkan. Yah ketika semuanya berjalan 100% dengan lancar, itu OK - tetapi bahkan gangguan yang jarang terjadi (seperti ketika pengulas utama dan cadangan keduanya tidak tersedia untuk mengatakan beberapa jam) membuat stres terlihat. Saya juga memperhatikan bahwa semangat tim agak menderita - ada terlalu banyak konflik.}

Pertama, kita harus mengklarifikasi konsep "integrasi berkelanjutan". Dalam metode pengembangan tradisional, integrasi berkesinambungan berarti kita dapat mengintegrasikan dan membangun repositori kode sumber setiap hari, yang akan menghindari perangkap "neraka integrasi". Ulasan kode selalu antara periode Coding dan pengujian Unit. Kami harus menjamin bahwa penggabungan kode ke cabang dapat dikompilasi tanpa kesalahan. Jarang ada situasi di mana bagian-bagian fitur bergabung ke cabang karena sulit untuk menangani koherensi antarmuka dan kompilasi kesalahan.

Integrasi berkelanjutan sangat populer dalam proses Pemrograman Ekstrim. Pengembangan yang digerakkan oleh pengujian menambahkan pemrograman Pair, yang merupakan bagian sebenarnya dari proses tinjauan kode, membuat integrasi berkelanjutan mudah untuk diimplementasikan. Extreme Programming sendiri adalah proses pengkajian dan integrasi kode berkelanjutan. Ulasan kode ada di mana-mana.

Di beberapa komunitas open source, ulasan kode dijalankan sebelum kode bergabung ke cabang. Selalu merupakan orang yang paling berpengalaman dalam tim ini untuk melakukan tinjauan kode dan memutuskan apakah kode tersebut dapat bergabung ke cabang utama. Dengan cara ini, periode Integrasi Berkelanjutan sedikit lebih lama tetapi kualitas kode sedikit lebih baik.

Kembali ke pertanyaan. Tidak ada jawaban standar untuk kapan melakukan tinjauan kode, dan itu tergantung pada proses pengembangan asli Anda dan implementasi integrasi berkelanjutan Anda yang sebenarnya.