Sessie 11: Git: Jouw code-geschiedenisboek

Stel je voor: je werkt drie uur aan je game. Je voegt een cool nieuw wapen toe. Maar… nu doet de rest van je game het niet meer. En je weet niet meer wat je precies veranderd hebt. Weg drie uur werk.

Git is de oplossing. Git onthoudt élke versie van je bestanden. Als een oneindige “undo”-knop die nooit vergeet wat je gedaan hebt.

In deze sessie installeer je Git, maak je je eerste repository en leg je voor altijd vast wat je doet: stap voor stap, versie voor versie. En het leuke: Git werkt niet alleen voor code. Ook voor notities, schoolverslagen en verhalen.

Wat is Git?

Git is een versiebeheersysteem. Het houdt bij wat jij verandert in je bestanden, wanneer je dat deed, en waarom. Elke keer dat je een stukje werk af hebt, maak je een commit: een foto van al je bestanden op dat moment.

Wat Git bijzonder maakt:

• Elke versie is bewaard. Je kunt altijd terug naar een vorige commit als iets kapot gaat.
• Je werkt lokaal. Git draait op jouw computer. Geen internet nodig.
• Git is snel. Zelfs projecten met duizenden bestanden controleren in milliseconden.

Git is gemaakt door Linus Torvalds, dezelfde persoon die Linux bouwde. Hij had iets nodig om met duizenden programmeurs tegelijk aan de Linux-kernel te werken. In 2005 bouwde hij Git in een weekend. Vandaag gebruikt bijna elke ontwikkelaar ter wereld het.

Git is niet alleen voor code

Git is gebouwd voor broncode, maar het werkt met alle tekstbestanden. Een tekstbestand is elk bestand dat je met Kladblok of een simpele editor kunt openen en lezen: .py, .html, .css, .json, .txt, .csv, .md (Markdown), .yml, .toml, noem maar op.

Wat Git níet goed kan: binaire bestanden. Dat zijn bestanden die niet uit leesbare tekst bestaan: afbeeldingen (.png, .jpg), video’s (.mp4), gecompileerde programma’s (.exe), Word-documenten (.docx). Git kan ze wél bijhouden, maar het is trager en je kunt niet zien wát er precies veranderd is. Bij tekstbestanden toont git diff elke letter die je toevoegde of weghaalde. Bij een .png zegt Git alleen “dit bestand is gewijzigd”, maar niet wát er aan de afbeelding veranderde.

Markdown en notities

Veel notitie-apps van tegenwoordig gebruiken Markdown (.md-bestanden) om je documenten op te slaan. Denk aan:

• Obsidian: je notities zijn gewoon .md-bestanden in een map op je computer
• Notion: exporteert naar Markdown
• Joplin: slaat alles op als Markdown
• Typora, Zettlr, Logseq: allemaal Markdown-gebaseerd

Omdat Markdown-bestanden gewone tekstbestanden zijn, kun je er Git op loslaten. Je houdt de geschiedenis van je notities bij, je kunt terug naar een vorige versie van een document, en je kunt je notities delen via GitHub, precies zoals je met code doet.

Een map met Markdown-notities onder Git zetten is even simpel als een Python-project:

mkdir mijn-notities
cd mijn-notities
git init
echo "# Mijn Notities" > start.md
git add start.md
git commit -m "Eerste notitie: startpagina"

Vanaf dat moment bewaart Git elke wijziging aan je notities. Schrijf je een verslag voor school in Markdown? Commit elke paragraaf. Werk je aan wereldbouw voor een verhaal? Git onthoudt elke versie van je plot.

Wanneer Git wél en níet voor notities gebruiken

Kortom: alles wat tekst is, kun je in Git stoppen. Alles wat binair is, beter niet.

Waarom versiebeheer?

Zonder Git ziet je workflow er zo uit:

game.py
game_backup.py
game_backup2.py
game_final.py
game_final_echt.py
game_final_echt_nieuwe_wapens.py

Herkenbaar? Met Git heb je maar één bestand nodig: game.py. Git onthoudt de rest.

