Co powinienem zrobić, gdy już zbyt długo czekałem między zatwierdzeniami?

100

Byłem niegrzeczny ... Za dużo „kodowania kowbojów”, za mało popełniania. Teraz jestem z ogromnym zobowiązaniem. Tak, powinienem był cały czas się angażować, ale teraz jest już za późno.

Co jest lepsze?

  1. Zrób jeden bardzo duży zatwierdzenie, wymieniając wszystkie rzeczy, które zmieniłem
  2. Spróbuj podzielić go na mniejsze zatwierdzenia, które prawdopodobnie się nie skompilują, ponieważ pliki zawierają wiele poprawek, zmian, dodatkowych nazw metod itp.
  3. Spróbuj wykonać częściowe odwracanie plików tylko dla odpowiednich zatwierdzeń, a następnie odłóż nowe zmiany z powrotem.

Uwaga: w tej chwili jestem jedynym programistą pracującym nad tym projektem; jedyną osobą, która spojrzy na te komentarze, są ja, przynajmniej dopóki nie zatrudnimy większej liczby programistów.

Przy okazji: używam SVN i Subclipse. Utworzyłem nowy oddział przed wprowadzeniem tych zmian.

Więcej informacji : zadałem osobne pytanie dotyczące tego, jak dostałem się do tej sytuacji: jak przygotować się do przepisania kleju aplikacji

durron597
źródło
2
Jakiego programu do kontroli wersji używasz? Wiele posiada moduły, które pozwalają ci rozbijać swoje edycje na „przystojniaki”, tj. Grupy zmodyfikowanych linii, które pozwolą ci grupować swoje edycje w dowolny sposób i dystrybuować mody jednego pliku do kilku zestawów zmian. Np. Merkurial ma rozszerzenie „półka”. Oczywiście nadal powinieneś sprawdzić, czy każda partia zmian się kompiluje, jeśli ma to znaczenie dla Twojego procesu. To, czy wszystko jest warte kłopotu, zależy od Ciebie i Twojego sklepu.
Alexis
6
Przynajmniej sprawdź to w oddziale, aby nie stracić zmian.
Rory Hunter
2
Możesz zadawać sobie pytanie i czekać jeszcze dłużej, albo faktycznie popełnić i poradzić sobie z każdym bałaganem, który powoduje ... A potem ... nie rób tego więcej!
haylem
40
# 1, módlcie się o przebaczenie, a potem idźcie dalej i już więcej nie
grzeszcie
5
Ważniejszym pytaniem, które powinieneś sobie zadać, jest: „jak zmienić swoje złe nawyki, aby zapobiec ponownemu wystąpieniu”. Nie powinno być żadnego powodu, aby nie popełnić przynajmniej raz dziennie, lepiej częściej.
Doc Brown

Odpowiedzi:

52

Aby odpowiedzieć, musisz zadać sobie pytanie, w jaki sposób zamierzasz wykorzystać wyniki tych zmian w przyszłości. Najczęstsze przyczyny to:

  • Aby zobaczyć, w jakiej wersji wprowadzono błąd.
  • Aby zobaczyć, dlaczego obecny jest określony wiersz kodu.
  • Aby połączyć się w inną gałąź.
  • Aby móc sprawdzić poprzednią wersję w celu rozwiązania problemu, który klient lub tester widzi w tej wersji.
  • Aby móc uwzględnić lub wykluczyć niektóre części z wydania.

Dwa pierwsze powody mogą być obsługiwane równie dobrze za pomocą jednego dużego zameldowania, przy założeniu, że możesz utworzyć komunikat odprawy, który będzie równie dobrze pasował do każdej linii zmienionego kodu. Jeśli jesteś jedynym programistą, mniejsze zatwierdzenia nie ułatwią ci scalenia. Jeśli nie planujesz robić wydania lub testowania tylko z częścią nieprzesłanych zmian, dwa ostatnie powody nie mają zastosowania.

