Apakah DVCSes tidak mendorong integrasi berkelanjutan?

Katakanlah ada tim yang terdiri dari sepuluh pengembang lincah. Setiap hari mereka masing-masing memilih tugas dari dewan, melakukan beberapa perubahan terhadapnya, sampai (pada akhir hari) mereka telah menyelesaikan tugas. Semua pengembang check-in langsung terhadap trunk (gaya Google, setiap komit adalah kandidat rilis, menggunakan fitur toggle dll).

Jika mereka menggunakan CVS terpusat seperti SVN, setiap kali salah satu dari mereka berkomitmen, server build akan mengintegrasikan dan menguji perubahan mereka terhadap pekerjaan sembilan pengembang lainnya. Server build akan berjalan terus menerus sepanjang hari.

Tetapi jika mereka menggunakan DCVS seperti git, pengembang dapat menunggu sampai mereka menyelesaikan tugas sebelum mendorong semua komitmen lokal mereka bersama-sama ke repositori pusat. Perubahan mereka tidak akan diintegrasikan sampai akhir hari.

Dalam skenario ini, tim SVN terus-menerus berintegrasi lebih sering, dan menemukan masalah integrasi jauh lebih cepat daripada tim git.

Apakah ini berarti DVCS kurang cocok untuk tim kontinu daripada alat terpusat yang lebih tua? Bagaimana kalian bisa mengatasi masalah ini?

Penafian: Saya bekerja untuk Atlassian

DVCS tidak mencegah Integrasi Berkelanjutan selama pengembang mendorong dari jarak jauh secara teratur ke cabang mereka sendiri dan server CI diatur sehingga membangun cabang-cabang aktif yang dikenal.

Secara tradisional ada dua masalah dengan DVCS dan CI:

• Ketidakpastian status integrasi - kecuali pengembang telah bergabung secara teratur dari master dan menjalankan build, Anda tidak tahu apa kondisi dari perubahan gabungan itu. Jika pengembang harus melakukan ini secara manual, kemungkinan itu tidak akan cukup sering dilakukan untuk mengambil masalah cukup awal.
• Duplikasi dan drift konfigurasi build - jika konfigurasi build harus disalin dari build 'master' untuk membuat build cabang, konfigurasi untuk cabang dapat dengan cepat menjadi tidak sinkron dengan build yang disalin darinya.

Di Bamboo, kami memperkenalkan kemampuan server build untuk mendeteksi cabang baru karena dibuat oleh pengembang dan secara otomatis membuat setup untuk cabang berdasarkan dari konfigurasi build untuk master (jadi jika Anda mengubah master build config, itu juga mengubah konfigurasi cabang untuk mencerminkan perubahan).

Kami juga memiliki fitur yang disebut Strategi Penggabungan yang dapat digunakan untuk memperbarui cabang dengan perubahan dari master sebelum pembangunan cabang berjalan atau secara otomatis mendorong perubahan dalam cabang yang berhasil dikuasai untuk dikuasai, memastikan perubahan antar cabang diuji bersama secepat mungkin .

Bagaimanapun, jika Anda tertarik untuk mempelajari lebih lanjut, lihat posting blog saya "Membuat Cabang Fitur menjadi efektif dengan Integrasi Berkelanjutan"

Tim kecil saya beralih ke DVCS satu atau dua tahun yang lalu, dan sisa perusahaan saya mengikutinya beberapa bulan yang lalu. Dalam pengalaman saya:

• Orang yang menggunakan VCS terpusat masih cenderung menunda komitmen ketika mereka melakukan proyek besar. Ini bukan masalah unik bagi DVCSes. Mereka akan memiliki set perubahan yang menunggu beberapa hari sebelum melakukan komit. Perbedaan besar adalah bahwa jika mereka membuat kesalahan di beberapa titik selama waktu ini, atau jika komputer crash, itu membutuhkan upaya yang jauh lebih banyak untuk memperbaikinya.
• Kami menggunakan alur kerja komit di mana setiap pengembang bekerja di cabang bernama mereka sendiri, dan hanya orang yang meninjau kode mereka diizinkan untuk menggabungkan perubahan mereka ke dalam kepala. Ini mengurangi kemungkinan komit yang menyebabkan masalah, sehingga orang benar-benar memperhatikan ketika server membangun menghasilkan pesan kesalahan. Ini juga berarti bahwa pengembang lain dapat terus bekerja di cabang mereka sendiri sampai kepala diperbaiki.
• Pada DVCS, orang cenderung menghabiskan lebih banyak waktu pemrograman sebelum menggabungkan kode mereka dengan kepala. Jadi itu cenderung memperkenalkan sedikit kelambatan ke dalam kesinambungan pembangunan. Tetapi perbedaannya tidak cukup signifikan untuk melawan keunggulan DVCS.

