Bir sürüm kontrolü ne zaman çok büyük bir işlem yapar? [kapalı]

Birkaç yerde "Büyük taahhütlerde bulunma" diye duydum ama aslında "büyük" bir taahhüdün ne olduğunu anlamadım. Bir grup dosya üzerinde çalışıyor olsanız bile ilgili olsa bile büyük mü? Bir projede kaç parça üzerinde aynı anda çalışmalısınız?

Bana göre başka bir şey yaratan başka bir şey yaratan bir şeyi unuttum ya da yarattığım için "küçük işler" yapmaya çalışmakta güçlük çekiyorum. Sonra böyle şeylerle bitirsin:

Özel giden kuyruk yapıldı

Bot
-Yeni alan msgQueue bir SingleThreadExecutor'dan başka bir şey değildir
-sendMsg, mesaj gönderilinceye kadar bloklar
gönderilen
-adminExist çağrıları güncellendi (denetleyiciye bakın)
-Mesaj göndermek için Kaldırılan çağrılar

kontrolör
-Yeni alan msgWait, mesajlar arasında beklenecek süreyi belirtir.
-Hizmet eklentileri yeniden başlatıldı
-adminExists, Global yöneticiler nedeniyle Sunucu'dan taşındı. Kanaldaki kontroller,
sunucu ve genel seviye

yönetim
-Yeni yöntemler getServer ve uygun nesne Admin olsun getChannel
ait olmak

BotEvent
-toString () ayrıca ekstra ve ekstra1 de gösterir.

Kanal
-anal alanı adıyla yeniden adlandırıldı
-Kanalda sabitlenmiş yazım hatası (int)

Sunucu
-Hareketli admin Kontrolöre Gidiyor

PluginExecutor
-Minor testi eklendi, daha sonra kaldırılacak

JS Eklentileri
-Çalışma değişikliklerine güncellendi
-Replaced InstanceTracker.getController () Controller.instance ile
-VLC şimdi kendi dosyasına konuş

Çeşitli NB projesi güncellemeleri ve değişiklikleri

---

Etkilenen dosyalar
/Trunk/Quackbot-Core/dist/Quackbot-Core.jar öğesini değiştirin
/Trunk/Quackbot-Core/dist/README.TXT değiştir
/Trunk/Quackbot-Core/nbproject/private/private.properties değiştir
/Trunk/Quackbot-Core/nbproject/private/private.xml dosyasını değiştirin
Değiştir / trunk/Quackbot-Core/src/Quackbot/Bot.java
/Trunk/Quackbot-Core/src/Quackbot/Controller.java öğesini değiştirin
Değiştir / trunk/Quackbot-Core/src/Quackbot/PluginExecutor.java
Değiştir / trunk/Quackbot-Core/src/Quackbot/info/Admin.java
Değiştir / trunk/Quackbot-Core/src/Quackbot/info/BotEvent.java
Değiştir / trunk/Quackbot-Core/src/Quackbot/info/Channel.java
Değiştir / trunk/Quackbot-Core/src/Quackbot/info/Server.java
/Trunk/Quackbot-GUI/dist/Quackbot-GUI.jar dosyasını değiştirin
/Trunk/Quackbot-GUI/dist/README.TXT değiştir
/Trunk/Quackbot-GUI/dist/lib/Quackbot-Core.jar dosyasını değiştirin
/Trunk/Quackbot-GUI/nbproject/private/private.properties değiştir
/Trunk/Quackbot-GUI/nbproject/private/private.xml dosyasını değiştirin
/Trunk/Quackbot-GUI/src/Quackbot/GUI.java dosyasını değiştirin
/Trunk/Quackbot-GUI/src/Quackbot/log/ControlAppender.java değiştir
/Trunk/Quackbot-GUI/src/Quackbot/log/WriteOutput.java dosyasını silin
/Trunk/Quackbot-Impl/dist/Quackbot-Impl.jar dosyasını değiştirin
/Trunk/Quackbot-Impl/dist/README.TXT değiştir
/Trunk/Quackbot-Impl/dist/lib/Quackbot-Core.jar dosyasını değiştirin
/Trunk/Quackbot-Impl/dist/lib/Quackbot-GUI.jar dosyasını değiştirin
/Trunk/Quackbot-Impl/dist/lib/Quackbot-Plugins.jar dosyasını değiştirin
/Trunk/Quackbot-Impl/lib/javarebel.stats değiştir
/Trunk/Quackbot-Impl/lib/jrebel.info ekleyin
/Trunk/Quackbot-Impl/nbproject/private/private.properties değiştir
/Trunk/Quackbot-Impl/nbproject/private/private.xml dosyasını değiştirin
/Trunk/Quackbot-Impl/nbproject/project.properties dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/CMDs/Admin/reload.js dosyasını değiştirin
Ekle / gövde / Quackbot-Impl / eklentiler / CMD'ler / Operatör / hostBan
/Trunk/Quackbot-Impl/plugins/CMDs/Operator/mute.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/CMDs/lyokofreak/curPlaying.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/CMDs/lyokofreak/lfautomode.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/listeners/onJoin.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/listeners/onQuit.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/testCase.js dosyasını değiştirin
/Trunk/Quackbot-Impl/plugins/utils/whatsPlaying.js ekleyin
/Trunk/Quackbot-Impl/src/Quackbot/impl/SandBox.java dosyasını değiştirin
/ Trunk / Quackbot-Impl / vlc_http ekle
/Trunk/Quackbot-Impl/vlc_http/current.html ekleyin
/Trunk/Quackbot-Plugins/dist/Quackbot-Plugins.jar dosyasını değiştirin
/Trunk/Quackbot-Plugins/dist/README.TXT değiştir
Değiştir / trunk/Quackbot-Plugins/dist/lib/Quackbot-Core.jar
/Trunk/Quackbot-Plugins/nbproject/private/private.properties değiştir
/Trunk/Quackbot-Plugins/nbproject/private/private.xml dosyasını değiştirin
Değiştir / trunk/Quackbot-Plugins/src/Quackbot/plugins/JSPlugin.java
Add / trunk / Quackbot-Plugins / vlc_http
/Trunk/global-lib/jrebel.jar ekleyin

