Czujesz się komfortowo łącząc kod?

Rozgałęzianie może być bolesne, ale nie powinno być.

To właśnie projekty podobne do Gita (mercurial, bazar) mówią nam o CVS i SVN. Na git i mercurial rozgałęzianie jest łatwe. Na SVN jest to łatwe, ale przy dużych projektach zarządzanie może być nieco trudne (ze względu na czas spędzony na procesie rozgałęziania/scalania, który może być bardzo długi - w porównaniu do niektórych innych, takich jak git i mercurial-i trudny, jeśli występują nieoczywiste konflikty). Które nie pomagają użytkownikom, którzy nie są przyzwyczajeni do oddział często mieć zaufanie do rozgałęzienia. Wielu użytkowników nieświadomych potężnych zastosowań rozgałęzień po prostu trzymaj go z dala, aby nie dodawać nowych problemów do swoich projektów, pozwalając, aby strach przed nieznanym sprawił, że są daleko od wydajności.

Rozgałęzianie powinno być łatwym i potężnym narzędziem, którego będziemy musieli użyć z dowolnego powodu wystarczająco dobrego do rozgałęzienia.

Kilka dobrych powodów do rozgałęzień:

• praca nad konkretną funkcją równolegle z innymi ludźmi (lub podczas pracy nad innymi funkcjami alternatywnie, jeśli jesteś sam w projekcie);
• posiadanie kilku wersji aplikacji;
• posiadanie równoległych wersji tej samej aplikacji - jak techniki współbieżne rozwijane w tym samym czasie przez część zespołu, aby zobaczyć, co działa lepiej; {12]}
• mając zasoby aplikacji są zmieniane na Artysty/projektantów (na przykład w grach) określonej gałęzi, gdzie aplikacja jest "stabilna", podczas gdy inne gałęzie i tułów są używane do funkcji dodawanie i debugowanie;
• [dodaj tutaj przydatne zastosowania]

Rozgałęzienie jest trywialne. Scalanie nie jest. Z tego powodu rzadko coś rozgałęziamy.

Używając SVN, stwierdziłem, że rozgałęzianie jest stosunkowo bezbolesne. Zwłaszcza jeśli okresowo łączysz bagażnik z gałęzią, aby nie był zbytnio zsynchronizowany.

Używamy svn. To zajmuje nam tylko około 5 minut do odgałęzienia kodu. To trywialne w porównaniu z ilością bólu, który ratuje nas przed zniszczeniem bagażnika.

Praca w bazie kodu złożonej z milionów linii kodu z setkami rozgałęzień programistów jest codziennością. Żywotność oddziału zależy od ilości wykonywanej pracy.

Dla małej poprawki:

• projektant tworzy boczny kanał z głównego strumienia
• wprowadza zmiany
• testy
• opinie
• łączy nagromadzone zmiany z głównego strumienia do bocznego kanału
• iteruje przez jeden lub więcej z poprzednich kroków
• powrót do głównego strumienia

Dla funkcji wieloosobowej drużyny:

• zespół tworzy boczny panel funkcji poza głównym strumieniem
• poszczególni członkowie zespołu działają na zasadzie "small fix" i łączą się z "feature sidebranch".
• sidebranch prime okresowo łączy nagromadzone zmiany z głównego strumienia do funkcji sidebranch. Małe przyrostowe połączenia z głównym nurtem do funkcji sidebranch są znacznie łatwiejsze do opanowania.
• Gdy funkcja działa, czy końcowe Scalanie z głównego strumienia do funkcji sidebranch
• merge feature sidebranch to main stream

Dla wersji oprogramowania klienta:

• Utwórz gałąź wydania
• dostarczaj poprawki potrzebne do wydania gałęzi
• poprawki są propogowane do / z głównego strumienia w razie potrzeby