Saya baru-baru ini mengamati sekitar 19 proyek yang menggunakan Mercurial over SubVersion (saya adalah geek subversi ): pengembang mulai menjadi benar-benar individualis dengan bekerja di cabang mereka sendiri dan berintegrasi hanya setelah hari serveral atau minggu. Ini menyebabkan masalah dan masalah integrasi yang serius.

Masalah lain yang kami hadapi adalah dengan server integrasi berkelanjutan. Kami diberi tahu tentang masalah (gagal tes misalnya), hanya ketika sinkronisasi komit dilakukan ke server.

Tampaknya Martin Fowler menulis tentang itu di situsnya.

Yang mengatakan, beberapa proyek yang saya sebutkan melakukan sinkronisasi setidaknya sekali sehari mengurangi masalah. Jadi untuk menjawab pertanyaan Anda, saya pikir DVCS dapat mencegah integrasi berkelanjutan dan meningkatkan individualisme. Namun, DVCS bukanlah penyebab langsung.

Pengembang masih bertanggung jawab terlepas dari VCS yang mereka gunakan.

Ide Anda mendasarkan alasan Anda pada sangat goyah, berbicara dengan lembut. Ini adalah masalah tim / manajemen / proses yang mungkin ditunggu pengembang sampai mereka menyelesaikan tugas .

Melakukannya dengan satu atau lain cara, "tunggu" atau "buru-buru", cabang bersama atau cabang terisolasi, dikenal sebagai strategi percabangan , dan jika Anda mempelajari informasi yang tersedia secara online , Anda akan mengetahui bahwa memilih strategi tertentu pada dasarnya tidak ada hubungannya dengan VCS sedang dipusatkan atau didistribusikan.

Katakanlah, untuk VCS terdistribusi seperti Mercurial, Anda dapat dengan mudah menemukan rekomendasi kuat untuk penggabungan yang sering :

Pertama, sering bergabung! Ini membuat penggabungan menjadi lebih mudah bagi semua orang dan Anda mengetahui tentang konflik (yang sering kali berakar pada keputusan desain yang tidak kompatibel) sebelumnya ...

Mempelajari rekomendasi seperti di atas, orang dapat dengan mudah menemukan bahwa ini menarik untuk pertimbangan yang tidak ada hubungannya dengan Mercurial yang didistribusikan.

Sekarang, mari kita lihat situasi di samping VSC terpusat, Subversion. Mempelajari informasi online, orang dapat menemukan di antara strategi populer teratas yang disebut batang stabil dan batang tidak stabil - masing-masing memiliki dampak berlawanan pada frekuensi penggabungan. Anda lihat, orang memilih satu atau cara lain dalam melakukan sesuatu tanpa memperhatikan sentralisasi VCS.

• ^{Saya telah melihat penggabungan yang sangat tertunda terjadi (bahkan didorong oleh manajemen lumpuh) dengan VCS terpusat, serta sering penggabungan dilakukan dengan DVCS ketika tim / manajemen hanya berpikir bahwa itu adalah cara yang benar. Saya telah melihat bahwa tidak ada yang peduli jika VCS didistribusikan atau terpusat dalam memutuskan satu atau lain cara.}

Diberikan di atas, sepertinya jawaban yang tepat untuk Apakah DVCSes tidak mendorong integrasi berkelanjutan? akan menjadi Mu .

VCS yang didistribusikan atau tidak tidak memiliki dampak yang substansial pada hal itu.