Evet ....

Yani sorularınız için:

• Bir taahhüt çok büyük olduğunda ( açık olmayan şeyler ) bazı faktörler nelerdir ?
• Bu tür taahhütleri nasıl önleyebilirsiniz? Lütfen detayları ver
• Peki ya hızlı ilerlerken yarı-erken gelişim evrelerinizde olduğunuzda? Büyük komisyonlar hala iyi mi?

Bana göre başka bir şey yaratan başka bir şey yaratan bir şeyi unuttum ya da yarattığım için "küçük işler" yapmaya çalışmakta güçlük çekiyorum.

Bu bir problem. Çalışmanızı daha küçük ve yönetilebilir parçalara bölmeyi öğrenmeniz gerekiyor gibi geliyor .

Büyük taahhütlerde sorun:

• Çok kişili bir projede, taahhütlerinizin diğer geliştiricilerin çözmesi için çatışmalara neden olma olasılığı daha yüksektir.
• Günlük mesajlarında ne yapıldığını doğru olarak tanımlamak daha zordur.
• Değişikliklerin yapıldığı sırayı izlemek ve dolayısıyla sorunların nedenini anlamak daha zordur.
• Bir sürü taahhüt edilmemiş iş kaybetme olasılığını arttırır.

Bazen büyük taahhütler kaçınılmazdır; Örneğin, büyük bir API’yi değiştirmeniz gerekirse. Ama normalde durum böyle değil. Ve kendinizi bu durumda bulursanız, bir şube oluşturmak ve işinizi orada yapmak için ... iyi bir fikir olabilir ... işiniz bittiğinde ve yeniden birleşmeniz iyi olur.

(Başka bir durum, ilk içe aktarmayı yaptığınız zamandır, ancak yukarıda listelenen sorunların bakış açısından sorun değildir.)

Tek Sorumluluk İlkesi.

Her kaynak kontrol taahhüdü yalnızca bir amaca hizmet etmelidir. Özetinize "ve" veya "ayrıca" kelimesini koymak zorunda kalırsanız, ayırmanız gerekir.

