Menghentikan pengembang yang berkomitmen ke cabang yang salah di DVCS

Masalah

Saya sedang mengerjakan proyek perangkat lunak yang memiliki sekitar 10 pengembang, kami membagikan kode sumber melalui Mercurial. Kami memiliki cabang pengembangan dan produksi per rilis. Berulang kali selama proyek kami memiliki kode sumber dari satu cabang yaitu v1 masuk ke cabang patch dan pemeliharaan untuk rilis perangkat lunak sebelumnya yaitu v2.

Ini menghasilkan waktu yang dihabiskan untuk membatalkan komit yang salah, atau salah (mungkin non-QAd) kode menjangkau dan ditempatkan di cabang yang salah jika kita tidak melihat bahwa kode tersebut telah masuk ke cabang yang salah.

Cabang dan desain / metode penggabungan kami

               v1-test   v1-patch1   v1-patch2
               ^---------^-----------^                v1-prod
              /         / \           \
-----------------------/   \           \              v1-dev
              \             \           \
               --------------------------\            v2-dev
                             \       \    \ 
                              ^-------^-------------  v2-prod
                              v2-test v2-patch1      

Oleh karena itu kami akan bekerja pada cabang pengembangan rilis, sampai dianggap siap , cabang itu untuk cabang pengujian / UAT / Produksi, di mana semua rilis dan pemeliharaan dilakukan. Tag digunakan untuk membuat rilis cabang ini. Saat v1 sedang diuji, cabang akan dibuat untuk v2 dan pengembang akan mulai bekerja pada fitur-fitur baru.

Apa yang cenderung terjadi adalah bahwa pengembang melakukan pekerjaan karena untuk cabang v2-dev menjadi v1-dev atau v1-prod, atau lebih buruk lagi, mereka menggabungkan v2-dev menjadi v1-prod (atau kesalahan serupa lainnya).