Pengalaman saya adalah kebalikannya , tim yang menggunakan svn tidak akan mendorong selama berhari-hari, karena kode yang mereka kerjakan akan menyebabkan bagasi tidak dapat dikompilasi untuk orang lain tanpa membuang waktu untuk penggabungan manual. Kemudian di dekat ujung sprint, semua orang akan melakukan, penggabungan kegilaan akan terjadi, semuanya akan ditulis ulang dan hilang dan harus dipulihkan. Sistem CI akan menjadi MERAH dan penunjuk jari akan terjadi.

Tidak pernah memiliki masalah dengan Git / Gitorious.

Git memungkinkan Anda menarik dan menggabungkan perubahan orang lain sesuai keinginan Anda, bukan karena orang lain memeriksa sesuatu dan Anda ingin check-in, tetapi Anda memiliki 20 menit penggabungan manual untuk dilakukan.

Git juga memungkinkan Anda menarik komitmen orang lain, menggabungkan kode Anda, dan kemudian mendorong versi yang berfungsi ke orang lain sehingga mereka tidak perlu menebak apa yang harus mereka gabungkan berdasarkan apa yang Anda ubah.

Memiliki sesuatu seperti Gitorious sebagai mediator untuk tinjauan kode melalui permintaan gabungan membuat mengelola banyak cabang dan banyak kontributor menjadi sangat tidak menyakitkan.

Menyiapkan Jenkins / Hudson untuk melacak semua cabang aktif dalam repositori Git juga sangat mudah. Kami mendapat lebih banyak daya tarik dengan CI dan umpan balik yang lebih sering tentang keadaan repositori ketika kami pindah ke Git dari SVN.

Membangun server itu murah. Hanya meminta server CI Anda mengambil semua cabang yang Anda ketahui.

Jenkins memiliki dukungan untuk memeriksa beberapa repositori git dan mendapatkan yang terbaru dari salah satu dari mereka dalam satu pekerjaan. Saya yakin ada solusi serupa dengan alat lain.

Pertanyaan lama ini baru saja ditandai sebagai duplikat dari yang baru, dan karena banyak jawaban merujuk beberapa ide yang sudah ketinggalan zaman, saya pikir saya akan memposting yang diperbarui.

Satu hal yang tampaknya tidak biasa lima tahun lalu adalah menjalankan tes CI pada cabang permintaan tarik sebelum menggabungkannya menjadi master. Saya pikir ini mencerminkan sikap yang berubah yang meskipun sering diinginkan adalah penggabungan, berbagi setiap perubahan dengan semua orang , segera setelah Anda membuatnya , tidak optimal.

DVCS telah melahirkan mode yang lebih hierarkis dalam mengintegrasikan komit Anda. Misalnya, saya sering mengerjakan tugas yang sangat dekat dengan pengembang yang duduk di sebelah saya. Kami akan menarik dari cabang masing-masing beberapa kali sehari. Hari ini, kami berkolaborasi dengan pengembang lain melalui perubahan yang didorong ke permintaan tarik setiap beberapa jam.

Kami membuat perubahan besar pada skrip build. Jenkins secara lokal menggabungkan setiap cabang PR dengan tes master dan menjalankan, jadi kami mendapat umpan balik otomatis seperti itu, tanpa mengganggu pengembang lain yang membutuhkan bangunan yang bersih. Mungkin akan memakan waktu satu hari atau lebih sebelum PR siap bergabung untuk menguasai dan berbagi di luar kelompok kami yang terdiri dari tiga pengembang.

Namun, jika seseorang tidak bisa menunggu perubahan kita bergabung untuk dikuasai, karena perubahan mereka tergantung pada kita, mereka dapat menggabungkan cabang dev kita secara lokal, dan melanjutkan pekerjaan mereka. Inilah yang dilewatkan oleh banyak orang yang terbiasa dengan CVCS. Dengan CVCS, satu - satunya cara untuk membagikan perubahan Anda adalah menggabungkannya ke dalam repo pusat, dan itulah sebabnya penggabungan sering lebih penting. Dengan DVCS, Anda memiliki opsi lain.