Są inne powody dokonywania małych zatwierdzeń, ale dzieje się tak, gdy jesteś w trakcie zmian, a ten czas już minął. Powody te ułatwiają wycofanie się z pomyłki lub eksperymentalnej zmiany oraz ułatwiają synchronizację z kolegami bez ogromnych przerażających połączeń.

Z mojego rozumienia twojej sytuacji, którą opisałeś, wydaje się, że podzielenie twojego zatwierdzenia w tym momencie nie ma żadnej korzyści.

Karl Bielefeldt
źródło
Doskonała odpowiedź! Chociaż nie mniej żałuję, że nie popełniłem małych błędów, czuję się o wiele lepiej, co powinienem zrobić, aby przywrócić dobre zachowanie tak produktywnie, jak to możliwe.
durron597
1
Inną rzeczą w przypadku 3 i 5 jest to, że każda praca, którą wykonujesz teraz, aby na nią pozwolić, może poczekać, aż rzeczywiście będziesz jej potrzebować, a następnie wykonaj tę samą pracę. W przyszłości będzie to prawdopodobnie trudniejsze, ponieważ pamięć o tym, co zrobiłeś, zniknęła. Ale z drugiej strony prawdopodobnie nigdy tego nie będziesz potrzebować.
Steve Jessop
Z mojego doświadczenia wynika, że ​​opieranie się na komentarzach kontroli wersji, by opowiedzieć historię, dlaczego kod istnieje (tj. Przyczyny 1 i 2), jest kruche i kruche. Jeśli używasz SVN z odgałęzieniem, historia zatwierdzeń i tak zostanie utracona podczas scalania (lepiej będzie w przypadku bardziej nowoczesnych rzeczy, takich jak git). Więc najlepiej IMHO z komentarzami.
Hans-Peter Störr
1
@ hstoerr - jeśli korzystasz z Subversion 1.5 lub nowszej, możesz zachować historię dzięki opcji --reintegrate po scaleniu.
Dustin Kendall
1
git add -p jest tutaj twoim najlepszym przyjacielem. Zakochałem się w tej funkcji. W ten sposób mogę zatwierdzić moje standardowe modyfikacje kodowania w osobnych zatwierdzeniach i zachować odpowiednie zmiany kodu w izolacji.
Spidey
39

Myślę, że cokolwiek zrobisz, staraj się unikać wpisywania kodu, o którym wiesz, że się nie skompiluje.

Jeśli uważasz, że twoja trzecia opcja jest wykonalna, może to być dobry sposób na zrobienie tego, o ile możesz upewnić się, że sekwencja zatwierdzeń nie stworzy niemożliwego do kompilacji systemu. W przeciwnym razie po prostu wykonaj jedną dużą zmianę. To brzydkie, ale proste, szybkie i gotowe. Idąc dalej, dokonuj częściej .

FrustratedWithFormsDesigner
źródło
Opcja trzecia jest możliwa, ale byłaby niezwykle czasochłonna. Myślę, że zamierzam zrobić opcję 1
durron597
3
Jakie są wady popełnienia kodu, który nie skompiluje się ani nie zbuduje w gałęzi funkcji (lub podobnej), który jest tak okropny, że zmusza kogoś do unikania robienia tego „cokolwiek robi”? Wyobrażam sobie, że inni mogliby uniknąć naprawdę okropnych zobowiązań, co jest jedynym prawdziwym powodem, dla którego unikałem ich w pierwszej kolejności (zakładając oczywiście, że nie zostały wydane ).
Kenny Evitt
3
„Uniknąć kontroli w kodzie, który nie zostanie skompilowany” odnosi się tylko do udostępnionego kodu bazowego / oddziału. W przypadku projektu jednoosobowego lub jednoosobowej gałęzi rozwoju uważam, że ważniejsze jest, aby wprowadzić zmiany do VC, aby nie stracić rzeczy.
Stephen C
3
@StephenC na przykład, ponieważ łamie narzędzia takie jak git-bisect. Jeśli kod kompiluje się / działa przez cały czas i trzeba znaleźć regresję, jeśli się kompiluje przez cały czas, możesz po prostu wyszukiwać binarnie (nie wspominając, że jeśli regresja jest w części kodu, masz dużą zmianę do czytania zamiast zawężania to w dół).
Maciej Piechotka
@MaciejPiechotka - Cóż, oczywiście jeśli potrzebujesz specjalnych narzędzi w swoich prywatnych oddziałach, a one wymagają kompilacji kodu, zrób to. Ale to nie jest typowe dla jednoosobowego projektu / oddziału.
Stephen C
19

