Beginnergids: Starten met het onderwerp stap voor stap

Deze tutorial is een complete, praktische beginnersgids om stap voor stap te starten met Git en GitHub. Je leert niet alleen wat je moet doen, maar ook waarom, met echte commando’s, veelvoorkomende valkuilen en een werkbare workflow die je direct kunt toepassen.

Inhoud

1. Wat is Git (en wat is GitHub)?
2. Wanneer gebruik je Git?
3. Installatie
   • Windows
   • macOS
   • Linux
4. Eerste configuratie (essentieel)
5. Een nieuw project starten met Git
6. De basisworkflow: add → commit → log
7. Werken met branches
8. Mergen en conflicten oplossen
9. GitHub gebruiken: remote, push, pull
10. Pull requests (PR’s) en samenwerken
11. Handige Git-commando’s voor dagelijks gebruik
12. Veelgemaakte fouten en hoe je ze herstelt
13. Een aanbevolen workflow voor beginners
14. Volgende stappen

Wat is Git (en wat is GitHub)?

Git is een versiebeheersysteem (version control system). Het houdt bij hoe je bestanden veranderen door de tijd heen. Je kunt:

• wijzigingen opslaan als “momentopnames” (commits)
• teruggaan naar eerdere versies
• parallel werken via branches
• wijzigingen samenvoegen (merge)
• samenwerken zonder elkaars werk te overschrijven

GitHub is een platform waar je Git-repositories online kunt hosten. Het voegt o.a. toe:

• centrale opslag (remote)
• samenwerking via pull requests
• issue tracking
• code reviews
• CI/CD integraties (GitHub Actions)

Belangrijk: Git werkt prima zonder GitHub. GitHub is “een plek” waar je je Git-repo kunt delen en beheren.

Wanneer gebruik je Git?

Git is nuttig zodra je:

• code schrijft (Python, JavaScript, Java, etc.)
• teksten/rapporten bijhoudt (Markdown, LaTeX)
• configuratiebestanden beheert
• met meerdere mensen aan dezelfde bestanden werkt
• experimenten wilt doen zonder je hoofdversie te breken

Zelfs als je solo werkt is Git waardevol: het is je “tijdmachine” en je veiligheidsnet.

Installatie

Windows

1. Installeer Git for Windows (komt met Git Bash).
2. Controleer installatie:

git --version

Je ziet iets als:

git version 2.45.1.windows.1

Tip: Gebruik bij voorkeur Git Bash of Windows Terminal met Git in PATH.

macOS

Meestal kun je Git installeren via Xcode Command Line Tools:

git --version

Als Git nog niet aanwezig is, krijg je een prompt om tools te installeren.

Alternatief via Homebrew:

brew install git
git --version

Linux

Debian/Ubuntu:

sudo apt update
sudo apt install git
git --version

Fedora:

sudo dnf install git
git --version

Arch:

sudo pacman -S git
git --version

Eerste configuratie (essentieel)

Git gebruikt je naam en e-mail in commits. Stel dit meteen goed in:

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

Controleer:

git config --global --list

Handige extra instellingen

Standaard branchnaam (veel projecten gebruiken main):

git config --global init.defaultBranch main

Een betere log-weergave:

git config --global alias.lg "log --oneline --graph --decorate --all"

Nu kun je:

git lg

Standaard editor (voorbeeld: VS Code):

git config --global core.editor "code --wait"

Een nieuw project starten met Git

Maak een map en initialiseer een repository:

mkdir mijn-project
cd mijn-project
git init

Controleer status:

git status

Je ziet dat je op een branch zit (bijv. main) en dat er nog geen commits zijn.

Wat gebeurt er bij git init?

Git maakt een verborgen map .git/ aan. Daarin bewaart Git alle geschiedenis, branches, tags, en metadata. Verwijder je .git/, dan is het geen Git-repo meer.

De basisworkflow: add → commit → log

Laten we een bestand maken:

echo "# Mijn Project" > README.md

Controleer status:

git status

Je ziet README.md als “untracked”.

1) Stagen met git add

Voeg het bestand toe aan de staging area:

git add README.md

De staging area is een soort “winkelmandje” van wijzigingen die je straks commit. Dit is een belangrijk concept: je kunt selectief bepalen wat in een commit komt.

2) Committen met git commit

Maak een commit:

git commit -m "Voeg README toe"

3) Geschiedenis bekijken

Bekijk commits:

git log

Of je alias:

git lg

Wijzigingen bekijken

Pas README aan:

echo "Eerste versie van de documentatie." >> README.md

Bekijk wat veranderd is:

git diff

Stage en commit opnieuw:

git add README.md
git commit -m "Vul README aan met eerste tekst"

Werken met branches

Branches zijn essentieel om veilig te experimenteren. Je maakt een zijpad van je code, werkt daar, en voegt het later samen.

Branch maken en wisselen

Maak een nieuwe branch feature/intro en ga er direct naartoe:

git switch -c feature/intro

(Alternatief oudere syntax: git checkout -b feature/intro.)

Controleer:

git branch

Je ziet een * bij de actieve branch.

Wijziging op de feature-branch

Maak een nieuw bestand:

echo "Introductie" > intro.md
git add intro.md
git commit -m "Voeg intro document toe"

Terug naar main

git switch main

Je ziet dat intro.md nu weg is in je werkmap (want die commit staat op de andere branch).

Mergen en conflicten oplossen

Merge zonder conflict

Merge de feature-branch naar main:

git merge feature/intro

Als alles goed gaat, krijg je een “fast-forward” of een merge commit, afhankelijk van de situatie.

Conflicten: wat en waarom?

Een merge conflict ontstaat wanneer Git niet automatisch kan bepalen hoe twee wijzigingen gecombineerd moeten worden. Dit gebeurt vaak als:

• twee branches dezelfde regel in hetzelfde bestand aanpassen
• bestanden hernoemd/verplaatst zijn op beide branches

Conflict simuleren (leerzaam)

1. Maak op main een wijziging:

echo "Regel op main" >> README.md
git add README.md
git commit -m "Pas README aan op main"

2. Ga naar je feature-branch en pas dezelfde plek aan:

git switch feature/intro
echo "Regel op feature-branch" >> README.md
git add README.md
git commit -m "Pas README aan op feature-branch"

3. Probeer te mergen naar main:

git switch main
git merge feature/intro

Nu krijg je waarschijnlijk een conflict.

Conflict oplossen

Check status:

git status

Open het conflicterende bestand. Je ziet markeringen zoals:

<<<<<<< HEAD
Regel op main
=======
Regel op feature-branch
>>>>>>> feature/intro

Los het op door de gewenste tekst te kiezen (en de markers te verwijderen). Bijvoorbeeld:

Regel op main
Regel op feature-branch

Daarna:

git add README.md
git commit

Als je editor goed staat ingesteld, opent Git een commit message voor de merge. Sla op en sluit.

Merge afbreken

Als je midden in een merge zit en je wilt terug:

git merge --abort

GitHub gebruiken: remote, push, pull

1) Maak een repository op GitHub

• Ga naar GitHub → New repository
• Kies een naam (bijv. mijn-project)
• Maak hem aan (leeg is prima)

2) Koppel je lokale repo aan GitHub (remote)

Kopieer de SSH- of HTTPS-URL. Voeg remote toe:

git remote add origin git@github.com:jouwnaam/mijn-project.git

Controleer:

git remote -v

3) Push je commits

Push main naar GitHub:

git push -u origin main

De -u zet upstream tracking, zodat je later simpel git push kunt doen.

4) Wijzigingen ophalen

Als iemand anders (of jij via GitHub) wijzigingen heeft gedaan:

git pull

git pull = git fetch + git merge (standaard).
Wil je meer controle: eerst fetch, dan bekijken, dan mergen.

git fetch origin
git log --oneline --decorate --graph --all
git merge origin/main

Pull requests (PR’s) en samenwerken

Een pull request is een voorstel om wijzigingen van een branch naar een andere te brengen (meestal naar main). Het is dé plek voor review en discussie.

Typische flow

1. Maak een branch:

git switch -c feature/nieuwe-sectie

2. Werk, commit:

echo "Nieuwe sectie" >> README.md
git add README.md
git commit -m "Voeg nieuwe sectie toe aan README"

3. Push branch naar GitHub:

git push -u origin feature/nieuwe-sectie

4. Open GitHub → “Compare & pull request”
5. Laat review doen, pas aan indien nodig
6. Merge PR in GitHub

Na het mergen: lokaal bijwerken en opruimen

git switch main
git pull
git branch -d feature/nieuwe-sectie

Als de branch ook remote weg mag:

git push origin --delete feature/nieuwe-sectie

Handige Git-commando’s voor dagelijks gebruik

Status en overzicht

