Strategi untuk menggabungkan 1 tahun pengembangan di Visual Studio

Saya punya klien yang bersikeras agar kami memisahkan pengembangan baru dari cabang utama sepanjang 2016. Mereka memiliki 3-4 tim lain yang mengerjakan aplikasi dalam berbagai kapasitas. Banyak perubahan besar telah dibuat (mengubah cara injeksi ketergantungan dilakukan, membersihkan kode dengan ReSharper, dll). Sekarang telah jatuh pada saya untuk menggabungkan utama ke cabang dev baru kami untuk bersiap mendorong perubahan kami ke atas rantai.

Pada penggabungan awal saya, TFS melaporkan ~ 6500 file dengan resolusi konflik. Beberapa di antaranya akan mudah, tetapi beberapa di antaranya akan jauh lebih sulit (khususnya beberapa javascript, pengontrol api, dan layanan yang mendukung pengontrol ini).

Apakah ada pendekatan yang bisa saya ambil yang akan membuat ini lebih mudah bagi saya?

Untuk memperjelas, saya menyatakan banyak keprihatinan dengan pendekatan ini beberapa kali di sepanjang jalan. Klien sudah dan menyadari kesulitan dengan ini. Karena mereka memilih untuk kekurangan staf QA (1 tester untuk 4 devs, tidak ada pengujian otomatis, pengujian regresi kecil), mereka bersikeras bahwa kami menjaga cabang kami diisolasi dari perubahan di cabang utama dengan alasan bahwa ini akan mengurangi kebutuhan untuk kami tester untuk mengetahui tentang perubahan yang dilakukan di tempat lain.

Salah satu masalah yang lebih besar di sini adalah peningkatan ke versi sudut dan beberapa perangkat lunak pihak ketiga lainnya - sayangnya kita belum menemukan cara yang baik untuk membangun solusi ini sampai semua bagian dimasukkan kembali ke tempatnya.

Akan ada cara sederhana yang telah membuat pengembangan baru Anda terpisah dari cabang utama tanpa membawa Anda ke dalam situasi yang tidak menguntungkan ini: setiap perubahan dari bagasi harus digabung ke cabang dev Anda setiap hari . (Apakah klien Anda benar-benar picik sehingga ia tidak bisa mengantisipasi bahwa kantor cabang Anda perlu dipasang kembali ke jalur utama suatu hari nanti?)

Bagaimanapun, pendekatan terbaik adalah IMHO yang mencoba mengulang apa yang seharusnya terjadi di tangan pertama:

• mengidentifikasi semantik dari perubahan pada jalur utama untuk hari 1 setelah cabang dibuat. Menerapkannya ke basis kode Anda saat ini sebaik mungkin. Jika itu adalah "perubahan lokal", itu harus sederhana, jika itu adalah "cross cutting refactoring" seperti mengubah nama kelas yang banyak digunakan, menerapkannya secara semantik setara dengan basis kode Anda saat ini. Mudah-mudahan selama tahun itu tidak ada perubahan lintas-basis yang kontradiktif dalam basis kode yang dibuat pada cabang "Anda", jika tidak, ini bisa menjadi penggila otak yang nyata
• uji hasilnya (apakah saya menyebutkan Anda membutuhkan test suite yang baik untuk tugas ini)? Perbaiki semua bug yang diungkapkan oleh tes
• sekarang ulangi proses ini untuk perubahan pada jalur utama untuk hari 2, lalu hari 3, dan seterusnya.

Ini mungkin bekerja ketika tim secara ketat mematuhi aturan klasik kontrol versi ("hanya melakukan kondisi yang dapat dikompilasi, diuji" dan "check in lebih awal dan sering").

Setelah 365 pengulangan (atau 250, jika Anda beruntung dan Anda dapat menggabungkan pekerjaan untuk perubahan akhir pekan), Anda akan hampir selesai (hampir, karena Anda perlu menambahkan jumlah perubahan yang akan terjadi pada jalur utama selama periode integrasi ). Langkah terakhir adalah menggabungkan cabang dev yang diperbarui ke dalam trunk lagi (jadi Anda tidak kehilangan sejarah trunk). Ini harus mudah, karena secara teknis itu hanya penggantian file yang terpengaruh.

Dan ya, saya serius, mungkin tidak ada jalan pintas untuk ini. Mungkin ternyata "porsi harian" mungkin kadang-kadang terlalu kecil, tapi saya tidak berharap ini, saya kira itu kemungkinan porsi harian bisa berubah menjadi terlalu besar. Saya harap klien Anda membayar Anda dengan sangat baik untuk ini, dan bahwa ini sangat mahal baginya sehingga ia akan belajar dari kegagalannya.