Najważniejszym powodem dokonywania częstych, małych i znaczących zmian jest pomoc w zrozumieniu historii kodu. W szczególności bardzo trudno jest zrozumieć, jak zmienił się kod, jeśli trudno jest wygenerować zrozumiałe różnice.

Opcja 1 zaciemnia historię wprowadzonych zmian, ale w przeciwnym razie nie spowoduje żadnych problemów.

Opcja 2 zaciemnia historię dokonanych zmian, być może nieco mniej niż opcja 1, ale może powodować inne problemy dla ciebie lub innych, jeśli założą oni lub w inny sposób stwierdzą, że zatwierdzenia są różne, np. Mogą zostać niezależnie połączone z innymi gałęziami. O ile nie istnieje silny praktyczny powód, dla którego jest to preferowane w porównaniu z opcją 1, jest to mniej idealne niż to.

Opcja 3 jest najlepsza, wszystkie pozostałe są równe, ale jeśli, jak opisano w innym miejscu, zrobienie tego wymagałoby „ekstremalnych” ilości czasu lub pociągnęłoby za sobą inne znaczące koszty, będziesz musiał porównać te koszty z oczekiwanymi korzyściami tworzenie czystszych zatwierdzeń.

W oparciu o informacje, które podałeś, wybrałbym opcję 1. Może powinieneś skonfigurować przypomnienia z prośbą o zatwierdzenie zmian?

Prototypowanie i przepisywanie

Kolejną kwestią, o której należy pamiętać, szczególnie w świetle notatki o byciu jedynym programistą oraz mojego podejrzenia, że ​​pracujesz nad stosunkowo nową bazą kodu, jest to, że prawdopodobnie dobrze jest rozwinąć różne nawyki dotyczące dokonywania zmian w przypadku „prototypowanie nowego kodu w porównaniu z utrzymywaniem lub rozszerzaniem istniejącego kodu. Prawdopodobnie nie ma strasznie ostrego podziału między nimi, ale myślę, że nadal jest to użyteczne rozróżnienie.

Kiedy prototypujesz nowy kod, zatwierdzaj, kiedy chcesz zapisać zmiany, prawie na pewno w oddziale, ale być może w osobnym projekcie. A może nawet całkowicie działają poza kontrolą wersji. Zamiast tego możesz skupić się na gromadzeniu dowodów na temat wykonalności różnych hipotez lub projektów, które rozważasz. Często piszę małe prototypy przy użyciu różnych narzędzi, np. LINQPad zamiast Visual Studio for C #.

Po zweryfikowaniu konkretnej hipotezy lub projektu, przepisz ją w głównym projekcie, najlepiej w oddziale, i wykonaj małe, znaczące zatwierdzenia, które najlepiej pomogą zrozumieć inne (w tym ciebie w przyszłości), co do charakteru zmian robisz.

Kenny Evitt
źródło
1
Dobra odpowiedź; Kenny, czy masz dobry artykuł lub inną bazę wiedzy, aby połączyć się z bardziej szczegółowymi szczegółami na temat prototypowania? Moja wersja prototypowania to „szkic w notatniku lub na tablicy”
durron597,
@ durron597, nie mogę wymyślić żadnych linków (nawet w poszukiwaniu) z góry mojej głowy. Bawiłem się z wystarczającą ilością interpretowanych (i dynamicznie kompilowanych) języków programowania, że ​​nawet nie myślałem, że pomysł „prototypowania” może być nowy! I przepisałem tak wiele programów C, C ++ i Java (raz po raz), że nie sądziłem, że może to być również rzadkie lub przynajmniej dla niektórych nowatorskie.
Kenny Evitt
12

