Czy możesz przeprowadzić ciągłe wdrażanie z młodszymi programistami?

Jest moment, w którym zaczynasz rozumieć, że w architekturze mikrousług, bardziej przerażające jest poczekanie tygodnia na wdrożenie wszystkich mikrousług na raz, aby upewnić się, że wszystko działa razem, niż ścisłe egzekwowanie wersji interfejsu API, pisanie wielu automatycznych testy (po trochu każdy: jednostka i eksploracja, integracja) oraz automatyczne wdrożenie do produkcji, gdy tylko zatwierdzenie przejdzie jako testy na scenie.

Teraz wygląda to na świetny pomysł, o ile pamiętasz pisać testy, testować zmiany przed zatwierdzeniem, wiedzieć, jak korzystać z wersji API i nie będziesz upuszczać bazy danych w skrypcie przyrostowej aktualizacji db, który jest wykonywany podczas wdrażania (który nie jest dużym problemem, ponieważ powinien zawieść na scenie).

Ale czy można to zrobić z młodszymi programistami? Może będę musiał zaimplementować schemat żądania ściągania. Czyli by to mniej przypominało ciągłe wdrażanie (tak sądzę)?

Mam nadzieję, że nie jest to oparte na opiniach i mogę liczyć na to, że podzielisz się swoim doświadczeniem, dzięki.

Uwaga: nie pytam o CI ani o ciągłą dostawę. Już to mamy. To, co próbujemy teraz, to ciągłe wdrażanie, co oznacza, że ​​wszystko będzie w produkcji tuż po odprawie kodu.

Dlaczego nie? Każda z opisywanych przez Ciebie rzeczy stanowiłaby problem bez względu na to, czy używasz ciągłego wdrażania, czy nie. Wydaje się, że problem polega na tym, że obawiasz się, że juniorzy popełnią katastrofalny błąd. I ten błąd zostanie wprowadzony do produkcji, zanim ktokolwiek go złapie.

Dlatego przeprowadzasz recenzje kodu i testujesz. Zanim cokolwiek zostanie scalone z gałęzią master i przeznaczone do wydania, należy poddać go przeglądowi kodu, zarówno przez niektórych innych juniorów (aby zdobyli doświadczenie), jak i przez starszych programistów (aby skorzystać z ich wiedzy, aby ulepszyć kod). Wszyscy powinni szukać tych katastrofalnych błędów. I to powinno ich powstrzymać. Jeśli tak się nie stanie, prawdopodobnie potrzebujesz lepszej kontroli jakości / testowania w środowisku testowym (i być może lepszych programistów, jeśli przeglądy kodu pominą te rzeczy).

Ciągłe wdrażanie będzie działać dobrze, jeśli masz dobry zestaw automatycznych testów.

Młodsi programiści mogą ekscytować się swoim własnym zadaniem i nie widzą, że coś psują. Możesz to naprawić za pomocą automatyzacji. Skonfiguruj serwer kompilacji, który będzie przeprowadzał testy przez cały czas, i zdobądź dla nich narzędzie takie jak Powiadomienie o kompilacji CatLight . Daje im szybką i jasną informację zwrotną, gdy coś psuje.

Będą naprawiać małe problemy, gdy się pojawią i utrzymają ciągłą dostawę.

Jedynym sposobem na poznanie dobrych nawyków jest ich przećwiczenie, więc tak, młodsi programiści mogą również ćwiczyć ciągłe wdrażanie. Możesz zastanowić się nad dodaniem kroków do potoku, aby wykonać takie czynności, jak sprawdzenie pokrycia testowego i być może uruchomienie analizy kodu statycznego oraz niepowodzenia kompilacji, jeśli zasięg testowy nie jest wystarczająco wysoki. To zapewni, że młodsi twórcy zrozumieją oczekiwania, zanim coś zostanie uznane za kompletne.

Nie tylko możesz to zrobić z młodszymi programistami, ale jest to wymagane od ciebie. Po pierwsze, w przeciwnym razie obniżysz jakość oprogramowania, a po drugie pomoże to młodym programistom nauczyć się dobrych umiejętności programistycznych.

Analogicznie: czy chciałbyś, aby Twój lekarz nie praktykował medycyny zgodnie z jego najlepszą wiedzą, ponieważ będzie bał się młodych błędów w przyuczaniu do zawodu? Jak lekarze radzą sobie z potencjalnymi szkodami?

W oparciu o wcześniejsze doświadczenia z bazą kodu Big Ball Of Mud, która ewoluowała naturalnie przez wiele lat z rąk wielu młodszych programistów bez nadzoru, chciałbym zwrócić uwagę na to, co się stanie, gdy nie ćwiczysz CI z tymi programistami.

Edycja / Aktualizacja : Zgodnie z komentarzem RubberDuck; w tej odpowiedzi założono, że celem scalania dla integracji jest gałąź rozwoju, a nie gałąź oceny lub wydania.

• Oczywiście musi istnieć znacznie większa kontrola nad kodem w celu wydania i wdrożenia na żywo; jeśli nie ma oddzielnej gałęzi produkcyjnej, warto rozważyć zmianę strategii rozgałęziania / scalania, aby uruchomić główną gałąź programistyczną (która służy do testowania integracji, a nigdy do wydania) obok gałęzi głównej. Zachowuje to wszystkie zalety CI i częste łączenia bez ryzyka złamania kodu produkcyjnego.

1. Młodsi programiści rzadziej komunikują się ze swoimi współpracownikami lub przełożonym

Ciągła integracja to nie tylko kwestia scalenia kodu, to moment, w którym programista jest zmuszony do interakcji z innymi interesariuszami.

