Geleneksel ekipler için dağıtılmış sürüm kontrolü kullanan baş ağrıları?

Her ne kadar kişisel projelerim için DVCS kullanmış ve beğenmiş olsam da projenize katkıları başkalarından nasıl daha kolay yönetebildiğini (örn. Tipik Github senaryosunuz) tamamen görebilsem de, "geleneksel" bir ekip için bazı sorunlar olabilir. TFS, Perforce, vs. gibi çözümlerin kullandığı merkezi yaklaşım. ("Geleneksel" derken, hiç kimsenin "sahip olmadığı" bir projede çalışan bir ofiste geliştiricilerden oluşan bir ekip demek, potansiyel olarak herkes aynı koda dokunuyor.)

Bu sorunlardan birkaçı kendi başıma öngördüm, ama lütfen diğer hususlara dikkat edin.

Geleneksel bir sistemde, sunucudaki değişikliğinizi kontrol etmeye çalıştığınızda, başka biri çakışan bir değişikliği daha önce kontrol etmişse, sizinkini kontrol etmeden önce birleştirmek zorunda kalırsınız. DVCS modelinde, her geliştirici kendi yerel olarak değişir ve bir noktada başka bir repoya zorlar. Bu repo daha sonra bu dosyanın 2 kişinin değiştiği bir şubesine sahip. Görünüşe göre şimdi bu durumla başa çıkmak için birisinin görevlendirilmesi gerekiyor. Ekipte görevlendirilmiş bir kişi, tüm uyuşmazlıkları birleştirmek için kod tabanının tamamı hakkında yeterli bilgiye sahip olmayabilir. Şimdi, birisinin bu geliştiricilerden birine yaklaşması, birleştirmeyi çekmesini ve yapmasını ve tekrar itmesini (veya bu görevi otomatikleştiren bir altyapı inşa etmeniz gerektiğini) ekstra bir adım eklendi.

Dahası, DVCS yerel olarak çalışmayı bu kadar kolay hale getirme eğiliminde olduğundan, geliştiricilerin itmeden önce yerel depolarında birkaç değişiklik biriktirmesi olasıdır, bu tür çatışmaları daha yaygın ve daha karmaşık hale getirebilir.

Takımdaki herkes sadece kodun farklı alanlarında çalışıyorsa, bu bir sorun değildir. Ama herkesin aynı kod üzerinde çalıştığı durumu merak ediyorum. Merkezileşmiş model çatışmaların hızlı ve sık sık ele alınmasını zorlar ve büyük, ağrılı birleşmeler yapma veya ana repoyu "polise" alma zorunluluğunu azaltır.

Ofisinizdeki ekibinizle DVCS kullananlarınız için bu tür davaları nasıl ele alıyorsunuz? Günlük (veya daha olası, haftalık) iş akışınızın olumsuz etkilendiğini düşünüyor musunuz? İşyerinde bir DVCS önermeden önce dikkat etmem gereken başka noktalar var mı?

Mercurial'ı yaklaşık bir yıldır kullanıyoruz. Bahsettiğiniz baş ağrısı var olmakla birlikte, bizim için tam olarak benimsenmenin en büyük zorluğu yerel depoların DVCS zihniyetine girmekti (= sık sık taahhüt edin.) "Cilalı bir kodunuz olduğunda bir kez çalışın" eski zihniyetine izin vermek zor olabilir Git.

Dedin:

DVCS modelinde, her geliştirici değişikliklerini yerel olarak kontrol eder ve bir noktada başka bir repoya zorlar. Bu repo daha sonra bu dosyanın 2 kişinin değiştiği bir şubesine sahip. Görünüşe göre şimdi bu durumla başa çıkmak için birisinin görevlendirilmesi gerekiyor.

Mercurial'ın varsayılan yüklemesi bu davranışı engeller. Ekstra onay olmadan uzak depoda birden fazla kafa oluşturulacaksa itmeye izin vermez. Günlük aktiviteler için bundan kaçınırız. (Git kafaları adlandırdı ve her biri yalnızca bir önceki sürümü tamamen onaylamadan birleştirirse güncellenebilir, bu nedenle durum tekrar ortaya çıkamaz. Diğer DVCS de benzer korumaya sahiptir.)

Bu nedenle, her çalışma gününün sonunda, taahhüt için biraz zaman ayrılması gerekiyor, ki bu gerçekten şu etkinlikler:

1. Yerel değişiklikler yapın.
2. Merkezi repodan çekin.
3. Birleştir (& birleştirmeyi birleştir.)
4. Merkezi repoya itin.

Bu, yakın zamanda bu kod üzerinde çalışan bir kişi üzerindeki birleştirme etkinliğini korur ve değişikliklerini herkes kadar hızlı bir şekilde entegre edebilmelidir.

Soruda belirtildiği gibi, bu gerçekten sadece iki kişi aynı kod alanında çalışırken çaba harcar. Durum buysa, yine de DVCS'yi kullanmanın daha fazla faydası vardır, bu nedenle kazanç bu geliştiriciler için zaten belirgindir. (Ek avantajlar, her geliştiricinin ayrı bir kod işleyebilmesi ve başka bir geliştirici engellemeden kendi repolarıyla oynayabilmesini içerir.)