Çalışma kopyanızda çok sayıda ayrı, ilgisiz veya yarı ilişkili değişiklik olması son derece yaygındır. Buna "karışık çalışan kopya problemi" denir ve disiplinli geliştiriciler için bile sakınmak çok zordur. Bununla birlikte, Git ve Mercurial her ikisi de size çözmeniz için araçlar sunar - git add -p veya chunk selection ve sırasıyla TortoiseHg'deki Mercurial Queues .

Müşterinin belirli bir değişikliğin yapılmasını istediğini hayal edin - örneğin, "ne olursa olsun" tarihinden iki gün içinde bir şeyin veya başka bir şeyin yapılamayacağına dair bir kural eklemek için. Sonra, değişikliği yaptıktan sonra fikirlerini değiştirirler. Taahhüdünüzü geri almak isteyeceksiniz. Eğer ilgisiz raporların sıralama düzenini değiştirmekle ilgili bazı şeylere katlanmışsanız, hayatınız bir sefalettir.

Bir iş öğesi, bir değişiklik kümesi. İstemciden bir istek, bir değişiklik oldu. Fikrinizi değiştirebileceğiniz bir şey, bir değişiklik kümesi. Bazen bu tek bir kod satırı olduğu anlamına gelir. Bazen veritabanı şeması dahil olmak üzere on farklı dosya. Bu iyi.

Büyük taahhütler, aslında aynı kovaya girmeyen tonlarca değişikliğiniz olduğunda gerçekleşir. Denetleyici mantığını değiştirirsem, sonra veritabanı bağlantı modelini, sonra bazı misc. senaryolar, hepsini bir taahhüt altında toparlamamalıyım.

Önleme, tamamladığınız şeye göre taahhütte bulunur. Yukarıdaki örnekte, denetleyici mantığından sonra, veritabanı çalışmasından sonra ve komut dosyalarından sonra çalışacağım. Çünkü basitçe işlemekle ertelemeyin sen değiştirdiğini bilmek. Diğer insanlar "Değişmiş eşyalarınız" giriş günlüğüne bakar ve ne içtiğinizi merak eder.

İlk ithalat, muhtemelen sahip olmanız gereken en büyük taahhüt. Sıfırdan bir sistem kurmak? Tabii ki birkaç büyük taahhüt var. Seviyelendirdikten sonra her şeyi düzenli tutmanın zamanı geldi.

Önceden büyük bir kod parçası üzerinde çalışacağınızı biliyorsanız, kodunuzun senkronize kaldığından emin olmak için periyodik olarak ana hattan kodu aşağı çekerken belirli bir özellik için bir dal oluşturmanızı öneririm. Şube üzerinde çalışmayı tamamladığınızda tüm değişikliklerinizi tekrar ana çizgiye yerleştirin. Bu şekilde, diğer ekip üyeleri büyük bir taahhüt gördüklerinde şaşırmayacak ve / veya rahatsız olmayacaktır. Ayrıca, işleri kırmak için daha az şans var. İşleri daha küçük işler haline getirmek için pratik yapmaya devam edin. Zamanla ikinci doğaya dönüşecek.

Bu örnek, çok büyük bir taahhüdü göstermektedir.

Genel bir kural olarak, değişikliği bir cümlede veya bir metinde bir satırda tanımlayın. (Bu kurala dayanarak, taahhüt 10-15 küçük olanlara bölünmelidir.) Tek bir satırdaki bir teklifi yeterince yorumlayamazsanız, o zaman zaten çok büyük demektir.

