Jak często zatwierdzać zmiany w kontroli źródła? [Zamknięte]

Jak często powinienem zatwierdzać zmiany w kontroli źródła? Po każdej małej funkcji, czy tylko w przypadku dużych funkcji?

Pracuję nad projektem i mam do wdrożenia długoterminową funkcję. Obecnie zobowiązuję się po każdym kawałku pracy, tj. Każdej zaimplementowanej podfunkcji i usuniętym błędzie. Popełniam nawet po dodaniu nowej porcji testów dla niektórych funkcji po wykryciu błędu.

Jestem jednak zaniepokojony tym wzorem. W produktywny dzień pracy mogę popełnić 10 zobowiązań. Biorąc pod uwagę, że używam Subversion, te zatwierdzenia wpływają na całe repozytorium, więc zastanawiam się, czy rzeczywiście dobrą praktyką jest tworzenie tak wielu?

Za każdym razem, gdy kończę „pełną myśl” o kodzie, który się kompiluje i uruchamia, odprawiam. Zwykle kończy się to między 15-60 minutami. Czasami może to być dłuższe, ale zawsze próbuję się zameldować, jeśli mam wiele zmian w kodzie, których nie chciałbym przepisać w razie awarii. Zazwyczaj też upewniam się, że mój kod się kompiluje i odprawiam pod koniec dnia pracy przed powrotem do domu.

Nie martwiłbym się wprowadzaniem zbyt wielu zatwierdzeń / zameldowań. To naprawdę jest do bani, gdy trzeba coś przepisać, i miło jest móc cofać się w małych krokach na wszelki wypadek.

Kiedy mówisz, że obawiasz się, że twoje „zatwierdzenia wpływają na całe repozytorium” - czy masz na myśli fakt, że liczba wersji całego repozytorium wzrasta? Nie wiem, ile bitów używa Subversion do jego przechowywania, ale jestem pewien, że nie zabraknie numerów wersji! Wiele zmian nie stanowi problemu. Możesz popełnić dziesięć razy częściej niż facet z sąsiedztwa i wcale nie zwiększysz swojego śladu węglowego.

Pojedyncza funkcja lub metoda powinna mieć nazwę tego, co robi, a jeśli nazwa jest za długa, robi zbyt wiele. Próbuję zastosować tę samą regułę do zameldowania: komentarz dotyczący zameldowania powinien dokładnie opisywać, co dokonuje się zmiana, a jeśli komentarz jest za długi, prawdopodobnie zmieniam zbyt wiele naraz.

Podoba mi się ten mały artykuł Jeffa Atwooda: Zaewidencjonuj wcześnie, zamelduj się często

Osobiście zatwierdzam każdą logiczną grupę kodu, która jest skończona / stabilna / kompiluje i staram się nie opuszczać dnia bez popełniania tego, co zrobiłem tego dnia.

Jeśli dokonujesz poważnych zmian i obawiasz się, że możesz wpłynąć na inne osoby pracujące nad kodem, możesz utworzyć nową gałąź, a następnie scalić się z powrotem do linii głównej po zakończeniu zmian.

Zobowiązuję się za każdym razem, gdy skończę z zadaniem. Zwykle zajmuje to od 30 minut do 1 godziny.

Jeśli komentarz kontroli wersji jest dłuższy niż jedno lub dwa zdania, prawdopodobnie nie popełniasz wystarczająco często.

Podążam za mantrą open source (parafrazowaną) - wcześnie popełnia, często popełnia.

Zasadniczo za każdym razem, gdy wydaje mi się, że dodałem użyteczną funkcjonalność (nawet niewielką) bez problemów innych członków zespołu.

Ta strategia częstego zatwierdzania jest szczególnie przydatna w środowiskach ciągłej integracji, ponieważ umożliwia testowanie integracji pod kątem innych działań programistycznych, umożliwiając wczesne wykrycie problemów.

Nie zatwierdzaj kodu, który tak naprawdę nie działa. Nie używaj swojego repozytorium jako rozwiązania do tworzenia kopii zapasowych.