Bahsettiğiniz başka bir konu:

Dahası, DVCS yerel olarak çalışmayı bu kadar kolay hale getirme eğiliminde olduğundan, geliştiricilerin itmeden önce yerel depolarında birkaç değişiklik biriktirmesi olasıdır, bu tür çatışmaları daha yaygın ve daha karmaşık hale getirebilir.

Bu bizim için birleştirme sorunu oluşturmaz, ancak farklı bir sorun oluşturabilir:

DVCS'nin esnekliği, birçok farklı iş akışının mümkün olduğu, ancak bunlardan bazılarının sorumsuz olduğu anlamına gelir. DVCS ile net süreç veya prosedürlere olan ihtiyaç artar. Yerel değişiklikleri koruma faaliyeti, birçok şeye bağlı olarak uygun olabilir veya olmayabilir.

Örneğin: bir geliştirici bir evcil hayvan özelliği üzerinde birkaç hafta içinde boş zamanlarında çalışabilir mi? Bazı ortamlarda bu teşvik edilir, bazılarında bu uygunsuz olur ve tüm değişiklikler yakında merkezileştirilmelidir. Ancak bir geliştirici değişiklikleri yerel olarak tutuyorsa, çalışmalarının en son ortak rev ile güzel bir şekilde oynamaya devam edeceğinden emin olmak için kesinlikle ilgili değişiklikleri çekmek isteyeceklerdir.

Kauçuk yolla karşılaştığında, yazılım sürümleri veya dağıtımları genellikle merkezi bir repodan gelir, bu nedenle geliştiricilerin değişikliklerini test ve dağıtım için buraya almaları gerekir.

Bu benim hikayem ve en az birkaç dakika boyunca ona bağlı kalıyorum ...

Sorunuzun önermesi "Birleşmeler zor ve kaçınılmalıdır" civarındadır. DVCS sistemleri bu engeli kaldırır, aslında daha fazlasını yaparlar, birleştirme fikrini kucaklarlar - sonuç olarak birleşmelerden ve çatışmaların birleştirilmesinden korkmamalısınız, merkezi araçların aksine, DVCS araçları bunu tasarımla destekler.

Jamie F'nin mükemmel cevabının belirttiği gibi - Düzenli olarak (günlük) yapılan Command-Pull-Merge-Push iş akışı, bazı başkalarının işlerinde yürürseniz, onu erken görüyorsunuz - görünür olduğu sürece, yönetilebilir .

Açıkladığınız sorunlar, araçları nasıl kullanmayı seçtiğinizle ilgilidir.

SVN ve GIT'i birkaç yıl boyunca yerel olarak kullandıktan sonra 6 ay önce SVN'den GIT'e geçtik. Kimse geri dönmeyecek ve acı dolu birleşme çatışmaları geçmişte kaldı. "Küçük ve sık taahhüt" mantra anahtardır.

Git kullanan bir ekip üzerinde çalıştığımda, başparmak kuralı şuydu: özel bir dalda çalışın, daha sonra, çalışmanızı ekibin geri kalanına sunmaya hazır olduğunuzda, itmeden önce dalınızı ustaya yeniden hazırlayın. (Daha sonra şubenizi doğrulayın.)

Bu strateji, ustanın lineer bir taahhüt dizisi olduğu ve tüm entegrasyon konularının şubelerde herkese açık olmadan onarıldığı anlamına geliyordu.

SVN gibi bir araç, sıkıca entegre edilmiş bir çalışma şeklini kuvvetle teşvik eder.

Sıklıkla paylaşılan bir şubeye (gövde veya geliştirici bir şubeye) bağlı kalmak.

Bu, yaşadığım çoğu kurumsal geliştirme ortamı için A-OK'dir ve kapsamlı entegrasyon testleri, regresyon testleri ve birim testleri tarafından desteklenen Sürekli Entegrasyon kullanımı ile daha da kolaylaştırılır ve teşvik edilir (Bireysel geliştiricilerin kırılmadığına güven kazanmalarına yardımcı olur) herhangi bir değişiklik).

DVCS size daha bağımsız çalışma özgürlüğü verir, bazı durumlarda ihtiyacınız vardır ve birleşmeler için (çok fazla) gelişmiş destek herhangi bir zarar veremez.

Her zaman aklımın arkasında kalan endişe şudur: Büyük bir özgürlükle bu özgürlüğü kullanma cazibesi gelir.

Kesinlikle, (sınırlı) tecrübemde, mevcut takımımda (Mercurial kullanarak) bağımsız olarak çalışmak için önceki rollerde (SVN, CVS & P4 kullandığımız yer) yaptığımdan çok daha fazla zaman harcıyorum.

Bu sadece araca kısmen atfedilebilir, ancak bence, iletişim ve koordinasyon çabalarını harcamak için zorlayıcı bir neden olmadığında, insanlar ayrı ve izole bir şekilde çalışma eğiliminde olacaklar.

