Berurusan dengan permintaan tarik besar

Saat ini saya sedang mengerjakan proyek dengan tim yang menggunakan alur kerja git. Ini cukup sederhana, master harus dalam status dapat digunakan dan cabang digunakan untuk membuat fitur dan perbaikan terbaru. Setiap kali kami memiliki fitur atau perbaikan bug yang diselesaikan dan diuji, maka kami memindahkannya ke master sesegera mungkin. Idenya adalah bahwa cabang harus sekecil mungkin untuk membuatnya lebih mudah untuk menggabungkannya kembali menjadi master. Kami memiliki kebijakan bahwa kode apa pun yang didorong ke cabang utama harus dalam status yang dapat digunakan dan lulus tes.

Kami mendapat situasi di mana salah satu pengembang telah melakukan banyak pekerjaan (senilai beberapa bulan) pada satu cabang dan cabang ini belum digabungkan kembali ke master. Sekarang ada beberapa fitur terpisah dan banyak komitmen di cabang ini, pada dasarnya cabang ini benar-benar harus digabungkan kembali dalam beberapa kali, tetapi sejauh ini belum. Sebagian besar kode berada dalam kondisi baik dengan unit test yang dapat digabungkan kembali ke master tetapi perubahan terbaru tentu saja tidak karena tidak selesai dan tidak diuji.

Apa cara terbaik untuk menghadapi situasi seperti itu di mana satu cabang benar-benar jauh dari yang lain? Cara apa yang bisa kita hindari cabang mendapatkan komitmen yang sangat besar dari tuan di masa depan?

Biarkan pengembang yang melakukannya selama beberapa bulan tanpa bergabung memperbaikinya. Mungkin mereka bisa mendapatkan satu potongan besar kode untuk digabungkan, mungkin mereka bisa mendapatkan banyak potongan kecil untuk digabung satu per satu. Bagaimanapun, mereka harus melakukan kerja keras untuk memperbaiki masalah, karena mereka yang menyebabkannya.

Apa cara terbaik untuk menghadapi situasi seperti itu di mana satu cabang benar-benar jauh dari yang lain?

Secara umum, jangan khawatir tentang hal itu: itu masalah pengembang lain. Jika dua cabang benar benar terpisah terlalu jauh untuk digabungkan, maka mereka tidak benar-benar menjadi bagian dari proyek yang sama lagi dan Anda memiliki garpu defacto. Jika ini adalah proyek open source, itu mungkin tidak menjadi masalah.

Jika pengembang ini benar-benar brilian, dan kode mereka lebih baik / lebih pintar / lebih penting daripada gabungan tim lainnya, maka ada baiknya menjadikannya masalah Anda alih-alih milik mereka. Kalau tidak, tidak.

Untuk menjawab pertanyaan literal: yang terbaik cara untuk menghadapi situasi semacam ini adalah dengan tidak masuk dalam situasi seperti itu.

Cara apa yang bisa kita hindari cabang mendapatkan komitmen yang sangat besar dari tuan di masa depan?

Pastikan semua orang memperhatikan bahwa pengembang yang berbulan-bulan tanpa penggabungan harus memperbaiki masalah yang disebabkannya. Pastikan semua orang tahu bahwa lebih mudah untuk berkomitmen untuk menguasainya sering daripada jarang, karena perubahan yang lebih sedikit berarti lebih sedikit peluang untuk konflik.

Pastikan bahwa orang tahu bahwa mereka dapat menarik dari master untuk tetap mengikuti perkembangan orang lain.

"Jika kamu bergabung setiap hari, tiba-tiba kamu tidak pernah sampai pada titik di mana kamu memiliki konflik besar yang sulit untuk diselesaikan." --Linus Torvalds

Kutipan itu dari ceramah yang dia berikan di Google, ini transkripnya , dan inilah videonya .

Jika Anda memiliki komit yang Anda ketahui ini dan semua komit sebelumnya diuji dengan baik dan harus digabungkan, maka cukup cabut dari komit baik terakhir ini dan gabungkan cabang baru dengan master.

Jika Anda memiliki beberapa komit yang ingin Anda gabungkan, tetapi mereka diselingi dengan komit lain yang tidak siap produksi, maka saya melihat 2 kemungkinan:

1. Buat cabang baru, dan ceri pilih komitmen yang baik, bergabung dengan master.
2. Cobalah untuk mengubah komitmen yang tidak diinginkan ke atas (mungkin di cabang baru hanya untuk aman).

Adapun metode pencegahan, cobalah untuk mendefinisikan beberapa aturan tim lucu seperti "Yang tidak bergabung dengan master dalam waktu seminggu akan memesan pizza selama sebulan".

Pertama, lihat apakah benar-benar ada komit terpisah yang dapat digabung atau dipilih-ceri, seperti yang disarankan oleh @Maciej Chalpuk. Jika ini masalahnya, maka situasinya benar-benar tidak terlalu buruk, dan saya tidak akan terlalu khawatir tentang itu di masa depan.