Komunikacja jest ważna i bez nadmiernej uogólnienia jest to umiejętność wyuczona, która dociera mniej naturalnie do niedoświadczonych programistów niż do tych, którzy są przyzwyczajeni do pracy w środowisku zespołowym.

Jeśli pozwolisz młodym programistom siedzieć w swojej kabinie i walczyć o kod przez wiele tygodni, bez konieczności częstych raportów / recenzji, wtedy bardziej prawdopodobne jest, że całkowicie unikną komunikacji.

2. Kod, który tworzą, prawdopodobnie będzie wymagał bardziej rygorystycznej weryfikacji

Czy kiedykolwiek recenzowałeś coś, co było tak złe, że żałowałeś, że nie odebrałeś go wcześniej i nie dopuściłeś do napisania? To się często zdarza.

Nie można zapobiec pisaniu złego kodu, ale można ograniczyć straty czasu. Jeśli zobowiązujesz się do częstych recenzji i fuzji, minimalizujesz zakres zmarnowanego czasu.

Najgorszym scenariuszem jest to, że możesz zostawić młodszego programistę w spokoju na kilka tygodni w jego własnym miniaturowym projekcie, a kiedy są oni w końcu gotowi do przeglądu kodu, po prostu nie ma wystarczająco dużo czasu, aby rzucić cały bałagan i zacznij od nowa.

Wiele projektów staje się wielką kulą błota po prostu dlatego, że napisano cały ładunek złego kodu, kiedy nikt nie zwracał uwagi, dopóki nie było za późno.

3. Powinieneś być mniej pewny, że młodszy programista lub inny nowy członek zespołu zrozumiał wymagania

Czasami programista może stworzyć idealne rozwiązanie niewłaściwego problemu; ten jest smutny, ponieważ zwykle wynika z prostych nieporozumień, których tak łatwo byłoby uniknąć, gdyby tylko ktoś zadał właściwe pytanie (pytania) wcześniej.

Ponownie, jest to problem, który bardziej dotyka niedoświadczonych programistów, którzy są bardziej skłonni zaakceptować „złe” wymagania według wartości nominalnej, zamiast odpychać i kwestionować zasadność tego wymagania.

4. Prawdopodobnie będą mniej zaznajomieni ze wspólnymi wzorcami, architekturą istniejącego kodu oraz dobrze znanymi narzędziami i rozwiązaniami

Czasami deweloper spędza cały czas niepotrzebnie wymyślając koło, ponieważ nie wiedzieli, że istnieje nawet lepsze rozwiązanie. Lub spędzają dni próbując wbić kwadratowy kołek w okrągły otwór, nie zdając sobie sprawy z tego, co robią źle.

Ponownie, tego rodzaju rzeczy częściej zdarzają się niedoświadczonym programistom, a najlepszym sposobem rozwiązania tego problemu jest regularne przeglądy.

5. Długie przerwy między zatwierdzeniami / połączeniami kodu utrudniają identyfikację i naprawę defektów

Kiedy błąd pojawia się natychmiast po scaleniu zmian kodu o wiele tygodni w gałęzi master, trudność w określeniu, która zmiana mogła spowodować błąd, staje się trudniejsza.

Oczywiście w grę wchodzi również ogólna strategia rozgałęziania; idealnie wszyscy twoi programiści będą albo pracować we własnych gałęziach, albo w gałęziach funkcji (lub w obu) i nigdy nie będą pracować bezpośrednio z poziomu głównego / głównego.

Widziałem sytuacje, w których całe zespoły jednocześnie pracują bezpośrednio nad mistrzem / pniem, i jest to straszne środowisko dla CI, ale na szczęście rozwiązanie odciągnięcia wszystkich od mistrza / pnia ogólnie zapewnia wystarczającą stabilność do indywidualnej pracy przedmioty / bilety / itp.

Zawsze powinno być „OK” dla każdego dewelopera, aby złamać gałąź master / trunk, przy założeniu, że łączenie powinno odbywać się tak regularnie, że przełamywanie zmian i defektów powinno być rozpoznawane szybciej, a zatem również szybciej usuwane. Najgorsze wady to zazwyczaj te, które pozostają niewykryte przez miesiące, a nawet lata.

W podsumowaniu; główne zalety ciągłej integracji / ciągłego wdrażania to:

• Poprawia się komunikacja między zespołem
• Jakość kodu jest generalnie utrzymywana na wyższym poziomie
• Wymagania są mniej prawdopodobne, że zostaną pominięte lub źle zinterpretowane
• Problemy z architekturą i projektowaniem powinny być wykrywane szybciej,
• Wady są częściej wykrywane i naprawiane na wcześniejszym etapie

Więc jeśli nie ćwiczysz CI ze swoimi młodszymi programistami, to akceptujesz wiele znaczącego niepotrzebnego ryzyka, ponieważ są to członkowie twojego zespołu, którzy potrzebują go bardziej niż reszta.

Tak, możesz ćwiczyć CI z młodszymi programistami. Byłoby głupio, gdyby nie obecny klimat rozwoju. Niezwykle przydatna jest możliwość wypychania repozytorium, a następnie automatycznego scalania go w kod pomostowy - i oglądania go w czasie rzeczywistym w Travis (lub Bamboo, Pipelines itp.)!

Zabierz faceta DevOps i poproś go, aby wraz z nim przechodził przez ten proces, a także starszego programistę w gotowości, aby tylko pilnował rzeczy i łączył je z recenzjami kodu (robisz to, prawda?)

Jeśli obawiasz się, że ten gówniany kod przejdzie, to nie ma go w CI i nie jest w juniorach: to na tobie .

Pomóż im więc stać się lepszymi i przyzwyczaić się do szybszego wdrażania kodu stage / prod. W dłuższej perspektywie podziękujesz sobie.