Wat versiebeheer je oplevert:

• Nooit meer werk kwijt. Alles wat je commit, blijft bestaan. Altijd.
• Begrijpen wat er gebeurd is. Je ziet exact welke regels je wanneer veranderde.
• Experimenteren zonder risico. Maak een aparte kopie van je code (een branch), probeer iets geks, en gooi het weg als het niet werkt. Je originele code blijft intact.
• Samenwerken. Meerdere mensen kunnen tegelijk aan hetzelfde project werken, zonder elkaars code te overschrijven.

Wat stop je NIET in Git?

Git is gemaakt voor tekstbestanden: bestanden die jij zelf schrijft: code, notities, configuratie. Er zijn dingen die je beter buiten Git houdt:

Waarom geen wachtwoorden in Git? Omdat Git álles onthoudt, voor altijd. Zelfs als je later een wachtwoord verwijdert, zit het nog in de geschiedenis. Iedereen die jouw code ooit ziet, kan terugscrollen naar die commit. En als je code ooit op GitHub komt, staat je wachtwoord op het internet. Voor eeuwig.

Gebruik een .gitignore-bestand om Git te vertellen welke bestanden het moet negeren. Daar kom je zo meteen achter.

Stap 0: Git installeren

Windows

1. Ga naar git-scm.com en download de Windows-installer.
2. Dubbelklik het gedownloade bestand.
3. Klik door de installatie. De standaardopties zijn prima.
4. Belangrijk: kies bij het kiezen van de teksteditor Nano of Notepad++ (niet Vim, tenzij je Vim al kent).
5. Open na de installatie Git Bash (zoek ernaar in het startmenu).

Mac

Open de Terminal (zoek naar “Terminal” in Spotlight) en typ:

git --version

Als Git niet geïnstalleerd is, vraagt macOS je om de developer tools te installeren. Klik op “Install”. Klaar.

Linux (Ubuntu/Debian)

sudo apt install git

Controleren of het werkt

Open een terminal (Git Bash op Windows) en typ:

git --version

Je ziet iets als git version 2.47.0. Dat betekent: Git staat klaar.

Stap 1: Vertel Git wie je bent

Git wil weten wie jij bent, zodat het jouw naam bij elke commit kan zetten. Dit doe je één keer, daarna onthoudt Git het.

git config --global user.name "Jouw Naam"
git config --global user.email "jouw@email.com"

Gebruik hetzelfde e-mailadres dat je straks voor GitHub gebruikt. Dat maakt koppelen makkelijker.

Tip: --global betekent: deze instelling geldt voor ál je Git-projecten. Je hoeft dit maar één keer te doen.

Stap 2: Je eerste repository maken

Een repository (of “repo”) is een map waar Git de versies bijhoudt. Laten we er één maken.

Maak eerst een nieuwe map voor je project:

mkdir mijn-eerste-git-project
cd mijn-eerste-git-project

Nu vertel je Git: “Deze map is een repository.”

git init

Je ziet: Initialized empty Git repository in .../mijn-eerste-git-project/.git/

Git heeft een verborgen map .git aangemaakt. Daar bewaart het álles: de geschiedenis, de commits, de configuratie. Raak die map nooit met de hand aan, want Git beheert hem zelf.

Stap 3: Je eerste bestand committen

Maak een bestand aan. Bijvoorbeeld een Python-bestand met één regel:

echo 'print("Hallo Git!")' > hallo.py

Nu vertel je Git: “Let op dit bestand.”

git add hallo.py

Met git add zet je bestanden in de staging area: een tussenstation. Je zegt tegen Git: “Deze wijzigingen wil ik in mijn volgende commit.”

Controleer wat er klaarstaat:

git status

Git toont:

On branch master
Changes to be committed:
  new file:   hallo.py

Nu komt de commit zelf:

git commit -m "Mijn eerste commit: hallo.py toegevoegd"

Wat gebeurt hier? -m staat voor “message”. De tekst tussen aanhalingstekens is je commit message: een korte uitleg van wat je veranderd hebt. Git heeft nu een permanente foto van je project gemaakt.

