Apakah ini praktik yang baik untuk menggunakan cabang untuk mempertahankan edisi berbeda dari perangkat lunak yang sama?

Kami memiliki produk yang memiliki beberapa edisi berbeda. Perbedaannya kecil: string yang berbeda di sana-sini, sedikit sekali logika tambahan di satu, sangat sedikit perbedaan dalam logika di yang lain. Ketika perangkat lunak sedang dikembangkan, sebagian besar perubahan perlu ditambahkan ke setiap edisi; Namun, ada beberapa yang tidak dan beberapa yang perlu berbeda. Apakah ini penggunaan cabang yang valid jika saya memiliki cabang release-editionA dan release-editionB (..etc)? Apakah ada gotcha? Latihan yang baik?

Pembaruan: Terima kasih atas wawasan semua orang, banyak jawaban bagus di sini. Konsensus umum tampaknya adalah ide yang buruk untuk menggunakan cabang untuk tujuan ini. Bagi siapa pun yang bertanya-tanya, solusi terakhir saya untuk masalah ini adalah mengeksternalisasi string sebagai konfigurasi, dan mengeksternalkan logika yang berbeda sebagai plugin atau skrip.

Ini tergantung pada besarnya perubahan, tetapi saya tidak akan menganggapnya sebagai praktik yang baik untuk perbedaan yang Anda jelaskan.

Secara umum, Anda ingin cabang Git menjadi sesuatu yang akan digabungkan di masa depan atau disimpan hanya untuk referensi. Cabang-cabang Git yang hidup berdampingan tanpa batas berarti bekerja untuk semua orang: Perubahan perlu disebarkan dan digabungkan, konflik diselesaikan, semua kesenangan. Jika tidak ada yang lain, setiap pengembang harus ingat untuk mendorong perubahan ke lima repositori, bukan satu.

Jika Anda memiliki perubahan kecil, seluruh upaya penggabungan dan pemeliharaan cabang tampaknya berlebihan jika dibandingkan dengan masalahnya. Gunakan preprocessor Anda atau bangun sistem untuk membedakan antar versi. Apakah yang sederhana #ifdefberhasil? Maka jangan memecahkan masalah dengan git, itu berlebihan.

Bukan untuk apa cabang itu sebenarnya. Cabang seharusnya pendek untuk jalur samping jangka menengah ke garis pengembangan Anda, bukan versi paralel jangka panjang dari kode yang sama.

Saya akan meletakkan semua versi yang berbeda ke cabang yang sama, dengan subdirektori untuk bagian-bagian yang berbeda di antara edisi, dan mengatur proses pembuatan Anda (Anda memiliki bangunan otomatis, bukan?) Sehingga dapat menghasilkan edisi mana pun sesuai permintaan (atau semuanya sekaligus).

Lagi pula, Anda ingin menyimpan "satu sumber kebenaran"; dengan cabang, Anda akan menduplikasi beberapa kode, tetapi tidak semua, dan penggabungan tertentu pada kenyataannya akan merusak pengaturan Anda.

Salah satu solusi - seperti yang ditunjukkan orang - adalah mengonfigurasi sistem build untuk mendukung edisi yang berbeda.

Saya juga akan mempertimbangkan mengimplementasikannya sebagai fitur toggle dan menggunakan file konfigurasi. Semakin sedikit Anda harus membangun, semakin baik.

Lihatlah situs ini.

Saya akan berpikir itu ide bagus asalkan Anda tidak dapat melakukannya dalam satu cabang tanpa mengelompokkan kode menjadi banyak.
Saya lebih suka untuk dapat menyimpannya dalam satu cabang dan menggunakan file lokal dan konfigurasi, terutama jika Anda mengatakan perbedaannya kecil.
Cara lain dapat berupa build yang berbeda, misalnya file build Anda mengemas file yang berbeda untuk pelanggan yang berbeda, tetapi saya juga dapat melihat alat build memeriksa cabang yang berbeda. Ketika Anda menggunakan git, saya akan mengatakan tidak ada gotcha nyata. Salah satu strategi percabangan dapat dikembangkan pada cabang yang berbeda untuk tugas yang berbeda, check in ke cabang master dan bergabung dari master ke edisiX dan Y.

Ini terdengar seperti pekerjaan untuk konfigurasi bangunan yang berbeda. jawaban thiton menuju ke arah ini tetapi saya akan mengambilnya lebih jauh dari #ifdef:

Gunakan target pembuatan yang berbeda untuk membuat edisi perangkat lunak yang berbeda. Target dapat berbeda menurut

• konfigurasi yang mereka sertakan,
• objek atau file sumber yang mereka sertakan, atau
• preprocessing dari kode sumber.

Preprocessing ini jelas dapat mencakup preprocessor C klasik tetapi bisa juga memerlukan menggunakan preprocessor kustom, mesin template untuk membangun tampilan kustom, ...

Dengan cara ini, Anda menghindari keharusan untuk secara aktif mendorong setiap perubahan tunggal ke beberapa cabang, yang melanggar KERING (tentu saja itu juga bisa otomatis tetapi saya tidak melihat keuntungannya).

Saya akan menggunakan cabang hanya untuk perubahan signifikan, jika tidak Anda akhirnya menambahkan setiap perubahan kecil ke banyak cabang, yang sama sekali tidak menyenangkan untuk dilakukan dan sangat rawan kesalahan, terutama jika Anda bekerja dengan lebih banyak orang.

Jika Anda melepaskan semuanya sebagai produk yang berbeda maka disarankan untuk memiliki banyak cabang. Jika tidak, maka masih disarankan untuk menggunakan sesuatu seperti batang atau cabang master.

Juga, saya pikir ini akan tergantung pada proses pengembangan yang Anda miliki, khususnya penyebaran. Jika Anda memiliki proses yang hanya mengizinkan satu cabang untuk diluncurkan ke produksi dan cabang diperlakukan sebagai "membangun bertahap" yang berarti rilis B tidak dapat diluncurkan ke produksi kecuali jika rilis A diluncurkan terlebih dahulu, mengingat bahwa semua perubahan dari A sudah ada di B, lalu memiliki banyak cabang adalah cara yang harus ditempuh. Ini akan berfungsi jika Anda memiliki tim yang tersebar di seluruh dunia dan Anda biasanya memiliki perubahan yang dipesan berdasarkan prioritas.

Solusi dengan tiga cabang berbeda (untuk produksi, pengembangan, dan fitur) bekerja dengan sangat baik. Katakanlah Anda menemukan beberapa bug dalam kode produksi Anda maka Anda dapat menerapkan tambalan untuk itu lalu melepaskannya. Pastikan Anda tidak melakukan penambahan fitur apa pun ke cabang produksi atau perubahan besar pada cabang produksi. Anda dan tim Anda harus disiplin diri untuk tidak menambahkan perubahan fitur utama ke cabang produksi Anda. Cabang produksi seharusnya hanya untuk perbaikan bug kecil yang tidak menjamin perubahan besar dalam basis kode produksi Anda.