Daha küçük taahhütler uygulamak için, daha önce değiştirdiğiniz veya eklediğiniz şeyler hakkında not defterinize (veya Not Defteri'ne) not alın. Uzun bir liste haline gelmeden önce veya önceden not defterinde bulunduğunuz ile ilgili olmayan bir kod değişikliği yapmadan önce karar verin.

Alanımda (fizik modellemesi), bugün çıktısında 6 ay önce depoda olmayan bir hata keşfettim. Bu olduğunda, düzeltmelerde ikili arama yapacağım:

1. 3 ay öncesinden çalıştır model
2. Hata hala çıktıysa, modeli 4.5 ay öncesinden çalıştırın
3. ... verim düşük verimle sonuçlanan bir taahhüt bulana kadar tekrarla

Böcek canavarca bir şekilde ortaya çıktığında, sorunun kaynağını bulmak için ince dişli bir tarakla oturmam gerekiyor. Taahhüt az sayıda dosyaya dokunduysa, sorunu ortaya çıkaran kod satırlarını izlemek daha az acı vericidir.

Sorununuzu bir dizi daha küçük işe ayırmanızı tavsiye ederim (her bir görevi ideal olarak bir hata izleyiciye koyun). Her görevi tamamlarken bir taahhütte bulunun (ve hata izleyicinizde bu hatayı / özelliği kapatın).

Gerçekten önemli olan taahhüdün boyutu değil, taahhütlerinizin nasıl organize edildiğini belirlemesi gereken değişimin kapsamıdır .

Sen, mesela her örneğini değişebilir __macro1için __macro2200 dosya değiştiren büyük kod tabanı, içinde. Bu durumda 200 taahhüt aklı başında olmaz.

Sonunda istediğin şey, depoyu herhangi bir revizyonda çekebilmektir ve yapım işine sahip olmaktır. Eğer değiştirmek mi libfoohiç libbar? Umarım bu değişiklik, oluşturma komut dosyalarınızı ve Makefiles dosyalarınızı (veya uygulanabilir olanları) güncellemeyi de içerir.

Bazen, bir şeyi gerçekleştiren bir dizi deneysel değişiklik yapmanız gerekebilir, bu durumda, daha sonra geri dönmeniz gerekirse hangi kapsamın sizin için daha önemli olduğunu belirlemeniz gerekir. Biri diğerine mi bağlı? Hepsini tek bir revizyonda aynı anda tamamlayın. Aksi takdirde, bu durumda değişiklik başına bir taahhüt öneririm. Yine de başka bir dalda veya başka bir depoda böyle bir şey yapıyor olmalısınız.

Evet, tek bir dosyayı önceki bir revizyona geri döndürme gücüne sahipsiniz (bu nedenle bir dosyayı daha büyük bir taahhüdün dışında tutuyorsunuz);

Durup düşünürseniz, "Tamam, testler başarılı, sanırım bu işe yarıyor .. ama kötüye giderse, kolayca geri alabilir miyim?" .. mantıklı taahhütlerde bulunmaya başlayacaksınız.

Burada kavranması gereken şey, bu bağlamda "Büyük" ün, taahhüdün fiziksel büyüklüğüne değil (genellikle ikisi el ele gidene kadar) belirgin değişiklik sayısı ile ilgilidir.

Onun kadar meselesidir olarak "büyük hareketin yapmazlar" değil yapmak küçük hareketin yapmak - küçük kendini işlemeye olma idealdir değişiklikleri içeriyordu.

Ayrı ayrı (ve güvenli bir şekilde) işlenebilecek bir dizi şeye sahip olduğunuz changelog'dan açıkça anlaşılıyor ve bu nedenle oldukça büyük olduğu açıkça görülüyor.

Bunun bir problem olabilmesinin nedeni, son taahhüdünüzün şu anda yaptığınız değişiklikler için referans noktanız olması ve örneğin, ilk biti doğru yaparsanız ve sonra bir sonraki biti yanlış yaparsanız kolay bir yol bulmamanızdır. işinizi hata yapmaya başladığınız noktaya geri döndürmek için (BTDTGTTS).

Elbette bazen değişiklikler sadece büyüktür - büyük ölçekli yeniden yapılanma - ve diğerleri tarafından önerildiği gibi, bu noktada dallanmanız gereken yer burasıdır; sorun ve erken ve sık taahhüt vermeye devam etmek.

Bir şey daha - işinizin ortasında daha fazla dikkat gerektiren bir şey ortaya çıkarsa, ayrı ayrı değiştirmeniz (ideal olarak tamamen ayrı bir klasör kümesinde) ve ayrı olarak işlem yapmanız gerekir.

Tüm bunlardaki asıl zorluk, mekaniğin zihniyetinin değil - bir taahhüdün sadece şu anda yaptığınız bir yedek kopya değil, fakat her bir taahhüdün bir inç çakıl taşı olduğu ve çok fazla yanlış bir şey olmadığı. Küçük taahhütlerin ve çetelerin yerine getirilmesiyle farklı şeylerin birbirine karışması, bir kod yığını içinde belli belirsiz işlevsellik parçalarının bir araya gelmesi kadar kötüdür.

En azından, kendinize ne zaman düşünürseniz, kendinizi geliştirmek için kendimi eğitin "Şu ana kadarki ilerlememi seviyorum ve yapmak üzere olduğum değişiklikler felaketse, bunu kaybetmek istemiyorum." Ardından, denediğiniz tüm çıkmazları veya bir sorunu bulmak için eklediğiniz özel hata ayıklama kodlarını uçurmak için VCS'den faydalanma seçeneğiniz vardır. (örneğin git reset --hardveya ile rm -rf *; svn update)

Sert ve hızlı bir kural yok, taahhüdünüzün çok büyük olduğu bir çizgi yok.

Orada ise daha küçük kaydedilmesini iyi olduğunu bir kılavuz nedenle içinde (yani her satırını işlemekten probaby aşırı) Ancak.

Bu tür kuralları göz önünde bulunduruyorum:

• Tek bir işlem yalnızca bir hata düzeltmesi için değişiklikler içermelidir
• Tek bir taahhüt, yarım günden fazla çalışma içermemelidir
• Tek bir taahhüt yapıyı bozmamalı

Tabii ki - bunlar aklımda olan şey - YMMV. Farklı geliştiriciler, farklı ayrıntı düzeylerini tercih eder.

Taahhüt ne kadar küçükse, potansiyel bir gerilemenin nereden geldiğini bulmak o kadar kolay olacaktır.

İdeal olarak, bir taahhüt , kod tabanındaki (böcek, özellik vb. İle ilgili) en küçük tutarlı değişiklik anlamında atomik olmalıdır .

Taahhüdün boyutunu küçük tutmak için özel ipuçlarına gelince, bu VCS'nize ve kurulumun büyük ölçüde yapılmasına bağlıdır: yerel olarak işlem yapabilmeli veya sunucudaki kendi şubenizde çalışabilmelisiniz.

Önemli olan, atom değişimi yaptığınız her seferinde "özel" şubenize karar vermektir ve ardından şubenizi düzenli olarak birleştirebilirsiniz, örneğin her hafta.

Bir dvcs kullanarak iş akışınız şöyle görünebilir:

code code code
git commit       // create commit locally with meaningful message
code code code
git commit       // create commit locally with meaningful message
code code code
git commit       // create commit locally with meaningful message
...
git push         // push your previous commits to the team server

Merkezi bir vcs kullanarak:

svn copy trunk my_feature_branch  // create your private branch
svn co my_private_branch          //
code code code
svn commit                        // commit on your private branch with meaningful comment
code code code
svn commit                        // commit on your private branch with meaningful comment
code code code
svn commit                        // commit on your private branch with meaningful comment
...
svn merge my_feature_branch trunk  // all your previous commit are merged to main/master branch

Muhtemelen mükemmelliğin bir şeyi daha fazla alamayacağınız zaman olduğunu söylemiştiniz. Bu aynı zamanda taahhüt büyüklüğü için standart tanımlamalıdır.

Bu “mükemmel” boyutun nerede olduğu projenize bağlı. Dış müşterilere gönderiyorsanız, iyi bir boyut, bir sonrakini zamanında bitirmediyseniz, sevkıyatta rahat edeceğiniz en küçük artış olabilir. Dahili, sık kullanılan uygulamalar oluşturuyorsanız, en iyi boyut hiçbir şeyi bozmayan en küçük artış olabilir (ve sizi olmak istediğiniz yere yaklaştırır).

Modern versiyon kontrol sistemleri, kolay dallanma, etkileşimli rebasing, hazırlama alanı vb. İle iyi taahhütler oluşturmanıza yardımcı olur.

Taahhüt mesajları yalnızca bir satır olmalıdır (ve git max 60 karakter için). Yapılmakta olan kodun, açıklayıcı iletiyi bu sınırlar içinde tutacak kadar küçük olması gerekir.

Her zaman taahhüt etmeye meyilliyim (daha da öylesine şimdi gitmeye geçtik) Yaptığım işin bu şekilde yapılmasının "nedenini" yakalamaya izin verdiği için bir yığın yaptım.

Bazen bütün gün birkaç farklı mantıksal olarak farklı chagn üzerinde çalıştın ve kodunu arada yazmayı unuttun. Kullanılması git citoolEğer çalışıyorken gün boyunca çok dikkatli olmasalar bile, günün sonunda güzel lokma büyüklüğünde parçalar halinde çalışmanızı ayrıldığım için çok yararlı olabilir.

git citool Bir dosyanın hangi belirli parçalarının (veya hangi belirli satırların) belirli bir taahhütte bulunacağını seçmenize izin verebilir, böylece aynı dosyada yapılan (örtüşmeyen) değişiklikleri birkaç komisyona ayırabilirsiniz.

(Görünüşe göre Subversion kullanıyorsunuz. Subversion için bunu yapan bir araç bilmiyorum, ancak git-svngit için Subversion adaptörünü kullanmayı düşünebilirsiniz .

Taahhüt ne kadar büyük olursa, yapıyı bozma ve ekibinizin geri kalanı tarafından ödeme alma olasılığınız o kadar yüksek olur. Günde iki kez değişiklik yapmaya çalışıyorum. Öğle yemeğinden hemen önce ve eve gitmeden önce. Yani @ 12 ve 16: 30'da her şeyin çalışıp çalışmaya hazır olmasına çalışıyorum. Bu uygulamanın benim için işe yaradığını düşünüyorum.

Sorularınıza cevap vermek için:

1) Benim için standart bir taahhüt birden fazla şey yapıyorsa büyük olarak kabul edilir. Yani bir hatayı düzeltmek ya da bir özellik eklemek demek istiyorum.

2) Bir şeyi tamamladığınızda taahhüt etmeyi bir alışkanlık ve kural haline getirerek bu tür taahhütleri önleyin.