Goede commit messages: Schrijf in het Engels (dat is de afspraak in bijna alle projecten). Begin met een werkwoord: “Add”, “Fix”, “Update”. Hou het kort: maximaal 72 karakters.

Stap 4: Veranderingen bijhouden

Open hallo.py in een teksteditor. Verander de regel naar:

print("Hallo Git! Jij onthoudt mijn code.")

Sla het bestand op. Kijk nu wat Git ziet:

git status

Git weet dat hallo.py gewijzigd is. Maar wát is er precies veranderd?

git diff

git diff toont exact welke regels je toegevoegd (groen met +) en verwijderd (rood met -) hebt. Dit is één van de krachtigste dingen van Git: je ziet letterlijk wat er veranderd is, karakter voor karakter, sinds je laatste commit.

Commit de wijziging:

git add hallo.py
git commit -m "Update: begroeting uitgebreid"

Stap 5: Terug in de tijd

Dit is waar Git magisch wordt. Stel: je hebt spijt van je laatste wijziging. Je wilt terug naar de eerste versie.

Toon eerst alle commits:

git log --oneline

Je ziet zoiets:

a1b2c3d Update: begroeting uitgebreid
e4f5g6h Mijn eerste commit: hallo.py toegevoegd

Elke commit heeft een unieke code, een hash. Die lange code (verkort tot 7 karakters) identificeert exact die ene versie van je project.

Om te zien hoe hallo.py eruitzag in de eerste commit:

git show e4f5g6h:hallo.py

Daar is je originele print("Hallo Git!") weer.

Wil je écht terug in de tijd? Dat kan:

git checkout e4f5g6h -- hallo.py

Nu staat hallo.py weer zoals in je eerste commit. Controleer met cat hallo.py. Je ziet de oude versie. Maar maak je geen zorgen: je tweede commit is niet weg. Met git checkout master -- hallo.py ga je weer naar de nieuwste versie.

Stap 6: Wat níet in Git: .gitignore

Maak een bestand aan dat Git moet negeren:

echo "GEHEIM_WACHTWOORD=12345" > geheimen.txt

git status toont dit bestand nu als “untracked”. Git heeft het gezien, maar weet niet of je het wilt bijhouden. Je kunt het negeren met een .gitignore-bestand:

echo "geheimen.txt" > .gitignore

Nu git status opnieuw en geheimen.txt is verdwenen uit de lijst. Git negeert het. (Voeg .gitignore zelf wél toe aan Git met git add .gitignore en git commit, zodat anderen ook weten wat er genegeerd moet worden.)

Een goed .gitignore voor een Python-project:

# Python
__pycache__/
*.pyc
*.pyo

# Geheimen
*.env
secrets.txt

# Jouw editor
.vscode/
.idea/

Showcase

Laat aan een coach en een buddy zien:

1. Je repository met minstens 3 commits.
2. Het resultaat van git log --oneline: jouw commit-geschiedenis.
3. Een git diff die toont wat je veranderd hebt.
4. Je .gitignore-bestand.

Tot de volgende keer!

“Volgende keer: twee versies van je code tegelijk. Je werkt aan een nieuwe feature terwijl de oude versie gewoon blijft werken. Dat heet branches, en het is wat Git écht krachtig maakt.”

Neem mee naar huis

1. Makkelijk: Maak een repository voor je notities. Zet een Markdown-bestand met wat je vandaag geleerd hebt in Git, en commit het.
2. Middel: Verander iets in je code of notities, gebruik git diff om de wijziging te bekijken, en commit hem met een goede message.
3. Lastig: Maak drie commits met verschillende wijzigingen. Gebruik git show om elke versie te bekijken. Gebruik git checkout om terug te gaan naar de eerste commit, en daarna weer naar de laatste.
4. Erg lastig: Maak een Python-project met een goede .gitignore. Zorg dat __pycache__/ en .pyc-bestanden écht genegeerd worden (check met git status).

Vastgelopen? Vraag het volgende dojo aan een coach, of probeer gewoon iets anders. Programmeren is doen. Git leren is doen.