Saya akan mengatakan bahwa DVCS lebih kondusif untuk integrasi berkelanjutan. Penggabungan tidak menyebalkan dengan mereka. Namun itu membutuhkan lebih banyak disiplin. Anda harus mengikuti komit lokal dengan tarikan dari pangkalan untuk bergabung dan kemudian mendorong ketika tugas Anda selesai (sebelum pergi ke yang berikutnya).

Ketika tim saya beralih ke Git, kami secara eksplisit memaparkan proses kami sedemikian rupa sehingga dorongan harus diperlakukan persis seperti komit di VCS yang lebih lama, dan komit lokal dapat dilakukan sesering / jarang seperti yang masing-masing individu pilih. Dengan itu, tidak ada perbedaan pada sistem CI apakah kita menggunakan DVCS atau VCS terpusat.

Jawabannya adalah ya dan tidak.

Perbedaannya di sini adalah antara melakukan langsung ke repo yang dilihat CI pusat, dan mendorong perubahan Anda ke repo yang dilihat CI pusat. 'Masalah' yang mungkin Anda temukan adalah bahwa pengguna DVCS mungkin tidak benar-benar melakukan dorongan itu secara teratur.

Saya akan mengatakan ini adalah fitur desain inheren dari DVCS, itu tidak dirancang untuk mendorong perubahan Anda ke server pusat sepanjang waktu - jika ya, Anda sebaiknya menggunakan CVCS sebagai gantinya. Jadi jawabannya adalah untuk menegakkan alur kerja yang lebih baik di antara para pengembang Anda. Katakan pada mereka untuk mendorong perubahan setiap malam. Sederhana!

(dan jika pengguna SVN Anda tidak melakukan setiap malam, katakan kepada mereka - ini masalah yang sama persis).

Git tidak mencegah integrasi berkelanjutan. Alur kerja berbasis trunk Anda adalah.

Itu mungkin terdengar berlawanan dengan intuisi, tetapi: jika pengembang bekerja pada cabang fitur, mereka dapat didorong untuk sering berintegrasi pada mesin mereka sendiri (dan diharuskan untuk melakukannya sebelum mengirimkan fitur mereka untuk digabung). Sebaliknya, alur kerja berbasis trunk mendukung komitmen yang lebih besar dan karenanya integrasi lebih jarang.

Saya berpendapat bahwa alur kerja berbasis-gaya-Google kontraproduktif dengan VCS seperti Git di mana penggabungannya mudah. Inilah yang saya sarankan sebagai gantinya:

• Hancurkan fitur cukup kecil sehingga tidak ada yang membutuhkan lebih dari satu atau dua hari untuk berkembang.
• Setiap fitur dikembangkan di cabang pribadi.
• Pengembang sering berintegrasi di cabang pribadi ( git fetch origin; git merge master). Saya biasanya melakukan ini berkali-kali sehari ketika bekerja dengan cara ini.
• Ketika pengembang mengirimkan cabang untuk digabung dan ditinjau, server CI melakukan pembangunan otomatis. Penggabungan hanya terjadi saat ini berlalu.

Jadi begitulah: komit kecil, integrasi sering, dan sejarah dilacak dari komit milik fitur yang mana. Cabang, digunakan dengan benar, adalah kunci untuk semua yang berharga tentang Git, jadi menghindarinya adalah kesalahan besar.

Ada solusi teknis yang luar biasa seperti @jdunay yang disebutkan, tetapi bagi kami ini adalah masalah orang - dengan cara yang sama dengan menumbuhkan lingkungan di mana orang yang berkomitmen untuk svn sering kali adalah masalah orang.

Apa yang berhasil bagi kami adalah: (ganti 'master' dengan cabang dev yang saat ini aktif)

1. Penggabungan / rebase yang sering dari master
2. Dorongan yang cukup sering untuk dikuasai

3. Kesadaran akan hal-hal yang menyebabkan menggabungkan neraka, seperti refactoring tertentu, dan mengurangi ini dengan berkomunikasi. Sebagai contoh:

   • Pastikan semua orang mendorong sebelum makan siang
   • Lakukan dan dorong refactoring saat makan siang
   • Pastikan semua orang menarik setelah makan siang