Chociaż jedyną rozsądną odpowiedzią jest to, aby nigdy nie łamać bagażnika , czasami nie jest to możliwe. Na przykład, svn może przerwać zatwierdzanie, jeśli popełnisz zbyt dużo (być może opcja lub funkcja, nie jestem pewien). W takich szczególnych przypadkach wystarczy zameldować się w częściach. Ponieważ jesteś jednym programistą, nikomu to nie będzie przeszkadzać.

Dlatego wybrałbym opcję 1. Jeśli nie jest to możliwe, wybierz opcję 2.

Opcja 3 wymaga dużego wysiłku i po prostu nie jest tego warta.

BЈовић
źródło
1
lub oznacz wersje niekompilujące jako „NIE KOMPILUJE”
maniak ratchet
2
@ratchetfreak: Wydaje mi się, że „tag” w SVN niewiele pomoże, ponieważ tagi nie działają jako „komentarze” na linii głównej.
Doc Brown
@DocBrown Miałem na myśli dodanie go do wiadomości zatwierdzenia
maniak ratchet
5
@ratchetfreak Zrobiłbym to jako „CZĘŚĆ X / N: sprawdzanie w ABC
NIE KOMPILUJE
Opcja 3 nie wymaga dużego wysiłku. Inna odpowiedź wyjaśnia, jak to zrobić szybko i łatwo za pomocą git add --patchi git stash. Sytuacja wydaje się trudna tylko z powodu przestarzałych narzędzi i wiedzy na temat kontroli źródła.
Ron MacNeil
7

Spróbuj podzielić go na mniejsze zatwierdzenia, które prawdopodobnie się nie skompilują, ponieważ pliki zawierają wiele poprawek, zmian, dodatkowych nazw metod itp.

Kiedy znalazłem się w podobnej sytuacji, zastosowałem następującą technikę:

  1. Dodaj tylko kod odpowiedni dla konkretnej funkcji: git add --patch
  2. Ukryj wszystkie inne zmiany: git stash save --keep-index
  3. Uruchom testy / spróbuj skompilować
  4. Zatwierdź zmiany, jeśli wszystko jest w porządku, jeśli nie, przejdź do 1

Nie znam SVN, więc nie wiem, czy dotyczy to konkretnej sytuacji, ale podstawa powinna być taka sama - izoluj małe części kodu i testuj je indywidualnie.

Milos
źródło
Podoba mi się to, ale niestety jedną z wielu rzeczy na mojej liście rzeczy do zrobienia (jest wiele, gdy jesteś jedynym facetem technicznym w firmie) to przejście z SVN na git, a ja po prostu jeszcze się do tego nie załatwiłem .
durron597
1
Ponieważ nie jestem wystarczający do użycia --patch, używam Cofnij w różnych oknach edytora, aby przejść do wcześniejszych stanów roboczych i zatwierdzić je. Następnie powtarzam do następnego zatwierdzenia. Ze względu na pokusę wprowadzania niewielkich dodatków do kodu w stanie Cofnię zawsze wykonuję kopię zapasową przed rozpoczęciem tego procesu!
joeytwiddle
Z git możesz także dodawać interaktywnie (dodawać -i) przed zatwierdzeniem i rozgałęziać później, aby niezależnie zweryfikować swoje zatwierdzenia.
riezebosch
3

Co powiesz na opcję 4: Wykonaj kopię zapasową bieżącego stanu repozytorium w tymczasowym miejscu, przywróć repozytorium do jego pierwotnego stanu, zrób listę wszystkich dokonanych zmian (nadal możesz spojrzeć na tymczasową kopię zapasową), a następnie ręcznie wykonaj ponowną implementację (i skompiluj i przetestujcie!) jako osobne zatwierdzenia.

Powinno to być łatwiejsze, ponieważ kod został już napisany, wystarczy dowiedzieć się, które części skopiować i wkleić z tymczasowej kopii zapasowej.