Namun, jika situasi sebenarnya adalah bahwa banyak fitur telah dikembangkan secara bersamaan dalam satu cabang, dalam komitmen yang sama, maka itu akan menjadi rasa sakit yang jauh lebih besar untuk dihadapi. Untungnya, metode pencegahan sudah ada di dalamnya: mengharuskan pengembang untuk memisahkan perubahan untuk setiap fitur menjadi cabang terpisah dan menarik permintaan sebelum menggabungkannya. Anda berdua akan mendapatkan gabungan atom Anda, serta mencegah pengembang ini untuk melakukannya di masa depan.

Proses sebenarnya untuk memisahkan fitur sepenuhnya manual. Buat cabang baru dari master, dan salin perubahan apa pun dari cabang mega yang terkait dengannya. Kompilasi, uji fitur, tekan dan buat permintaan tarik. Semakin sedikit perubahan antar kode, semakin mudah untuk melakukannya. Jika dia meretas satu metode untuk mereka semua, bersenang-senanglah. Dia tidak akan melakukannya lagi.

Ini solusi sederhana.

Lacak fitur yang telah diterapkan orang ini dan masuk ke setiap komit di cabang itu yang diperbarui per fitur. Ambil komit ini dan gabungkan dengan master repo.

Biarkan saya memecah ini dalam bentuk contoh.

Biarkan: Cabang A menjadi cabang dari master Cabang A + = Cabang A + fitur baru 1 Cabang A ++ = Cabang A + fitur baru 2 dan seterusnya dan seterusnya

Yang perlu Anda lakukan adalah kembali ke: Cabang A +

Ambil Cabang A + dan gabungkan dengan Master.

Sekarang pergi ke Cabang A ++ dan menggabungkannya dengan (Master + Cabang A +).

Ulangi sampai Anda mencapai Cabang akhir A + ... + yang stabil.

Metode ini mungkin terdengar kontra-intuitif pada awalnya, tetapi jika Anda menggabungkan masing-masing fitur baru yang terpisah dengan master, menjadi mudah untuk siklus antara cabang master " per fitur tambahan "

Cara apa yang bisa kita hindari cabang mendapatkan komitmen yang sangat besar dari tuan di masa depan?

Saya pikir solusi saya di atas menunjukkan metode masa depan apa yang harus Anda adopsi. Pergi dengan fitur per atau metode tugas untuk setiap cabang.

Saya akan menyarankan menggunakan pendekatan:

pra-master dan master

master: Final / tingkat produksi. Dimodifikasi tidak sering. Dianggap selalu stabil

pre-master: area di mana fitur baru ditambahkan ke kode yang ada. Diuji secara menyeluruh untuk bekerja dengan basis kode yang ada, dan merupakan tempat di mana cabang lain dapat melakukan fork untuk implementasi fitur baru.

Anda juga harus mencoba fitur bundling dan bertujuan untuk penargetan versi.

Penargetan versi: Tentukan nomor sewenang-wenang yang akan bertindak sebagai pengganti untuk cabang utama. "Dalam V1.0.0, kami ingin mencapai fitur X, Y, Z. V1.0.0 juga akan memiliki semua fungsi yang tersedia: ..."

Dengan mempertahankan versi terhadap master, ini juga bisa menjadi cara untuk menjaga "master" stabil dan siap produksi setiap saat.

Memperbaiki masalah permintaan tarik besar adalah satu hal, dan ada beberapa jawaban yang bagus mengenai hal itu. Tetapi untuk berurusan dengan cabang yang sudah ketinggalan zaman, Anda mungkin ingin meninjau kembali proses Anda untuk berurusan dengan kerja tim.

Jika Anda bekerja dalam kerangka Agile atau SCRUM, tim harus benar-benar bertanya mengapa fitur tersebut tidak selesai dan digabung sebagai bagian dari iterasi / sprint. Jika "terlalu besar" untuk dimasukkan ke dalam iterasi, itu harus dipecah menjadi potongan-potongan kecil.

Ini juga menimbulkan pertanyaan tentang kepemilikan kode - di dalam tim Anda, apakah pengembang individu memiliki pekerjaan mereka sendiri secara terpisah, atau apakah tim penuh bekerja sama untuk memastikan bahwa barang telah dikerjakan?

Tentu saja, di atas mengasumsikan bahwa tim Anda berada dalam semacam struktur perusahaan. Jika ini adalah proyek open-source dengan kontributor sukarela, itu cerita lain. Secara umum, proyek semacam itu memiliki kontrol yang lebih longgar terhadap alur kerja, tetapi tanggung jawab untuk menghasilkan permintaan tarikan yang dapat diterima lebih sering jatuh pada masing-masing kontributor.

Dalam banyak hal ini menjadi pertanyaan proses. Mungkin proses yang Anda butuhkan termasuk memeriksa secara berkala (mingguan? Bulanan?) Untuk cabang lama yang tidak terputus. Beberapa alat membuat ini mudah untuk diperiksa secara visual; misalnya pada github kunjungi tautan "cabang" dan itu menunjukkan seberapa jauh di depan / di belakang setiap cabang.