Kami memberi tahu sebagian besar pengembang untuk tidak mengakses cabang -prod , namun kode masih menyelinap masuk. Sekelompok pengembang yang lebih senior `menjaga 'cabang -prod.

Perlu dicatat bahwa sementara v2 baru saja memulai pengembangan, mungkin masih ada beberapa tambalan yang cukup besar ke v1 untuk memperbaiki masalah. Yaitu v1 mungkin tidak hanya mendapatkan patch kecil yang aneh.

Apa yang telah kami coba sejauh ini

• Memiliki cabang -produk yang terpisah, dengan penjaga gerbang. Cabang -prod harus memunculkan peringatan melalui namanya dan sebagian besar pengembang tidak perlu berada di cabang itu. Ini belum benar-benar mengurangi masalah.
• Meningkatkan kesadaran akan masalah ini di antara para pengembang, untuk mencoba dan membuat mereka lebih waspada. Sekali lagi ini tidak terlalu berhasil.

Kemungkinan alasan yang saya lihat untuk pengembang melakukan ke cabang yang salah

• Desain cabang terlalu rumit
• Memiliki pengembangan aktif di beberapa cabang secara paralel. (Proyek ini menunjukkan gejala menggunakan model longsor .)
• Pengembang tidak cukup memahami DVCS

Pertanyaan yang pernah saya baca yang agak relevan

Saya sudah membaca pertanyaan ini tentang tidak melakukan ke cabang yang salah dan saya merasa bahwa jawaban mengenai isyarat visual mungkin membantu. Namun saya tidak sepenuhnya yakin bahwa masalah yang kita alami bukanlah gejala dari masalah yang lebih mendasar.

Dengan petunjuk visual, kita dapat memasukkannya ke dalam baris perintah dengan mudah, namun sekitar setengah dari tim menggunakan gerhana yang saya tidak yakin bagaimana cara memasukkan isyarat visual.

Pertanyaan

Metode apa, dalam bentuk perangkat lunak, manajemen proyek atau tata kelola yang dapat kita gunakan untuk mengurangi (idealnya berhenti) melakukan komitmen ke cabang yang salah mengambil waktu kita atau mengotori kode kita yang digunakan?

Komentar spesifik tentang alasan yang saya yakin dapat berkontribusi seperti yang dijelaskan di atas akan dihargai, tetapi ini tidak seharusnya membatasi balasan Anda.

Masalahnya adalah Anda mengubah apa arti cabang adalah bagian dari proses.

Awalnya, v1 devcabang itu untuk pengembangan. Semua fitur baru ada di sana. Di beberapa titik di masa depan, itu menjadi cabang pemeliharaan untuk v1 releasecabang. Inilah inti masalahnya.

Ini bukan karena pengembangnya ceroboh, itu bahwa izin dan peran cabang ceroboh dan dapat berubah.

Yang perlu Anda lakukan adalah menetapkan apa peran masing-masing cabang, dan mempertahankan peran itu. Jika peran berubah, cabang.

Sebagai contoh:

 developer
  commits    |   |  |   |    |     |   |     |
             v   v  v   v    v     v   v     v
 dev  +--+---------------------+------------------->
         |           ^    ^    |           ^    ^
         |           |    |    |           |    |
 v1      +----+------+----+    |           |    |
           prod  patches       |           |    |
                               |           |    |
                               |           |    |
 v2                            +-----+-----+----+
                                  prod  patches

Dalam model ini, pengembang selalu berkomitmen untuk dev. Jika Anda membuat tambalan, Anda memeriksa tambalan ke cabang rilis itu (atau lebih baik, cabang cabang rilis untuk patch dan kemudian menggabungkannya kembali ke cabang rilis).

Salah satu artikel yang harus Anda baca (dan mungkin itu adalah pernyataan yang meremehkan 'seharusnya') adalah Strategi Cabang SCM Lanjutan oleh Stephen Vance.

^{Dalam tulisan ini, saya pertama mendefinisikan cabang dalam arti umum. Saya kemudian membahas berbagai strategi untuk bercabang, mulai dengan yang jelas dan bergerak ke beberapa yang lebih tepat untuk upaya pembangunan yang lebih besar. Sepanjang jalan, saya membahas pro dan kontra dari masing-masing strategi, menggunakannya untuk memotivasi perubahan yang menyusun strategi yang lebih kompleks ...}

Dalam artikel ini, ia mengidentifikasi lima peran yang mungkin dimiliki cabang. Kadang-kadang cabang dapat mengisi dua peran dan peran tidak serta-merta memerlukan cabang baru selama kebijakan peran tidak mengubah pertengahan cabang (Anda terkadang akan melihat penyebutan "cabang pada kebijakan yang tidak kompatibel").

Peran-peran ini adalah:

1. Garis utama. Di sinilah cabang dibuat. Selalu bercabang dari garis utama membuat penggabungan menjadi lebih mudah karena kedua cabang akan memiliki leluhur yang sama yang tidak bercabang demi cabang.
2. Pengembangan. Di sinilah pengembang memeriksa kode. Seseorang mungkin memiliki beberapa cabang pengembangan untuk mengisolasi perubahan risiko tinggi dari yang rutin dan biasa.
3. Pemeliharaan. Perbaikan bug pada lingkungan produksi yang ada.
4. Akumulasi. Saat menggabungkan dua cabang, seseorang mungkin tidak ingin mengambil risiko mengganggu kestabilan jalur utama. Jadi percabangkan mainline, gabungkan cabang ke akumulator dan bergabung kembali ke mainline setelah semuanya selesai.
5. Pengemasan. Pengemasan rilis terjadi di cabang pengemasan. Ini sering menjadi rilis dan berfungsi untuk mengisolasi upaya rilis dari pembangunan. Lihat Bagaimana menangani komitmen yang tidak diinginkan yang merusak rilis yang sudah berjalan lama? untuk contoh di mana kemasan bertentangan dengan pengembangan.

Dalam contoh Anda, Anda memiliki arus utama berjenjang (ini adalah masalah - itu membuat penggabungan lebih sulit - apa yang terjadi jika Anda ingin menggabungkan perbaikan untuk v1 ke v2 dan v3?), Cabang dev yang menjadi cabang pemeliharaan ( perubahan kebijakan, ini masalah).

Ok, Anda bilang, itu hebat, tapi ini ditulis untuk memaksa yang merupakan VCS terpusat - Saya menggunakan DVCS.

Mari kita lihat model git-flow dan lihat bagaimana itu berlaku.

Cabang master (biru) adalah cabang rilis - untuk penandaan. Itu bukan arus utama. Garis utama sebenarnya adalah cabang berkembang (kuning). Cabang rilis (hijau) adalah peran pengemasan. Pengembangan risiko rendah terjadi di jalur utama, pengembangan risiko tinggi terjadi di cabang fitur (merah muda). Dalam model ini, akumulasi dilakukan di cabang pengembangan. Perawatan dianggap 'perbaikan panas' yang berwarna merah.

Meskipun kebijakan peran tidak sama persis (setiap produk memiliki siklus hidup yang sedikit berbeda), mereka cocok.

Melakukan ini harus menyederhanakan kebijakan percabangan Anda dan membuatnya lebih mudah untuk semua orang yang terlibat.

Meskipun Anda telah mencoba menggunakan cabang -prod terpisah dengan gatekeeper, sepertinya repositori yang digunakan untuk benar-benar melakukan build produksi. Jika build produksi hanya dilakukan dari repositori produksi, hanya dapat ditulis oleh penjaga gerbang maka para devs tidak akan bisa mendorongnya. Ini menempatkan beban pada penjaga gerbang, yang hanya akan mendorong ke repo produksi setelah ditinjau. Tentu saja orang masih dapat menarik dari repo produksi ketika dibutuhkan.

Saat orang mendapatkan pengalaman, mereka harus dirotasi melalui peran penjaga gerbang, untuk mendapatkan pemahaman atau perhatian yang lebih dalam yang tampaknya kurang mereka miliki.

Dan sebagai aturan umum, terapkan Occam's Razor: seluruh struktur repo harus sesederhana mungkin untuk melakukan pekerjaannya.

Lihat juga komentar Sean.

Mungkin saja para devs tidak mendapatkan DVCS dengan cukup baik, tetapi saya pikir itu jauh lebih mungkin bahwa Anda hanya memiliki terlalu banyak hal yang terjadi, dan devs tidak dapat melacak apa yang mereka lakukan dari waktu ke waktu. Mereka lupa di cabang mana mereka seharusnya bekerja, dan perubahan mereka berakhir di tempat yang salah.

Saya sarankan Anda memiliki masalah dengan fakta bahwa semua orang bekerja di semua cabang ini secara teratur.

Saran @ andy256 tentang repositori terpisah untuk prod tentu akan membantu, tetapi Anda mungkin perlu mempertimbangkan membagi pekerjaan secara berbeda, atau mungkin mengatur hal-hal sehingga tidak ada pengembang yang mengerjakan lebih dari satu cabang dalam satu minggu tertentu.

Sepertinya Anda telah mengidentifikasi salah satu beruang bug utama saya. Mayoritas alat kontrol sumber persis seperti itu, alat kontrol sumber. Mereka memungkinkan sekelompok pengembang untuk bekerja pada direktori sumber yang sama, membuat perubahan dan menangani konflik. Ada beberapa sisi kasar di sepanjang jalan, tetapi cvs, subversi, git, mercural dll semua memenuhi ini.

Kemudian Anda memiliki langkah berikutnya, ketika Anda perlu menstabilkan kode untuk rilis, dan Anda memperkenalkan percabangan. Di sinilah alat mulai gagal pengembang. Alat ini mampu membuat cabang, dan bahkan mengidentifikasi set perubahan yang timbul di cabang setelah mereka bercabang, tapi itu bukan masalah yang sekarang Anda hadapi.

Alat-alatnya sangat buruk dalam memilih perubahan mana yang perlu disalin ke cabang lain, dan kapan itu perlu terjadi. Git-flow berupaya untuk menyelesaikan ini dengan menciptakan strategi percabangan yang berarti bahwa ketika cabang digabung, SEMUA perubahannya digabungkan, dan kemudian mengharuskan programmer untuk membuat pilihan yang masuk akal tentang kapan dan cabang mana yang digabung.

Pada repositori tunggal di mana semua pengembang bekerja pada satu proyek yang memiliki utas rilis tunggal, git flow memecahkan masalah, tetapi hidup tidak sesederhana itu bagi banyak perusahaan.

Lingkungan yang kompleks adalah di mana Anda memiliki banyak tim yang bertanggung jawab atas berbagai aspek dari solusi total, melakukan rilis internal ke tim lain. git-flow tidak mampu menyelesaikan masalah seperti ini.

Satu-satunya cara saya melihat pekerjaan ini, adalah jika masing-masing tim bertanggung jawab untuk menentukan pembebasan mereka, dan mengendalikan ketika ketergantungan mereka berubah. Hanya karena tim A telah merilis rilis 1.3, tim B hanya mulai menggunakan rilis tim A 1.3 saat tim B memilih.

Akibatnya, tim pengembang menentukan grup perubahan yang perlu dipindahkan, dan pengembang yang menerima perubahan menentukan kapan mereka menerima grup perubahan.

Satu-satunya alat kontrol sumber yang saya lihat yang benar-benar memberikan ini adalah accurev - dan bahkan kemudian, sebagian besar pengembang Anda akan menggerutu tentang hal itu karena GUI terlalu membingungkan untuk mereka, dan itu tidak berperilaku seperti subversi ...