Obsługa strumieni wydań Klientów może być bardzo kosztowna. Wymaga badań zasobów-ludzi i sprzętu. Po roku lub dwóch, wiedza programistów na temat konkretnych strumieni zaczyna się czerstwieć, gdy główny strumień przesuwa się do przodu.

Wyobrażasz sobie, ile musi kosztować Microsoft Obsługa XP, Vista i Windows 7 jednocześnie? Pomyśl o łóżkach testowych, administracji, dokumentacji, obsłudze klienta i wreszcie zespołach programistów.

Złota zasada: nigdy nie przerywaj głównego strumienia, ponieważ możesz opóźnić dużą liczbę deweloperów. $$$

Problem z rozgałęzieniami polega na tym, że używam rozproszonego systemu kontroli wersji (w moim przypadku Git, ale są też Mercurial i Bazaar), gdzie tworzenie gałęzi jest banalne.

Używam tags do oznaczania zamrożonego kodu i w tych systemach łatwo jest wrócić i oddzielić je dla poprawek błędów bez obciążania długowiecznych gałęzi w bazie kodu.

Używam Subversion i uważam rozgałęzianie za bardzo proste i łatwe. Więc odpowiadając na pytanie 1.. Tak.

Powód rozgałęzienia może się znacznie różnić. Rozgałęziam się, jeśli czuję, że powinienem. Dość trudno określić zasady i powody wszystkich możliwości.

Jednak jeśli chodzi o " pozwól deweloperowi odejść od ryzykownych zmian."skomentuj. Całkowicie się z tym Zgadzam. Tworzę gałąź zawsze, gdy chcę naprawdę bawić się kodem i chciałbym być jedynym programistą pracującym nad nim.. Kiedy się rozgałęzisz, możesz to zrobić...

Byłem w projekcie używającym svn i TFS i rozgałęzienie samo w sobie jest naprawdę prostą rzeczą.

Użyliśmy rozgałęziania dla release candidate, a także dla długotrwałych lub eksperymentalnych funkcji i izolacji od ingerencji innych zespołów.

Jedynym bolesnym momentem w rozgałęzieniu jest łączenie się, ponieważ stara lub intensywnie rozwinięta gałąź może znacznie różnić się od pnia i może wymagać znacznego wysiłku, aby połączyć się z powrotem.

Mając powyższe na uwadze, powiedziałbym, że rozgałęzianie jest potężną i użyteczną praktyką, którą należy wziąć pod uwagę podczas rozwoju.

Jeśli scalanie jest zbyt bolesne, rozważ migrację do lepszego VCS. To będzie większy ból, ale tylko raz.

Używamy svn i przyjęliśmy regułę do rozgałęziania zmian. Drobne zmiany są wykonywane w bagażniku.

Udostępniamy również rozgałęziacze.

Rozgałęzianie i scalanie zadziałały dobrze dla nas. Oczywiście są chwile, kiedy musimy usiąść i pomyśleć o tym, jak rzeczy pasują do siebie, ale zazwyczaj svn wykonuje świetną robotę łącząc wszystko.

Używam svn, rozgałęzianie kodu zajmuje mniej niż minutę. Kiedyś używałem Clearcase, zajęło mniej niż minutę, aby rozgałęziać kod. Używałem również innych, mniejszych, SCM i albo nie wspierały gałęzi, albo były zbyt bolesne w użyciu. Starteam brzmi jak ten drugi.

Więc, jeśli nie możesz przenieść się do bardziej użytecznego (właściwie, słyszałem tylko złe rzeczy o Starteam), to może będziesz musiał spróbować innego podejścia: ręcznego rozgałęziania. Polega to na sprawdzeniu kodu, skopiowaniu go do inny katalog, a następnie dodanie go jako nowego katalogu. Gdy chcesz scalić, sprawdzasz oba katalogi i używasz WinMerge do scalania, sprawdzając wyniki do oryginalnego katalogu. Niewygodne i potencjalnie trudne, jeśli nadal korzystać z gałęzi, ale to działa.