Po ponownym zaimplementowaniu każdej zmiany w sposób czysty, a tym samym upewnieniu się, że zatwierdzenia są niezależne, małe i kompilowane, możesz usunąć tymczasową kopię zapasową, a wszystko będzie prawie dokładnie tak, jak (oprócz czasu / daty zatwierdzeń) byłoby, gdybyś zrobił to od samego początku.

Superbest
źródło
To tylko sposób na wykonanie opcji nr 3. Prawdopodobnie najlepszy sposób, prawda, ale wciąż dość czasochłonny.
durron597
Kiedy zrobiłem jedną dużą zmianę, było 149 linii dodawania / usuwania / wysyłania wiadomości. To co najmniej pół dnia, aby to zrobić.
durron597
@ durron597 Nie zgadzam się, myślę, że różni się to od # 3. Jeśli chodzi o 149 wierszy, ile cenisz czystą historię zatwierdzeń? Czy warto spędzić pół dnia? W każdym razie, nie jest tak, że inne metody nie będą wymagały ustalenia, która linia powinna być w którym zatwierdzeniu, więc będziesz musiał przejść przez 149 linii w obu kierunkach. Różnica w czasie będzie niewielka.
Superbest
Heh Mam wystarczająco dużo doświadczenia, aby wiedzieć, jak korzystać z kontroli wersji, ale nie mam wystarczającego doświadczenia, aby kiedykolwiek uratować mój tyłek :) Więc praktyczne powody robienia rzeczy są wciąż trochę naukowe, jeśli wiesz o co mi chodzi.
durron597
Nie musisz tworzyć kopii zapasowej całego repozytorium . Możesz wykonać zatwierdzenie „kopii zapasowej”, a następnie przywrócić HEAD za pomocą git reset HEAD~. Twoje zatwierdzenie będzie nadal obowiązywać, git reflogjeśli zdecydujesz, że będziesz go później potrzebować. Możesz nawet rozwidlić gałąź (a następnie przejść z powrotem do działającej gałęzi) przed wykonaniem resetu, aby nadać swojej nazwie „kopia zapasowa”. Usuń gałąź później, jeśli jej nie potrzebujesz. Edycja: Niestety nie zdałem sobie sprawy, że OP działa na svn!
joeytwiddle
3

Jesteś jedynym programistą; po prostu wykonaj jedną masową odprawę, szczegółowo opisując ważne fragmenty tego, co zrobiłeś.

Czy prawdopodobnie wycofasz „części” tego, co zrobiłeś? Jeśli nie, koniecznie przejdź do opcji 1.

Istnieje kilka powodów, aby sprawdzić kod w systemie kontroli wersji. I WSZYSTKIE z nich, gdy jesteś jedynym programistą, obracają się wokół bezpieczeństwa - mianowicie, jeśli spieprzysz, maszyna umrze lub cokolwiek innego, zawsze możesz wrócić do tego ostatniego punktu kontrolnego.

Programiści wchodzący później do projektu raczej nie chcą przywracać wersji, która się nie kompiluje. Tak więc, IMHO, opcja 2 to szaleństwo.

Opcja 3 brzmi jak taki czas, że gdybym był twoim szefem i zobaczył, że marnujesz godziny na robienie tego, porozmawiam z tobą o tym, ile twój czas jest wart.

Aby iterować: sprawdzając kod, zakrywasz / zapisujesz tyłek w przypadku awarii na twoim komputerze. Wszystko inne, w jednoosobowym zespole, to ozdoby do okien.