Zamiast tego wykonaj kopię zapasową niekompletnego kodu lokalnie w sposób zautomatyzowany. Time Machine dba o mnie, a na innych platformach jest mnóstwo darmowych programów.

Zasadą, której używam, jest odprawa, gdy grupa plików do odprawy może być objęta jednym komentarzem odprawy.

Zasadniczo ma to na celu zapewnienie, że zameldowania będą miały charakter atomowy i że komentarze mogą zostać łatwo przetrawione przez innych programistów.

Jest to szczególnie prawdziwe, gdy zmiany wpływają na plik konfiguracyjny (taki jak plik kontekstowy wiosny lub plik konfiguracyjny struts), który ma szeroki zakres aplikacji. Jeśli wprowadzisz kilka „grup” zmian przed zalogowaniem, ich wpływ nakłada się na plik konfiguracyjny, powodując scalenie dwóch grup.

Nie sądzę, żebyś tak bardzo martwił się tym, jak często. Ważne jest tutaj, co, kiedy i dlaczego. Mówienie, że musisz dokonywać co 3 godziny lub co 24 godziny, naprawdę nie ma sensu. Zobowiązuj się, gdy masz coś do popełnienia, nie rób tego, jeśli nie masz.

Oto fragment moich zalecanych najlepszych praktyk w zakresie kontroli wersji :

[...] Jeśli wprowadzasz wiele zmian do projektu w tym samym czasie, podziel je na logiczne części i zatwierdź w wielu sesjach. To znacznie ułatwia śledzenie historii poszczególnych zmian, co pozwoli Ci zaoszczędzić dużo czasu, gdy będziesz próbować znaleźć i naprawić błędy później. Na przykład, jeśli wdrażasz funkcję A, B i C i naprawiasz błąd 1, 2 i 3, to powinno dać w sumie co najmniej sześć zatwierdzeń, po jednym dla każdej funkcji i jeden dla każdego błędu. Jeśli pracujesz nad dużą funkcją lub przeprowadzasz rozbudowane refaktoryzacje, rozważ podzielenie pracy na jeszcze mniejsze części i dokonaj zatwierdzenia po zakończeniu każdej części. Ponadto przy wdrażaniu niezależnych zmian w wielu modułach logicznych zatwierdzaj zmiany do każdego modułu osobno, nawet jeśli są one częścią większej zmiany.

Najlepiej, aby nigdy nie wychodzić z biura z niezatwierdzonymi zmianami na dysku twardym. Jeśli pracujesz nad projektami, w których zmiany wpłyną na inne osoby, rozważ użycie oddziału do zaimplementowania zmian i scalenia ich z powrotem do magistrali po zakończeniu. Wprowadzając zmiany w bibliotekach lub projektach, od których zależą inne projekty, a tym samym inne osoby, upewnij się, że nie złamiesz ich kompilacji, wprowadzając kod, który nie będzie się kompilował. Jednak posiadanie kodu, który się nie kompiluje, nie jest wymówką, aby uniknąć popełnienia błędu. Zamiast tego użyj gałęzi. [...]

Twój obecny wzór ma sens. Pamiętaj, w jaki sposób korzystasz z tej kontroli źródła: co zrobić, jeśli musisz wycofać lub chcesz zrobić różnicę? Fragmenty, które opisujesz, wydają się w tych przypadkach dokładnie właściwą różnicą: diff pokaże dokładnie, co zmieniło się przy implementacji błędu # (określonego w logu kontrolnym), lub dokładnie, jaki nowy kod był dla implementacji funkcji. Podobnie wycofanie dotknie tylko jednej rzeczy na raz.

Lubię też angażować się po zakończeniu pracy, która często jest kilka razy dziennie. Myślę, że łatwiej jest zobaczyć, co dzieje się w małych zobowiązaniach niż w dużych. Jeśli martwisz się zbyt dużą liczbą zatwierdzeń, możesz rozważyć utworzenie gałęzi i scalenie jej z powrotem do linii głównej, gdy cała funkcja zostanie zakończona.