Sztuką z rozgałęzianiem nie jest traktowanie go jako zupełnie nowego produktu. Jest to gałąź-stosunkowo krótkotrwałe urządzenie służące do samodzielnego i bezpiecznego wprowadzania zmian do głównego bagażnika produktu. Anyone kto uważa, że scalanie jest trudne, albo refaktoryzuje pliki kodu tak bardzo (tzn. zmieniają nazwy, kopiują, tworzą nowe, usuwają Stare), że gałąź staje się zupełnie inną rzeczą, albo utrzymuje gałąź tak długo, że nagromadzone zmiany nie przypominają oryginału. Możesz zachować gałąź przez długi czas, po prostu musisz regularnie scalać swoje zmiany. Zrób to,a rozgałęzianie / scalanie staje się bardzo łatwe.

Robiłem to tylko kilka razy, więc nie czuję się z tym dobrze.

Zrobiłem to, aby przeprowadzić eksperymenty projektowe, które obejmowałyby niektóre Warcaby, więc rozgałęzianie jest łatwym sposobem na ogrodzenie ogrodu do zabawy. Ponadto pozwoliło mi to majstrować, podczas gdy inni ludzie pracowali na głównym oddziale, więc nie traciliśmy zbyt wiele czasu.

Zrobiłem to również przy wprowadzaniu szerokich zmian, które uczyniłyby bagażnik niemożliwym do skompilowania. W moim projekcie stało się jasne, że będę musiał Usuń bezpieczeństwo typu kompilacji dla dużej części bazy kodowej (przejdź od generyków do systemu.obiekt). Wiedziałem, że zajmie to trochę czasu i będzie wymagało zmian w całym kodzie, które kolidują z pracą innych ludzi. To również złamać budowę, dopóki nie byłem kompletny. Więc rozgałęziłem i usunąłem generyki, pracując aż ta gałąź się skompilowała. Potem włączyłem go z powrotem do bagażnika.

Wyszło całkiem nieźle. Zapobiegł wielu uderzeniom palców, co było świetne. Mam nadzieję, że nic takiego już się nie powtórzy. To rzadka rzecz, że projekt zmieni się, wymagając tego rodzaju szeroko zakrojonych edycji, które nie powodują wyrzucenia dużej ilości kodu...

Rozgałęzione muszą być prawidłowo zarządzane, aby połączenie było bezbolesne. Z mojego doświadczenia (z Perforce) regularna integracja z odgałęzieniem z linii głównej sprawiła, że integracja z powrotem do linii głównej przebiegała bardzo sprawnie.

Były tylko rzadkie przypadki, kiedy łączenie nie powiodło się. Ciągła integracja z linii głównej do gałęzi mogła wiązać się z połączeniami, ale były to tylko małe edycje, które Automatyczne Narzędzia mogły obsłużyć bez interwencji człowieka. Oznaczało to że użytkownik nie "widział" tego, co się dzieje.

Tak więc wszelkie połączenia wymagane w ostatecznej integracji mogą być również obsługiwane automatycznie.

Perforce 3-way merge tools były bardzo pomocne, gdy były rzeczywiście potrzebne.

Czy czujesz się komfortowo rozgałęziając kod?

Czy rozgałęziasz kod z powodów innych niż zamrożenie kandydata do wydania?

Cóż, to naprawdę zależy od wzorca kontroli wersji, ale krótka odpowiedź brzmi tak. Właściwie, proponuję przeczytać następujące Artykuły:

• Kontrola wersji dla wielu zespołów zwinnych Henrik Kniberg
• FeatureBranch by Martin Fowler

Bardzo podoba mi się wzór opisany w pierwszym artykule i może być stosowany z dowolnym (Nie rozproszonym) systemem kontroli wersji, w tym Starteam.

Mógłbym rozważyć drugie podejście (właściwie połączenie obu strategii) z (i tylko z) rozproszonymi systemami kontroli wersji (DVC), takimi jak Git, Mercurial...