Bu mutlaka kötü bir şey değildir, ancak bunun göz önünde bulundurulması gereken bir şey olduğuna inanıyorum.

Git / mercurial tip sürüm kontrolü ile ilgili şey, sık sık taahhüt etmek ve kod iyi olduğunda merkezi sunucuya zorlamaktır. Bununla birlikte büyük bir artı, çatışma durumunda uygulanması kolay küçük yamalar oluşturmasıdır. Ayrıca, iş akışınız şu satırlarda olmalıdır:

1. Birçok yerel taahhüt
2. Sunucudan al
3. Sunucuya aktar

Sunucudan gelen bu çekişme çakışmalar yaratabilir, ancak bunu çözmek için, bir çok kez gerekli olan tek şey bir birleştirme yerine basit bir rebase'dir. Bu, ana hat geçmişini oldukça temiz tutacak ve oldukça fazla çatışmayı kaldıracağını hissediyorum.

Bu, iki işin gerçekleşebileceği için bir iş arkadaşının yerel repolarından çektiğinizde de geçerlidir. Ya ilk önce sunucuya iter, bu zaten yamaları olduğu için iyidir ve herhangi bir çatışma meydana gelmez, ya da önce itersiniz, bu da yamaları çektiğinde sadece alacağı anlamına gelir.

Tabii ki, bazen bir birleştirme daha iyi bir çözümdür, örneğin bir ustayla birleştirilmesi gereken bir özellik dalında çalışıyorsanız.

İş akışınızda, açıkça başka bir geliştiriciye gitmesi ve ona çatışmayı düzeltmesini söylemesi gerekenler hakkında konuşuyorsunuz, ancak bu gerekli olmamalı. Merkezi sunucu "patron" ve esas olarak karşı çalışması gerekir. Yaptığınız değişiklikler merkezi repo için geçerliyse, sorun değil. Değilse, işiniz, çatışmayı düzeltmek için sizin işinizdir, bu da çatıştığınız geliştiricinin değişikliklerini anlamaya yardımcı olmasını gerektirebilir. Bu sunucudan çekmeye / rebase yapmaya çalıştığınızda gördüğünüz bir şeydir. Bu nedenle, sunucudan çekmeniz gerektiğinde taahhütte bulunun ve çatışmalarla başa çıkın.

Merkezi depo ile çalışma prensibi, kilitlemesiz merkezi veya dağıtılmış sistemle çalışırken aynıdır:

• Merkezi sistemde:
  1. Ana hattan en son sürümü alın (alt sürümde "gövde", git'te "ana", ...)
  2. Dosyaları değiştirme
  3. "Update" komutunu kullanarak değişiklikleri ana hattan en son sürümle birleştirin
  4. Anahat taahhüdü
• Dağıtılmış sistemde:
  1. Ana hattan en son sürümü edinin
  2. Dosyaları değiştirme
  3. Yerel olarak taahhütte bulun
  4. Değişiklikleri ana hattan en son sürümle birleştirin ve sonucu yerel olarak uygulayın
  5. Ana hatta itin.

Dağıtılmış sürüm yok, önceki kafa revizyonunu tam olarak birleştirmeyen revizyonu itmenize izin vermez (özel geçersiz kılma olmadan; bazen yararlıdır), bu nedenle birleştirme adımı yapmadan geçmeyecektir (bu yüzden biri iki versiyon olmayacaktır) ilgili olarak birleştirmeniz gerekir).

Şimdi, adımlardan dördünün terminoloji dışında aynı olduğunu, ancak dağıtılmış sistemlerin fazladan bir adım eklediğini unutmayın. Bu adımın en büyük avantajı, güncelleme / çekme çakışmaları oluşturduğunda ve bunları nasıl çözeceğinizden veya bunları çözerken nasıl bir hata yapacağınızdan emin değilseniz, geri dönebilir, yaptığınızı gözden geçirebilir ve birleştirmeyi yeniden yapabilirsiniz. Subversion bunların hiçbirini hatırlamaz, bu nedenle güncellemeyi çözerken bir hata yaparsanız, vidalanırsınız.

Değişiklikleri biriktirmeye gelince, insanlar bunu merkezi sistemle de yapma eğilimindedir. Özellikle özellikler arasında sık sık geçiş yapmanız gerekiyorsa (bir hatayı düzeltmek için daha uzun bir işi kesmek veya müşterinin acilen ihtiyaç duyduğu bazı ince ayarları yapmak gibi), insanların genellikle bitirmedikleri için değişiklikleri yerel olarak tutmaları gerekir. Bu yüzden sistem en azından anlamayı destekliyorsa daha iyidir.

Her iki durumda da, bu sorunların araçlarla değil, takımdaki uygun yönergeler ve iletişim ile ele alınması gerekir. Daha esnek araçlarla yönergeler daha önemlidir, ancak daha esnek araçlar çeşitli köşe kasalarının daha iyi ele alınmasını sağlar.