Nie ja
źródło
1
Wycofywanie nie jest jedynym powodem, aby używać małych zatwierdzeń. To nawet nie jest szczególnie dobry powód. Głównym powodem jest to, aby zobaczyć, kiedy i dlaczego wprowadzono zmianę, oraz ułatwić rozwiązywanie problemów, gdy napotykasz problem niewiadomego pochodzenia. Kolejny programista przychodzi do projektu później prawie na pewno będzie przynajmniej od czasu do czasu spotkać linii kodu, które sprawiają mu odejść „WTF” i odesłać do zatwierdzenia, gdzie po raz pierwszy w formie pisemnej lub ostatniej modyfikacji. Jeśli to zatwierdzenie jest jednym wielkim zatwierdzeniem zmieniającym 500 rzeczy, niemożliwe jest uzyskanie jakichkolwiek użytecznych informacji z historii.
Aaronaught
Nawiasem mówiąc, właśnie dlatego zespoły korzystające z Git zazwyczaj nienawidzą zatwierdzania scalania i zamiast tego żądają / wymagają rebase; scalanie zatwierdza przerwanie bisecti inne techniki powszechnie stosowane do izolowania problemów, ponieważ tak wiele zmian jest umieszczonych w jednym wielkim zatwierdzeniu.
Aaronaught
1
Na poziomie osobistym zgadzam się, że nie powinieneś robić dużych zmian, chyba że radykalnie zmienisz bazę kodu. W tym momencie powinieneś ją rozgałęzić. Mówimy jednak o jednym programiście, który działał w zasadzie odłączony i teraz próbuje wrócić do robienia właściwych rzeczy. W takim przypadku uważam, że lepsze jest jedno duże zatwierdzenie.
NotMe
1
@Aaronaught Dodałbym, że sam 3 miesiące później może stanowić „inny programista”.
Maciej Piechotka
1
Muszę się też nie zgodzić z rozgałęzianiem jako realną strategią zmian architektonicznych lub innych zmian „destrukcyjnych”. To po prostu prowadzi do koszmaru konfliktów scalania i błędów po scaleniu. W dłuższej perspektywie znalezienie sposobu na rozbicie głównej zmiany na mniejsze, kompatybilne wstecz, jest o wiele mniej bolesne lub, w najgorszym przypadku, użycie tego, co Fowler, Humble i reszta nazywają Oddziałem Według abstrakcji (która w rzeczywistości nie jest wcale gałęzią). Obie te strategie zakładają małe i skoncentrowane zobowiązania.
Aaronaught
2

Moja zasada brzmi: brak odprawy bez poważnego przeglądu kodu. Jeśli jestem sam, będę musiał przejrzeć kod, ale zostanie sprawdzony. Wygląda na to, że wprowadzono wiele zmian w kodzie, których nie mógł sprawdzić ktoś inny, dlatego nie można go przejrzeć samodzielnie (sprawdzenie własnego kodu jest trudniejsze i wymaga większej dyscypliny, ponieważ automatycznie przyjmuje się błędne założenie, że własny kod jest poprawny ).

Całkowicie nie do złamania jest zasada, że: Nigdy nie melduj kodu, który nawet się nie buduje, i poważnie unikaj meldowania się kodu, który nie działa.

Rozwiązanie: Skopiuj zmieniony kod i wróć do pierwotnego punktu. Scalaj jedną zmianę na raz z oryginalnym kodem, przeglądaj go, testuj, sprawdzaj. Za pomocą opisanej metody programowania na pewno znajdziesz w ten sposób poważne błędy.

To także dobry sposób na ćwiczenie dobrych nawyków programistycznych.

gnasher729
źródło
Jest to logicznie to samo, co odpowiedź oparta na Git powyżej ( git add --patchi git stash) i dobry przykład scenariusza, z którym nowoczesne DVCS mogą sobie łatwo poradzić, ale starsze systemy nie.
Ron MacNeil
1

Myślę, że zbytnio się martwisz. Jeśli jesteś jedynym programistą i nie masz arkusza specyfikacji, na którym możesz pracować, to od Ciebie zależy, co zrobisz. Zakładam, że nikt nie będzie cię karać za dokonanie dużego zatwierdzenia, więc jedyne problemy, na które się natkniesz, są technologiczne, takie jak niemożność wycofania indywidualnych zmian plików w zatwierdzeniu. Ponieważ w tej chwili masz wyłączną kontrolę nad repozytorium, nie powinno to stanowić większego problemu.