Oto powiązany post na blogu: Coding Horror: Check In Ear, Check In Często

Jak powiedzieli inni, spróbuj zatwierdzić jedną logiczną porcję, która jest „kompletna” na tyle, aby nie przeszkadzała innym programistom (np. Buduje i przechodzi testy automatyczne).

Każdy zespół / firma deweloperów musi zdefiniować, co jest „wystarczająco kompletne” dla każdego oddziału. Na przykład, możesz mieć gałęzie funkcji, które wymagają jedynie zbudowania kodu, Trunk, który również wymaga kodu, aby przejść automatyczne testy oraz etykiety wskazujące, że coś przeszło testy kontroli jakości ... lub coś w tym rodzaju.

Nie twierdzę, że jest to dobry wzorzec do naśladowania; Podkreślam tylko, że sposób wykonania „zależy” od zasad Twojego zespołu / firmy.

Moment, kiedy o tym pomyślisz.

(o ile to, co zameldujesz, jest bezpieczne)

Zależy od systemu kodu źródłowego i tego, co jeszcze masz. Jeśli korzystasz z Git, potwierdź za każdym razem, gdy zakończysz krok. Używam SVN i lubię zatwierdzać, kiedy skończę całą funkcję, więc co godzinę do pięciu godzin. Gdybym używał CVS, zrobiłbym to samo.

Zgadzam się z kilkoma odpowiedziami: nie wpisuj kodu, który się nie skompiluje; skorzystaj z osobistego oddziału lub repozytorium, jeśli masz obawy związane z „kopią zapasową” kodu lub jego zmian; sprawdź, kiedy jednostki logiczne są kompletne.

Inną rzeczą, którą chciałbym dodać, jest to, że w zależności od środowiska, stawka odprawy może się zmieniać w czasie. Na przykład wczesne sprawdzenie projektu po ukończeniu każdego funkcjonalnego elementu komponentu ma sens zarówno dla bezpieczeństwa, jak i historii zmian (myślę o przypadkach, w których wcześniejsze bity są refaktoryzowane, gdy są opracowywane późniejsze). Z drugiej strony w dalszej części projektu ważniejsza staje się całkowicie pełna funkcjonalność, szczególnie podczas opracowywania / testowania integracji. Połowa integracji lub połowa poprawki nikomu nie pomaga.

Jeśli chodzi o odprawę po każdej naprawie błędu: absolutnie, chyba że poprawka jest trywialna! Nic nie jest bardziej uciążliwe niż stwierdzenie, że jedno zameldowanie zawierało trzy poprawki, a jeden z nich należy wycofać. Najczęściej wydaje się, że w tej sytuacji deweloper naprawił trzy błędy w jednym obszarze i odwijał, która zmiana dotyczy tego, która poprawka jest koszmarem.

Lubię też regularnie się zameldować. To jest za każdym razem, gdy mam krok do celu.

Zazwyczaj jest to co kilka godzin .

Moja trudność polega na znalezieniu kogoś, kto byłby w stanie przeprowadzić tak wiele recenzji kodu .

Zgodnie z naszą polityką firmy musimy dokonać przeglądu kodu, zanim będziemy mogli cokolwiek sprawdzić, co ma sens, ale nie zawsze w dziale jest ktoś, kto ma czas na natychmiastowe sprawdzenie kodu. Możliwe rozwiązania:

1. Więcej pracy na odprawę; mniej meldunków == mniej recenzji.
2. Zmień zasady odprawy firmy. Jeśli właśnie dokonałem refaktoryzacji, a testy jednostkowe są zielone, to może uda mi się złagodzić regułę?
3. Odłóż zmianę na później, aż ktoś będzie mógł dokonać przeglądu i kontynuować pracę. Może to być problematyczne, jeśli recenzentowi nie podoba się kod i trzeba go przeprojektować. Żonglowanie różnymi etapami zadania poprzez zmiany „odkładania” na półce może stać się bałaganem.