Saya harus menambahkan bahwa Anda dapat mencoba ini juga dengan sisi yang diaktifkan - mengintegrasikan kembali perubahan dari cabang Anda dalam porsi kecil ke jalur utama. Ini mungkin lebih sederhana ketika di cabang dev Anda ada perubahan jauh lebih sedikit daripada di bagasi, atau sebagian besar perubahan terjadi pada file sumber baru yang saat ini bukan bagian dari bagasi. Orang dapat melihat ini sebagai "porting" suatu fitur dari produk A (cabang dev) ke produk B yang agak berbeda (kondisi batang saat ini). Tetapi jika sebagian besar refactor lintas sektoral dilakukan pada jalur utama, dan itu mempengaruhi kode baru Anda (6500 gabungan tabrakan tampaknya menjadi beberapa bukti untuk ini), mungkin lebih mudah dengan cara saya menggambarkannya terlebih dahulu.

Pada tahap penggabungan, saya akan mengatakan bahwa penggabungan otomatis hanya dapat memperumit proses. Saya memiliki masalah serupa dengan cabang yang telah menyimpang selama lebih dari setahun dan metode paling efektif yang saya miliki adalah dengan melakukan hal berikut:

• Ambil satu salinan dari kondisi tanpa pencemaran asli
• Perbedaan antara yang tidak digarap dan yang terbaru
• Hancurkan setiap elemen umum
  • Misalnya, lakukan semua perubahan nama fungsi, lalu perubahan parameter, dll.
  • Abaikan ruang putih pada diff jika standar telah berubah, jika tidak, Anda akan membuang banyak waktu untuk menghitung ruang
• Fokus pada fungsionalitas inti terlebih dahulu

Akhirnya kompiler peringatan dan diff akan menjadi teman terbaik Anda, tetap menggunakan diff unmerged untuk melihat apa yang berbeda dan terus berjalan. Mungkin ada berbagai alat yang dapat Anda gunakan untuk membantu, tetapi terserah Anda untuk menemukan mana yang terbaik.

Kuncinya adalah terus berjalan.

Edit:

Sebagai peringatan, pendekatan ini akan berarti bahwa sejarah kontrol versi akan menjadi 'rusak', karena Anda akan kehilangan bukti penggabungan cabang-ke-cabang, serta sejarah cabang yang tidak digeser.

Terima kasih atas komentar dari 'Jack Aidley' dan '17 of 26 '

Beberapa tahun yang lalu kami memiliki klien dengan persyaratan yang sama untuk memisahkan cabang. Jadi kami melakukannya.

Kami tidak pernah menggabungkan cabang mereka kembali. Mereka punya versi unik di sana. Kami menagih mereka ekstra untuk perubahan karena pada dasarnya kami memiliki dua batang utama bukan 1 batang utama dan cabang.

Kami berusaha untuk bergabung kembali ke bagasi, tetapi setelah 2 minggu kami memutuskan untuk meninggalkan upaya itu karena itu menghabiskan waktu berjam-jam tanpa manfaat nyata.

Jadi, jangan gabungkan kembali. Ke depannya, gabungkan perbaikan-perbaikan penting ke cabang klien sebagaimana diperlukan dan peningkatan apa pun akan menjadi salah satu diskon yang secara khusus dibebankan kepada klien itu.

Ini tidak akan menyenangkan, tetapi seberapa menyakitkan itu akan tergantung pada sifat perubahan, dan seberapa terisolasi mereka.

Saya sarankan Anda mencoba untuk menyatukan cabang-cabang melalui refactoring sebanyak mungkin sebelum Anda melakukan penggabungan yang sebenarnya.

Alat penggabungan agak bodoh karena hanya melihat perbedaan tekstual dan tidak mengerti kode dengan cara apa pun. Jika cabang utama telah mengubah nama kelas yang digunakan di seluruh aplikasi, dan cabang fitur menggunakan nama lama dalam beberapa kode baru, maka alat gabungan tidak akan mengerti bahwa nama kelas juga harus diubah dalam kode baru. Tetapi jika Anda melakukan refactoring di cabang B untuk mengubah nama kelas seperti di cabang A itu akan bekerja di kedua kode lama dan baru dan penggabungan akan berjalan dengan lancar.

Kedua, Anda harus memeriksa seberapa lokal perubahan di cabang pengembangan. Jika perubahan dalam cabang fitur dilokalkan ke beberapa area, Anda tidak harus menyatukan kode yang tidak terpengaruh, Anda bisa menyalin dan menimpa dari cabang utama.

Di area kode di mana ada perubahan non-sepele pada kedua cabang, Anda harus hati-hati memeriksa kode dan memutuskan bagaimana menulis ulang.