Apa cara terbaik untuk menangani versi produk dan percabangan proyek jangka panjang?

Dalam arti umum, untuk proyek jangka panjang yang mungkin memiliki beberapa rilis selama siklus hidup produk dan membutuhkan dukungan produk sebelumnya, apa cara terbaik untuk menangani versi produk dan percabangan basis kode?

Dalam arti yang lebih spesifik, asumsikan bahwa kontrol versi terdistribusi yang tepat sudah ada (yaitu git) dan bahwa tim berukuran kecil hingga besar dan pengembang dapat mengerjakan beberapa proyek sekaligus. Masalah utama yang sedang dihadapi adalah bahwa ada kewajiban kontrak untuk mendukung versi lama seperti yang ada pada saat itu yang berarti bahwa pengembangan baru tidak dapat menambal kode lama (produk Microsoft Office bisa menjadi contoh dari ini, Anda hanya mendapatkan tambalan untuk tahun fitur yang Anda miliki).

Akibatnya, versi produk saat ini adalah sentuhan yang berbelit-belit karena setiap produk utama memiliki banyak ketergantungan, masing-masing dengan versi mereka sendiri yang dapat berubah di antara rilis tahunan. Demikian juga, sementara setiap produk memiliki repositori sendiri, sebagian besar pekerjaan tidak dilakukan pada batang sumber utama melainkan pada cabang untuk tahun itu rilis produk dengan cabang baru yang dibuat ketika produk dilepaskan sehingga produk tersebut dapat didukung. Ini pada gilirannya berarti bahwa mendapatkan basis kode produk bukanlah hal yang mudah seperti yang mungkin dipikirkan orang ketika menggunakan kontrol versi.

Seberapa banyak (dan apa jenis) struktur yang Anda butuhkan sangat tergantung pada apa yang ingin Anda lakukan. Cari tahu apa yang Anda tidak bisa hidup tanpanya, apa yang ingin Anda miliki, dan apa yang tidak Anda pedulikan.

Contoh keputusan yang bagus mungkin:

Hal-hal yang kita tidak bisa hidup tanpanya:

• dapat merekonstruksi rilis masa lalu kapan saja
• dapat mempertahankan beberapa versi utama produk yang didukung kapan saja

Hal-hal yang ingin kami miliki:

• dapat melakukan pengembangan fitur utama yang sedang berlangsung (untuk rilis besar berikutnya) tanpa khawatir tentang penggabungan cabang
• dapat melakukan pembaruan pemeliharaan untuk rilis sebelumnya

Kita bisa hidup tanpa:

• backporting otomatis dari perubahan dari pekerjaan saat ini ke rilis sebelumnya
• jangan pernah mengganggu pengembangan fitur utama bahkan selama beberapa hari atau seminggu pada saat bersamaan

Jika tujuan di atas adalah tujuan Anda, Anda dapat mengadopsi proses seperti ini:

1. Lakukan semua pengembangan pada bagasi VCS Anda ("master" di git)
2. Ketika Anda dekat dengan rilis utama, hentikan pengembangan fitur utama, dan fokus pada stabilitas sistem selama satu minggu atau lebih
3. Ketika bagasi tampaknya stabil, buat cabang untuk rilis utama ini
4. Pengembangan fitur utama sekarang dapat melanjutkan di trunk, sementara hanya perbaikan bug dan persiapan rilis diizinkan di cabang
5. Namun, semua perbaikan bug yang dilakukan ke cabang harus terlebih dahulu diuji di bagasi; ini memastikan bahwa mereka juga akan hadir di semua rilis mendatang
6. Buat tag (VCS) pada cabang saat Anda siap untuk melepaskan; tag ini dapat digunakan untuk membuat ulang rilis kapan saja, bahkan setelah bekerja lebih lanjut di cabang yang sama
7. Rilis pemeliharaan lebih lanjut untuk rilis utama ini (rilis minor) sekarang dapat disiapkan di cabang; masing-masing akan ditandai sebelum dirilis
8. Sementara itu, pengembangan fitur utama yang diarahkan pada rilis besar berikutnya dapat dilanjutkan di bagasi
9. Ketika Anda mendekati rilis itu, ulangi langkah-langkah di atas, buat cabang rilis baru untuk rilis itu . Ini memungkinkan Anda untuk memiliki beberapa rilis utama, masing-masing di cabang mereka sendiri, dalam status yang didukung pada saat yang sama, dengan kemampuan untuk merilis rilis kecil terpisah terhadap masing-masing.