git status
git lg

Wat heb ik aangepast?

git diff
git diff --staged

Bestanden toevoegen

Alles stagen:

git add .

Selectief stagen (interactief):

git add -p

Dit is ideaal om kleine, logische commits te maken.

Commit aanpassen (laatste commit)

Als je net gecommit hebt maar iets wilt toevoegen:

git add README.md
git commit --amend

Let op: doe dit niet als je al gepusht hebt naar een gedeelde branch, tenzij je precies weet wat je doet (geschiedenis herschrijven).

Bestanden terugzetten

Wijzigingen in werkmap weggooien (niet gestaged):

git restore README.md

Gestagede wijzigingen terug uit staging:

git restore --staged README.md

Alles terug naar laatste commit (pas op!):

git restore .
git restore --staged .

Een bestand negeren met .gitignore

Maak .gitignore:

cat > .gitignore << 'EOF'
node_modules/
dist/
.env
.DS_Store
EOF

Commit dit bestand:

git add .gitignore
git commit -m "Voeg .gitignore toe"

Belangrijk: als een bestand al gevolgd wordt door Git, helpt .gitignore niet automatisch. Dan moet je het eerst untracken:

git rm --cached .env
git commit -m "Stop met tracken van .env"

Veelgemaakte fouten en hoe je ze herstelt

“Ik heb iets gecommit op de verkeerde branch”

Optie A: commit verplaatsen met cherry-pick (veilig en duidelijk).

1. Noteer de commit-hash:

git log --oneline

2. Ga naar de juiste branch:

git switch feature/juiste-branch

3. Cherry-pick:

git cherry-pick <commit-hash>

4. Ga terug en verwijder commit van de verkeerde branch (bijv. met reset) alleen als het nog niet gedeeld is:

git switch main
git reset --hard HEAD~1

“Ik heb per ongeluk wijzigingen weggegooid”

Als je git restore of git reset --hard deed, kan herstel lastig zijn, maar soms kan reflog helpen:

git reflog

Je ziet een lijst van recente HEAD-posities. Je kunt terug naar een eerdere staat:

git reset --hard <reflog-hash>

“Mijn push wordt geweigerd (non-fast-forward)”

Dit betekent dat remote nieuwe commits heeft die jij nog niet hebt. Oplossing:

git pull --rebase
git push

Waarom --rebase? Het houdt de geschiedenis vaak netter (jouw commits worden “bovenop” de remote commits gezet). In teams is het wel belangrijk afspraken te maken over rebase.

“Ik heb een geheim (API key) gecommit”

1. Verwijder het geheim uit het bestand en commit dat.
2. Roteer/vervang de sleutel (altijd doen).
3. Als het echt uit de geschiedenis moet: dat vereist history rewrite (bijv. git filter-repo). Dit is geavanceerd en impactvol voor alle collaborators.

Een aanbevolen workflow voor beginners

Hier is een eenvoudige workflow die in veel teams werkt:

1. Update main voordat je begint:

git switch main
git pull

2. Maak een feature-branch:

git switch -c feature/korte-omschrijving

3. Werk in kleine stappen: vaak git status, git diff.

4. Maak kleine, logische commits:

git add -p
git commit -m "Korte, duidelijke boodschap"

5. Push je branch:

git push -u origin feature/korte-omschrijving

6. Open een pull request op GitHub.

7. Na merge: update lokaal en ruim op:

git switch main
git pull
git branch -d feature/korte-omschrijving

Volgende stappen

Als je de basis beheerst, zijn dit goede vervolgstappen:

• Rebase beter begrijpen: git rebase -i (interactief)
• Tags voor releases: git tag -a v1.0.0 -m "Release 1.0.0"
• Stash voor tijdelijk wegzetten: git stash, git stash pop
• GitHub Actions voor automatische tests
• Conventionele commit messages (bijv. Conventional Commits)

Snelle oefening (aanrader)

Maak een mini-project en oefen:

1. init repo
2. maak README
3. maak branch
4. wijzig hetzelfde bestand op twee branches
5. los conflict op
6. push naar GitHub
7. maak PR en merge

Door dit één keer bewust te doen, onthoud je 80% van wat je in de praktijk nodig hebt.

Als je wilt, kan ik ook een oefenopdracht met “checkpoints” maken (met verwachte output van git status en git lg), of deze gids toespitsen op jouw situatie (bijv. schoolproject, webdevelopment, data science, of samenwerken in een team).