Lubię zatwierdzać zmiany co 30-60 minut, o ile kompiluje się czysto i nie ma regresji w testach jednostkowych.

Cóż, możesz mieć własną gałąź, do której możesz przypisać tak często, jak chcesz, a kiedy skończysz z funkcją, możesz połączyć ją z głównym pniem.

Jeśli chodzi o częstotliwość Commits, myślę o tym w ten sposób, ile by mnie bolało, gdyby mój twardy dysk się zepsuł i nie popełniłem czegoś - kwant tego czegoś dla mnie to około 2 godzin pracy.

Oczywiście nigdy nie popełniam czegoś, co się nie skompiluje.

Przynajmniej raz dziennie.

Nie mam określonego limitu czasu na zatwierdzenie, zwykle zatwierdzam po przejściu testu i jestem zadowolony z kodu. Nie zatwierdziłbym; t kodu, który się nie kompiluje lub jest w innym stanie, w którym nie czułbym się dobrze po powrocie w razie awarii

Musisz zrównoważyć kompromis między bezpieczeństwem i możliwościami odzyskiwania z jednej strony, a łatwością zarządzania zmianami dla całego projektu z drugiej.

Najlepszy schemat, jaki zastosowałem, ma dwie odpowiedzi na to pytanie.

Użyliśmy 2 całkowicie oddzielnych repozytoriów: jedno było repozytorium dla całego projektu, a drugie było naszym osobistym repozytorium (wówczas korzystaliśmy z rcs).

Regularnie sprawdzaliśmy nasze osobiste repozytorium, prawie za każdym razem, gdy zapisywałeś otwarte pliki. Jako takie osobiste repozytorium było zasadniczo dużym, dalekosiężnym buforem cofania.

Gdy mieliśmy kawałek kodu, który można skompilować, przetestowaliśmy ok i został zaakceptowany jako gotowy do ogólnego użytku, został sprawdzony w repozytorium projektu.

Niestety system ten polegał na wykorzystaniu różnych technologii VCS, aby był wykonalny. Nie znalazłem zadowalającej metody osiągnięcia tych samych wyników przy użyciu dwóch VCS tego samego typu (np. Dwa repozytoria subversion)

Jednak uzyskałem akceptowalne wyniki, tworząc „osobiste” gałęzie programistyczne w repozytorium subversion - regularnie sprawdzając gałąź, a następnie łącząc się z bagażnikiem po zakończeniu.

Jeśli pracujesz nad oddziałem, który nie zostanie zwolniony, zatwierdzenie jest zawsze bezpieczne.

Jeśli jednak udostępniasz go innym programistom, popełnienie niedziałającego kodu może być nieco denerwujące (szczególnie jeśli znajduje się w ważnym miejscu). Zwykle zatwierdzam tylko kod, który faktycznie „działa” - nie dlatego, że został w pełni przetestowany, ale upewniłem się, że faktycznie się kompiluje i nie kończy natychmiast.

Jeśli używasz zintegrowanego narzędzia do śledzenia błędów, pomocne może być wykonanie osobnych zatwierdzeń, jeśli naprawiłeś dwa błędy, aby dziennik zatwierdzeń mógł być zgodny z odpowiednimi błędami. Ale z drugiej strony, czasami jedna zmiana kodu naprawia dwa błędy, więc musisz po prostu wybrać, przeciwko któremu chcesz go usunąć (chyba że twój system pozwala jednemu zatwierdzić powiązanie z wieloma błędami)

Nadal wierzę w zwrot „popełnij często, popełnij wcześnie”. Wolę zdecentralizowane VCS jak Mercurial i nie ma problemu, aby popełnić kilka rzeczy i przesunąć je później.

To jest naprawdę częste pytanie, ale prawdziwe pytanie brzmi: czy możesz popełnić niedokończony kod?

Ilekroć skończysz jakiś kod, który działa i nie spieprzy nikogo, jeśli dostanie go w aktualizacji.

I upewnij się, że odpowiednio skomentowałeś