Dalam kontrol versi terpusat, apakah selalu baik untuk memperbarui sering?

Berasumsi bahwa:

• Tim Anda menggunakan kontrol versi terpusat.
• Anda sedang mengerjakan fitur yang lebih besar yang akan selesai beberapa hari, dan Anda tidak akan bisa melakukan sebelum itu karena itu akan merusak build.
• Anggota tim Anda melakukan sesuatu setiap hari yang dapat mengubah beberapa file yang sedang Anda kerjakan.

Karena ini adalah kontrol versi terpusat, Anda harus memperbarui checkout lokal di beberapa titik: setidaknya satu kali tepat sebelum melakukan fitur baru.

Jika Anda memperbarui hanya sekali sebelum komit Anda, maka mungkin ada banyak konflik karena banyak perubahan lainnya oleh rekan setim Anda, yang bisa menjadi dunia kesedihan untuk diselesaikan sekaligus.

Atau, Anda dapat memperbarui sering, dan bahkan jika ada beberapa konflik untuk diselesaikan hari demi hari, itu harus lebih mudah dilakukan, sedikit demi sedikit.

Akankah Anda tinggal itu selalu merupakan ide yang baik untuk memperbarui sering?

Secara pribadi, saya memperbarui versi lokal saya setiap hari.

Dalam skenario yang Anda jelaskan, saya akan berusaha lebih keras

• Membuat cabang untuk fitur baru yang panjang.
• Sering bergabung dari jalur utama ke cabang baru ini.

Cara ini,

• Anda dapat check-in setiap hari untuk menjaga kode Anda di server
• Anda tidak perlu khawatir tentang memecah bangunan dengan check-in.
• Anda dapat menggunakan repositori untuk membatalkan beberapa pekerjaan atau perbedaan bila perlu dengan check-in sebelumnya.
• Anda yakin akan mengerjakan basis kode terbaru dan mendeteksi kemungkinan perubahan kode yang bertentangan sejak awal.

Kelemahan seperti yang saya lihat adalah

• Penggabungan dari main harus dilakukan secara manual (atau dituliskan)
• Dibutuhkan lebih banyak "administrasi"

Ya, itu ide yang baik untuk memperbarui sering. Anda memperbarui sering untuk menghindari konflik penggabungan yang sulit dan ini adalah dasar-dasar pengetahuan Manajemen Konfigurasi Perangkat Lunak (SCM) dengan masalah perubahan yang berbeda.

Ini terlepas dari apakah itu terpusat atau didistribusikan; semakin lama Anda menyimpang dari sumber upstream (artinya jika itu adalah trunk, cabang, atau repositori lain dalam kasus DVCS), semakin tinggi kemungkinan untuk menggabungkan konflik. Ya, kejutan tidak menyenangkan dari tim Anda mungkin muncul saat memperbarui, tetapi menunda kejutan jahat itu bahkan lebih mengkhawatirkan (semakin lama Anda menunggu, semakin sedikit orang yang mengingat mengapa serangkaian perubahan dilakukan).

Untuk memperbarui agar berfungsi, ini juga berarti bahwa Anda dan programmer lain yang mengerjakan kode tidak boleh dengan sengaja melakukan atau mendorong kode hulu yang merusak build . Inilah sebabnya mengapa programer bercabang (atau menyimpang dari hulu dalam istilah SCM), untuk melindungi anggota tim Anda dan pemangku kepentingan lainnya dari memiliki kode yang rusak jika situasi seperti itu mau tidak mau harus muncul.

Mantra yang dapat Anda gunakan untuk diingat adalah ini: "perbarui, perbarui, perbarui, komit". Selalu pastikan perubahan Anda bekerja dengan orang lain sebelum melakukan. Ini juga untuk memastikan memeriksa kode untuk pertama kalinya juga berfungsi.

Poin ketiga dalam pertanyaan itu benar- benar salah :

• Anda sedang mengerjakan fitur baru yang pasti akan membutuhkan waktu beberapa hari untuk selesai, dan Anda tidak akan dapat melakukan sebelum itu karena itu akan merusak build.

Jika Anda tahu Anda akan mengerjakan sesuatu yang tidak dapat Anda lakukan untuk beberapa waktu, itu adalah contoh buku teks untuk menggunakan cabang.

Jangan menempatkan diri Anda dalam situasi di mana Anda memiliki banyak perubahan yang tertunda. Jika Anda tahu bahwa Anda tidak akan dapat melakukan di cabang utama proyek Anda untuk beberapa waktu, kemudian bekerja di cabang lain. Dan di sana, sering-seringlah berkomitmen .

Jika Anda sudah dalam situasi yang dijelaskan dalam pertanyaan, maka beralihlah ke cabang sekarang , komit perubahan Anda dan terus bekerja di cabang itu.

Biasanya di CVCS adalah ide yang baik untuk memperbarui sering. Tetapi jika Anda bekerja pada cabang maka pertanyaan "perbarui sering atau tidak" menjadi "sering bergabung atau tidak". Dan jawabannya adalah ya. Pastikan untuk melakukan semua perubahan yang tertunda (di cabang) sebelum bergabung dari cabang lain, ke opsi Anda untuk memutar kembali penggabungan dengan aman jika Anda harus.

