Úvod do riadenia verzií

Riadenie verzií predstavuje zaznamenávanie zmien v určitom softvére pomocou verzií. Verzia je určité vydanie softvéru s nejakým označením (najčastejšie sa používa systém sémantického verzionovania).

Prečo sledovať zmeny?

Povedzme, že máme jednoduchý Python kód:

# Načítame zoznam čísel na vstupe oddelených medzerou:
vstup = input("Zadaj čísla: ")

# `split()` pre `str` produkuje vždy zoznam `str` hodnôt:
str_cisla = vstup.split(" ")

# Preto musíme previesť tieto `str` hodnoty na `int` hodnoty,
# aby sme mohli vypočítať súčet:
int_cisla = []
for cislo in str_cisla:
    int_cisla.append(int(cislo))

# Vytvoríme si premennú pre súčet, na začiatku je súčet "0", pretože sme ešte nič nesčítali:
sucet = 0

for cislo in int_cisla:     # pre každé číslo v zozname čísel
    sucet = sucet + cislo   # pripočítame toto číslo k aktuálnemu súčtu

# Nakoniec iba vypíšeme výsledok:
print("Súčet zadaných čísel na vstupe je:", sucet)

Tento kód sčíta čísla oddelené medzerou a vypíše výsledok. Je to jeden z jednoduchších programov, ktorému sa venujú prevažne začínajúci programátori. V nasledujúcich kapitolách budeme tento kód postupne upravovať. Povedzme, že chceme celý kód drasticky zjednodušiť. Hneď v piatom riadku je spôsob pre elimináciu nasledujúcich 6 riadkov, a tým pádom zjednodušenie celého kódu:

int_cisla = [int(x) for x in vstup.split(" ")]

Toto riešenie by sa ďalej dalo zjednodušiť pomocou funkcie map, ale k tomu sa nedostaneme pretože sme dostali telefonát od nášho nadriadeného: vypadá to tak, že naši používatelia sú naozaj veľmi chytrí a namiesto čísla nám na vstup zadali nezmysel. Python nedokáže tento nezmysel prekonvertovať na číslo, a celý program vypíše chybové hlásenie a ukončí sa. Nadriadený nám povedal, že v takomto prípade by potreboval aby tento program takéto neplatné číslo jednoducho preskočil (ignoroval túto chybu). Zisťujeme, že my vlastne potrebujeme rozpísať ten for cyklus na viacero riadkov, aby sme mohli v prípade neplatného čísla pokračovať ďalším číslom:

# `split()` pre `str` produkuje vždy zoznam `str` hodnôt:
str_cisla = vstup.split(" ")

# Preto musíme previesť tieto `str` hodnoty na `int` hodnoty,
# aby sme mohli vypočítať súčet:
int_cisla = []
for cislo in str_cisla:
    try:
        int_cisla.append(int(cislo))
    except ValueError:
        continue

Hmm, toto sa veľmi nelíši od kódu ktorý sme mali k dispozícii predtým. Vlastne sme iba pridali ošetrenie výnimky v kóde na jedenástom riadku. Čiže sme museli niekoľkokrát stlačiť tlačidlo pre "krok späť" (alebo stlačiť naraz kombináciu klávesov Ctrl + Z) a upraviť náš predošlý kód. Horší scenár je taký, že sme náš obľúbený textový editor zatvorili a už nemáme žiadnu možnosť ako by sme sa vrátili k predchádzajúcemu riešeniu. Toto je iba jeden z veľmi veľa dôvodov prečo je dobré sledovať zmeny v našom projekte. Ďalšie dôvody sú napríklad také, že potrebujeme zistiť ktorá verzia obsahuje chybný kód, aby sme vedeli našich používateľov upozorniť, aké nové vylepšenia priniesla nejaká konkrétna verzia softvéru, možnosti spolupráce a príspevkov k zdrojovému kódu a tak ďalej - dôvodov je naozaj veľmi veľa, ak zapojíme fantáziu. A ak nezapojíme, tak si predsa len ukáźeme najdôležitejšie využitia v praxi, neskôr.

Poznámka: Ide iba o poukázanie na jednoduchý príklad toho, ako funguje princíp sledovanie zmien. Nie je podstatné ako kód funguje, ale aké zmeny v ňom vykonávame. Úpravy je možné realizovať pre akýkoľvek iný text, pri ktorom vieme jednoznačne pomocou softvéru pre riadenie zmien graficky porovnať rozdiely medzi verziami projektu. Nemusí ísť výlučne o počítačový kód - do zmien môžeme zahrnúť teoreticky akýkoľvek typ súboru. Avšak, pri netextových (respektíve binárnych súboroch) porovnávanie zmien nemá až taký veľký význam keďže ich ľudia nedokážu čítať voľným okom (nemáme čo porovnávať, pretože by sme nevideli žiadne zmysluplné zmeny, iba nezmyselné náhodné znaky ktoré vie prečítať iba počítač). Ale ak je to nevyhnutné, tak je možné sledovať zmeny aj pre binárne súbory (hoci sa to neodporúča, keďže je problém aj s kompresiou a úschovou dát zo strany softvéru ktorý verzie sleduje - a podobné iné technické záležitosti, o ktorých si povieme snáď neskôr, ale najskôr pekne po poriadku).

Je v poriadku ak sa jedná iba o pár riadkov jednoduchého kódu, ako sme mohli vidieť na príklade vyššie. Nie je problém tento kód voľne upravovať a udržiavať stabilným aj bez pomoci akéhokoľvek sledovania zmien. Ale čo ak pracujeme na veľmi veľkom projekte? Zdrojový kód operačného systému Linux (kernel) uchováva vyše 1 milión zmien (commitov) v rámci svojho GitHub repozitára. Pri takomto veľkom projekte a množstve kódu by sme si naozaj nedokázali predstaviť, že by sme nemali k dispozícii akékoľvek informácie o tom ako kód vyzeral v nejakom inom konkrétnom bode v čase (seriózne projekty potrebujú dokumentovať akékoľvek zmeny v zdrojovom kóde, inak by nastala chaos a panika).

Môže sa zdať, že pri takomto veľkom počte zmien je veľký problém zorientovať sa, kde čo vlastne je a ako to funguje. No pravdou je, že ak by sme zmeny nesledovali, mali by sme oveľa väčšie problémy. Ak je systém nastavený robustne, nie je problém pre skúseného programátora sa v kóde a v zmenách orientovať rýchlo a efektívne. Na prvý pohľad sa tento softvér pre sledovanie zmien môže zdať hrôzostrašný, no treba si uvedomiť že ide naozaj o veľmi rozsiahlu zbierku nástrojov ktoré používajú projekty všetkých veľkostí (naozaj neexistuje veľká spoločnosť, ktorá by niečo podobné nepoužívala) a teda je potrebné, aby obsahoval všetky dôležité funkcie. Šanca je, že niektoré z nich v živote ani nevyužijete, je dôležité zamerať sa na tie hlavné a potom to pôjde ako po masle.

Git

Existuje špecializované softvérové vybavenie ktoré nám umožňuje efektívne sledovať všetky zmeny v rámci určitého projektu. Najčastejšie sa používa softvér git, ktorý má širokú sadu nástrojov ktoré programátori dokážu zmysluplne využiť pre efektívne sledovanie zmien a riadenie verzií pre svoje projekty.