3) Gelişimin yarı-erken aşamalarında, taahhütlerin daha sonra kullanılacak dosyaların ilk oluşturulmasını içermesine izin veriyorum.

Bittiğimde, tanımlayabileceğiniz tüm hataların giderildiğini ve taahhüt ederek yapıyı bozmayacağınızı kastediyorum.

Evet, bu çok sayıda taahhüt doğurur, ancak aynı zamanda değişikliklerden yalnızca birinin soruna neden olduğu aynı zamanda işlenen büyük bir değişiklik dizisini geri almak yerine, tam olarak neyin kırıldığını geri almanıza izin verir.

Ayrıca Mercurial ve Git gibi dağıtılmış sürüm kontrol sistemleri (DVCS) için kuralların biraz değiştiğini belirtmek isterim. Bunlardan birini kullanıyorsanız, bir değişiklik yaptığınız zaman taahhütte bulunursunuz, ancak henüz test etmediniz ve sonra çalışırken merkezi depoya zorluyorsunuz. Bu, yapıyı bozma konusunda endişelenmeden kodunuzda daha fazla değişiklik yapmanıza izin verdiği için tercih edilir.

Benim durumumda bir sunucunun dosyalarını depo sistemine (SVN) işlemeye çalışıyorum. Bu ilk teklif ve gerçekten büyük bir proje olduğu için indirmek istemiyorum (birkaç GB) ve ilk istemcileri istemcileri sunucudan çıkarmak istiyorum.

Sorun, müşterinin paylaşılan bir sunucuda olması, svn istemcisinin bir dakikadan daha uzun bir süre çalışırsa öldürülmesidir (veya başka bir yazılım).

Bir alternatif projeyi bilgisayarıma indirmek ve oradan ilk taahhüdümüzü yapmak olacaktır, ancak SVN'de büyük bir işlemi daha fazla işlemeye ayırma, işlem yöntemlerine benzer bir seçenek olup olmadığını bilmek istiyorum.

Benden önce geliştirici asla bir sürüm kontrol sistemi kullanmadı.

Çalıştığım şirket, her taahhüt için bir eş kod incelemesini zorlamaktadır. Bu nedenle, bir akranın ne olduğunu anlamasını ve makul bir sürede gözden geçirmesini zorlaştıran herhangi bir taahhüt çok büyüktür.