Należy oddzielić pragmatyzm od dogmatyzmu. To, co zrobiłeś, nie byłoby dobrym pomysłem w zespole i prawdopodobnie nie powinno być powtarzane w przyszłości, ale w twojej sytuacji po prostu poddałbym się dużemu zatwierdzeniu.

Roy
źródło
1
wydaje się, że nie dodaje to nic znaczącego w stosunku do tego, co zostało już opublikowane w poprzednich 12 odpowiedziach
komnata
-1

Problemem nie są duże opóźnienia między zatwierdzeniami, ale fakt, że kod utrzymuje się zbyt długo w stanie niemożliwym do kompilacji. Po pierwsze, jaka jest twoja definicja „długiego”? Dla niektórych osób 5 minut na przejście w stan przejściowy to za dużo, ale niektórzy mogą wypolerować swój kod na kilka dni, nawet nie próbując uruchomić kompilatora.

W rzeczywistości nie ma to znaczenia - ważne jest to, że straciłeś kontrolę nad kodem, kod stał się niemożliwy do zarządzania. Jest to normalne, oznacza to po prostu, że masz dług technologiczny i czas pomyśleć o refaktoryzacji. Jesteś sfrustrowany? Twój kod się nie kompiluje, nawet nie masz testów jednostkowych? Jak możesz myśleć o refaktoryzacji w tym przypadku? Bez obaw. Zakończ „kodowanie kowboja” i zacznij go czyścić. Najlepiej spróbuj napisać kilka testów. Nie masz na to czasu? Ok, zacznij od drobnych ulepszeń.

Niektóre zmiany nie wymagają testów. Zmień nazwę zmiennej, aby była bardziej odpowiednia, przenieś powtarzalny kod do oddzielnej funkcji itp. Dostaniesz lepszy obraz swojego kodu. Następnie możesz wprowadzać większe zmiany. Ponownie spróbuj napisać testy, jeśli to możliwe. Uczyń swój kod zarządzalnym.

Następnie zobaczysz, że następna zmiana nie zajmie ci „zbyt długo” (cokolwiek to znaczy).

AlexT
źródło
2
Nie powiedział, że przez długi czas utrzymywał kod niekompilowalny. Kod w repozytorium był przez długi czas niezmodyfikowany - stary, ale nadal można go kompilować. Kod w jego kopii roboczej był często aktualizowany, ale nie został zatwierdzony. Nic w tym pytaniu nie sugeruje, że jego kod może wymagać refaktoryzacji - „kodowanie kowboja” odnosi się tutaj do jego przepływu pracy SCM, a nie do rzeczywistej jakości kodu
Idan Arye
@IdanArye Z oryginalnego pytania ...Try to break it into smaller commits that likely won't compile...Jeśli coś przeszkadza w popełnieniu kodu, to już jest dobry sing, trudno jest nim zarządzać. „Zaangażowanie” to tylko jeden ze sposobów na utrwalenie pracy. Możemy pomyśleć o bardziej ekstremalnym przypadku - „jeśli coś uniemożliwi mi zapisanie pliku źródłowego”. Co to może być? Myślę, że to strach przed własnymi zmianami. Dlaczego tak może być? ... Chyba masz
rację
2
Wydaje mi się, że bardziej przeszkadzało mu lenistwo.
Idan Arye
@IdanArye Masz rację pod każdym względem. To plus brak wystarczającej ilości TDD, co jest osobnym problemem.
durron597
@AlexT rozważ scenariusz, w którym naprawiasz dwa błędy, a jeden z nich wymaga nowo opracowanej metody. Jeśli popełniłeś błąd, naprawiłeś jeden błąd, zatwierdziłeś, a następnie naprawiłeś drugi błąd. Jeśli nie, to kiedy zatwierdzasz, musisz albo uwzględnić obie zmiany w tym samym zatwierdzeniu, albo zatwierdzić pierwszą naprawę błędu ze zmianami dla drugiej, z wyjątkiem tego, że zatwierdzona wersja nie ma nowego wywołania metody, a zatem nie kompiluje się.
durron597