Saya pikir Anda harus melakukan lebih sering. Jika Anda akan bekerja untuk waktu yang lama seperti beberapa hari, Anda harus melakukan percabangan kode Anda dan bekerja di cabang Anda daripada bekerja langsung di bagasi. Saya tahu itu nyaman untuk mulai bekerja tanpa cabang, tetapi itu tidak benar-benar fleksibel karena Anda tidak dapat memastikan bahwa pembaruan / komit Anda akan merusak kode Anda atau tidak, yang berakhir pada situasi di mana Anda akan menahan pembaruan / komit Anda sampai Anda telah melakukan pekerjaanmu. "Fitur percabangan" lebih baik karena Anda selalu dapat melakukan kode Anda, dan hanya menggabungkan kembali nanti ketika Anda selesai.

Dalam strategi percabangan, pembaruan diganti dengan penggabungan dari trunk. Dari pengalaman saya, Anda tidak perlu sering bergabung dari trunk, karena kode dalam rentang waktu lima hari tidak akan banyak berubah dan lebih mudah untuk menyelesaikan konflik hanya sekali setelah Anda selesai.

Saya sebenarnya merasa lebih nyaman menggunakan kontrol versi terdistribusi secara lokal. Yaitu, saya menggunakan git sebagai klien subversi. Ini memiliki kelebihan yaitu:

• Perubahan lokal disimpan sebelum memperbarui, jadi jika saya membuat kesalahan dalam penggabungan, saya selalu bisa kembali dan melakukannya lagi.
• Saat melakukan perubahan yang lebih besar, saya dapat menyimpan bagian yang selesai. Itu membuatnya lebih mudah untuk meninjau perubahan yang tersisa dalam proses.
• Ketika saya memperbaiki bug selama beberapa pekerjaan yang lebih besar, saya bisa melakukan perbaikan itu saja, sementara melakukan sisanya dan "mengubah" perbaikan untuk subversi sambil menjaga pekerjaan lain dalam proses lokal

Jika Anda menambahkan fitur baru, dapatkah Anda membuat file sumber tunggal baru (dan file header antarmuka eksternal yang cocok)?

Saya khawatir bahwa "fitur baru" memiliki implikasi luas? Orientasi objek mungkin tidak lagi menjadi kata kunci seperti dulu, tetapi ada manfaat dalam paradigma itu.

Dengan begitu Anda bisa membuat kerangka kerja (antarmuka eksternal, ditambah fungsi rintisan) dan komit bahwa maka harus ada efek pihak ketiga minimal, sementara Anda menyelesaikan sisa pengembangan Anda?

Dalam situasi yang Anda jelaskan, saya merasa lebih baik memiliki file sumber yang lebih kecil daripada lebih sedikit, file lebih besar.

Bagaimana perbedaan untuk kontrol versi terpusat daripada kontrol versi terdistribusi?

Dalam kedua kasus Anda harus check-in di tempat yang kontennya akan dipindahkan dibandingkan dengan apa yang Anda mulai. Saya tidak melihat perbedaan dalam frekuensi penggabungan dari repositori pusat ke tempat Anda bekerja (dan cabang proyek Anda adalah tempat kerja Anda).

Saya cenderung untuk penggabungan sering dengan cara (setidaknya sekali sehari, saya juga dapat menggabungkan pada waktu yang tepat bagi saya, atau ketika saya tahu seseorang telah memeriksa sesuatu yang mempengaruhi apa yang saya kerjakan). Jauh lebih mudah untuk menyerap perubahan kecil dan jika Anda memiliki masalah, orang-orang akan lebih membantu ketika Anda bertanya kepada mereka tentang apa yang baru saja mereka periksa daripada tentang apa yang telah mereka periksa satu minggu yang lalu.

BTW, saya tidak tahu apa yang Anda sebut "break the build". Saya cenderung bekerja dalam kenaikan yang relatif kecil, sehingga saya menjaga kondisi yang dapat dikompilasi, bahkan jika itu merusak beberapa fitur. Dan saya menjalankan tes sehingga saya tahu bahwa gabungan tidak merusak sesuatu yang seharusnya berfungsi. Sekali lagi, lebih mudah untuk memperbaiki masalah ketika terdeteksi dini.

Itu tergantung pada seberapa baik Anda berada di "unupdating" ketika orang lain merusak build. Di satu sisi, Anda ingin memperbarui dalam potongan sekecil mungkin. Secara pribadi, saya memperbarui hampir setiap kali saya melihat pembaruan tersedia. Di sisi lain, jika build rusak dan butuh satu hari bagi orang lain untuk memperbaikinya, Anda masih ingin dapat bekerja pada fitur baru Anda dalam waktu yang bersamaan.

Saya telah bekerja dengan sistem kontrol versi yang sangat sulit untuk dicadangkan begitu pembaruan dilakukan. Pada itu, saya cenderung memperbarui tepat sebelum saya perlu check-in. Dengan sistem kontrol versi yang lebih baik, ada sedikit alasan untuk tidak memperbarui beberapa kali per hari.