Proses ini tidak akan menjawab semua pertanyaan Anda - khususnya, Anda akan memerlukan proses untuk memutuskan perbaikan apa yang dapat dilakukan untuk cabang rilis, dan untuk memastikan bahwa bug tidak diperbaiki pada cabang rilis terlebih dahulu (perbaikan seperti itu harus selalu diuji di bagasi jika memungkinkan). Tapi itu akan memberi Anda kerangka kerja untuk membuat keputusan seperti itu.

"Jangka panjang" adalah indikator yang Anda perlukan untuk versi, tetapi itu tidak melibatkan strategi versi dan cabang yang spesifik. Pertanyaan yang lebih menarik adalah berapa banyak lini produk atau lini versi utama yang ingin Anda dukung (yang tergantung pada kontrak dengan pelanggan Anda). Anda setidaknya membutuhkan satu cabang untuk setiap lini produk / lini versi utama yang Anda miliki kontrak perawatannya.

Di sisi lain, itu tergantung pada ukuran tim Anda. Jika Anda memiliki tim pengembangan besar, dengan orang yang berbeda bekerja pada fitur yang berbeda secara paralel, Anda jelas akan membutuhkan lebih banyak cabang fitur daripada jika Anda memiliki tim yang terdiri dari satu atau dua orang. Jika Anda bekerja dengan tim yang lebih besar, Anda harus mempertimbangkan untuk menggunakan kontrol versi terdistribusi, yang membuat paralel bekerja pada cabang yang berbeda (dan mengintegrasikannya nanti ke dalam bagasi) jauh lebih efisien.

Git adalah alat kontrol versi - ia mengelola versi file. Apa yang Anda kejar adalah alat manajemen konfigurasi. Ada beberapa avalible ini, tetapi sebagian besar pada $$$ tinggi dari orang-orang seperti IBM.

Alat kontrol versi menyediakan percabangan dan penandaan, yang memungkinkan manajemen konfigurasi rudementy tanpa dukungan alat tambahan, karenanya pengembang menay tidak memahami perbedaannya. Kebutuhan Anda mungkin melampaui apa yang dirancang untuk dilakukan GIT.

Saya tidak tahu, tapi saya yakin itu akan ada, tambahan alat CM untuk Git.

Pertanyaan ini tampaknya sangat mirip dengan pertanyaan lain yang saya jawab baru-baru ini.

Singkatnya, ini lebih mirip masalah desain produk dan distribusi lebih dari masalah kontrol versi / percabangan. Tentu saja, mudah bagi saya untuk mengatakan itu dan lebih sulit bagi Anda untuk memperbaikinya jika Anda sudah berada jauh di dalam masalah.

Tanpa mengetahui secara lebih rinci masalah spesifik Anda. Namun secara umum, jika saya memiliki beberapa versi produk berdasarkan pada basis kode yang memiliki banyak kode bersama antara produk, jika layak saya akan melihat untuk refactoring produk dengan cara yang akan membuat mereka lebih modular, dan untuk memastikan bahwa modul itu sendiri tidak memerlukan percabangan kode tambahan. Saya juga akan melihat model penempatan saya, untuk melihat apakah ada cara yang lebih baik untuk mendukung pelanggan saya sambil tetap mempertahankan banyak basis kode. Jika diperlukan kustomisasi pelanggan khusus, granularitas modul yang lebih besar mungkin diperlukan untuk mengurangi jumlah kode duplikat dalam sistem.

Ini bukan tugas yang mudah, tetapi dapat diperbaiki secara bertahap jika Anda mengelola pekerjaan dengan baik, dan jika Anda dapat menjadwalkan pekerjaan sehingga Anda tidak perlu "meningkatkan" semuanya sekaligus.