Używamy StarTeam i rozgałęziamy się tylko wtedy, gdy mamy sytuację, która tego wymaga(np. poprawka do produkcji w trakcie cyklu wydania lub jakiś projekt o długim zasięgu, który obejmuje wiele okien wydania). Używamy etykiet widoku do identyfikacji wydań, co sprawia, że tworzenie gałęzi w późniejszym czasie jest proste. Wszystkie Kompilacje są oparte na tych etykietach widoku i nie budujemy kodu nieoznaczonego.

Programiści powinni stosować model "code-test-commit" i jeśli potrzebują widoku dla niektórych cel testowy lub" ryzykowny " rozwój tworzą go i zarządzają nim. Zarządzam repozytorium i tworzę gałęzie tylko wtedy, gdy ich potrzebujemy. Te czasy to (ale nie tylko):

• Hotfix produkcji
• projekty o długich lub nakładających się cyklach rozwoju
• rozbudowane przepisywanie lub eksperymentalne opracowanie

Narzędzie scalania w StarTeam nie jest najlepsze, ale jeszcze nie spotkałem się z problemem spowodowanym przez niego. Ktokolwiek robi połączenie, musi być bardzo na pewno wiedzą, co robią.

Utworzenie widoku "tylko do odczytu" w Star Team i ustawienie go na zmienną konfigurację pozwoli na automatyczne wyświetlanie zmian w bagażniku w gałęzi. Ustaw elementy do rozgałęzienia przy zmianie. Jest to dobre dla równoczesnych wysiłków na rzecz rozwoju.

Tworzenie widoku "tylko do odczytu" z oznaczoną konfiguracją jest tym, czego używasz do poprawek istniejących wydań produkcyjnych (zakładając, że je oznaczyłeś).

Rozgałęzianie jest trywialne, jak większość odpowiedziała, ale łączenie, jak mówisz, nie jest.

Prawdziwe klucze to odsprzęganie i testy jednostkowe. Spróbuj oddzielić przed rozgałęziasz się i miej oko na main, aby mieć pewność, że odsprzęgnięcie i interfejs są utrzymane. W ten sposób, gdy przychodzi czas na scalenie, jest to jak wymiana elementu lego: usuń stary element, a nowy idealnie pasuje na swoje miejsce. Testy jednostkowe mają zapewnić, że nic nie zostało złamane.

Rozgałęzianie i scalanie powinno być dość proste.

• czuję się bardzo komfortowo rozgałęziając/łącząc.
• rozgałęzianie odbywa się z różnych powodów, w zależności od modelu procesu rozwoju/

Istnieje kilka różnych modeli gałęzi:

Oto jeden

  Trunk          
  .      
  .      
  .      
  ..         
  . ....     
  .   ...
  .      ..Release1
  .      
  .      
  ...        
  .  .... 
  .    ...Release2
  .      
  .      
  ..         
  . ...  
  .  .. 
  .    ...Release3
  .      
  .      

Inny model rozgałęziający polega na tym, że wszystkie prace rozwojowe są wykonywane na pniu, a każde wydanie jest oznaczane, ale żadne dalsze prace rozwojowe nie są wykonywane na tym konkretnym wydaniu. Gałęzie rozwijają się.

  Trunk                                           
  .                                                         
  .                                                         
  .                                                         
  .Release1           
  .                       
  .                       
  .                   
  .                   
  .Release2           
  .                   
  .......                 
  .      ......       
  .           ...DevVer1
  .          .    
  .          .            
  .        ...DevVer2
  .      ....         
  .  ....             
  ...                     
  .Release3           
      .

Najważniejsze jest to, że Twój VCS musi obsługiwać elastyczne rozgałęzianie i łączenie. Systemy VCS(RCS, Clearcase, CVS) stanowią poważny problem. Mówi się, że SVN jest kłopotliwy również tutaj, nie wiem dlaczego.

Mercurial robi tu świetną robotę, podobnie jak (myślę)git.