← Terug naar tutorials

Hoe start je als beginner: 5 makkelijke stappen

beginnergidsstappenplanbasistips

Beginnergids: Starten met het onderwerp (stap voor stap)

Deze tutorial is een complete beginnersgids om stap voor stap te starten met een praktisch en veelgebruikt onderwerp: Git en GitHub. Je leert niet alleen wat je moet doen, maar ook waarom je het doet, wat er onder de motorkap gebeurt, en hoe je typische fouten oplost. Alle voorbeelden bevatten echte commando’s die je direct kunt uitvoeren.

Inhoud

  1. Wat is Git (en wat is GitHub)?
  2. Installatie en eerste configuratie
  3. Een repository maken (lokaal)
  4. De basisworkflow: add → commit → log
  5. Bestanden negeren met .gitignore
  6. Branches: waarom ze bestaan en hoe je ze gebruikt
  7. Mergen en conflicten oplossen
  8. Werken met een remote (GitHub)
  9. Pull requests (PR’s) en samenwerken
  10. Tags en releases
  11. Handige commando’s en troubleshooting
  12. Aanbevolen dagelijkse workflow (checklist)

Wat is Git (en wat is GitHub)?

Git in één zin

Git is een versiebeheersysteem (version control system) dat veranderingen in bestanden bijhoudt, zodat je kunt terugkijken, vergelijken, samenwerken en veilig experimenteren.

Waarom versiebeheer?

Zonder Git eindig je vaak met bestanden als:

Met Git heb je in plaats daarvan:

Git vs GitHub

Belangrijk: je kunt Git volledig gebruiken zonder GitHub. GitHub wordt pas relevant als je je repo online wil delen of samenwerken.

Installatie en eerste configuratie

Controleren of Git al geïnstalleerd is

Open een terminal:

git --version

Als je een versie ziet (bijv. git version 2.44.0), zit je goed.

Git installeren

Windows (aanrader):

macOS:

brew install git

Linux (Debian/Ubuntu):

sudo apt update
sudo apt install git

Identiteit instellen (verplicht)

Git zet je naam en e-mail in elke commit. Dit is metadata, zodat duidelijk is wie iets heeft gedaan.

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

Controleer:

git config --global --list

Standaard branchnaam instellen (optioneel, maar modern)

Veel projecten gebruiken main in plaats van master:

git config --global init.defaultBranch main

Teksteditor instellen (optioneel)

Git gebruikt soms een editor (bijv. bij merge commits). Je kunt VS Code instellen:

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

Een repository maken (lokaal)

Stap 1: maak een projectmap

mkdir mijn-project
cd mijn-project

Stap 2: initialiseer Git

git init

Wat gebeurt hier?

Controleer status:

git status

Je ziet iets als: “No commits yet” en “nothing to commit”.

Stap 3: maak een bestand

echo "# Mijn Project" > README.md

Controleer opnieuw:

git status

Je ziet README.md als untracked (Git kent het bestand nog niet).

De basisworkflow: add → commit → log

Git werkt grofweg in drie “zones”:

  1. Working directory: jouw bestanden zoals ze nu op schijf staan.
  2. Staging area (index): een soort “wachtruimte” waarin je selecteert wat in de volgende commit komt.
  3. Repository (commits): de vastgelegde geschiedenis.

Stap 1: bestand toevoegen aan staging

git add README.md

Nu staat het bestand in staging. Controleer:

git status

Je ziet README.md onder “Changes to be committed”.

Stap 2: commit maken

git commit -m "Voeg README toe"

Een commit is een snapshot van je project (technisch: Git slaat objecten op en een commit wijst naar een tree met blobs). Belangrijk: commits zijn immutabel; je past een commit niet “aan”, je maakt een nieuwe commit.

Stap 3: geschiedenis bekijken

git log

Voor een compact overzicht:

git log --oneline --decorate --graph

Meerdere bestanden tegelijk

Stel je maakt nog een bestand:

echo "print('Hallo Git')" > app.py

Voeg alles toe:

git add .

Commit:

git commit -m "Voeg simpele app toe"

Tip: git add . voegt alle wijzigingen toe in de huidige map en submappen. Gebruik het bewust.

Bestanden negeren met .gitignore

Sommige bestanden wil je niet in Git, zoals:

Maak een .gitignore:

cat > .gitignore << 'EOF'
# Python
__pycache__/
*.pyc

# Omgevingsvariabelen / secrets
.env

# OS
.DS_Store
EOF

Controleer:

git status

Commit .gitignore:

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

Belangrijk om te begrijpen:

git rm --cached pad/naar/bestand

Branches: waarom ze bestaan en hoe je ze gebruikt

Wat is een branch?

Een branch is een pointer naar een commit. De branchnaam (bijv. main, feature-login) wijst naar de nieuwste commit in die lijn.

Waarom branches?

Huidige branches bekijken

git branch

Nieuwe branch maken en ernaartoe gaan

git switch -c feature-tekst

(Oudere syntax: git checkout -b feature-tekst)

Maak een wijziging:

echo "" >> README.md
echo "Dit is een extra regel op een feature-branch." >> README.md

Stagen en committen:

git add README.md
git commit -m "Breid README uit met extra tekst"

Terug naar main

git switch main

Je ziet dat je README weer terug is naar de toestand van main (zonder de nieuwe regel), omdat die commit op een andere branch staat.

Mergen en conflicten oplossen

Merge zonder conflict

Merge de feature-branch in main:

git merge feature-tekst

Als Git de wijzigingen automatisch kan combineren, krijg je een merge commit of een fast-forward (afhankelijk van de situatie).

Bekijk de graph:

git log --oneline --graph --decorate

Merge conflict (bewust uitlokken om te leren)

Conflicten ontstaan wanneer Git niet weet welke wijziging “wint”. Bijvoorbeeld: dezelfde regel in hetzelfde bestand is op twee branches anders aangepast.

  1. Maak een nieuwe branch:
git switch -c conflict-demo
  1. Pas dezelfde regel aan op deze branch:
sed -i.bak 's/# Mijn Project/# Mijn Project (conflict-demo)/' README.md 2>/dev/null || true

Als sed -i niet werkt op jouw systeem (macOS vs Linux verschillen), bewerk dan handmatig met een editor.

Commit:

git add README.md
git commit -m "Wijzig titel in README op conflict-demo"
  1. Ga terug naar main en wijzig dezelfde regel anders:
git switch main

Bewerk titel anders (handmatig of met editor) en commit:

perl -pi -e 's/# Mijn Project/# Mijn Project (main)/' README.md
git add README.md
git commit -m "Wijzig titel in README op main"
  1. Probeer te mergen:
git merge conflict-demo

Nu krijg je een conflict. Git markeert het in het bestand met conflictmarkers:

<<<<<<< HEAD
# Mijn Project (main)
=======
# Mijn Project (conflict-demo)
>>>>>>> conflict-demo

Conflict oplossen

Daarna:

git add README.md
git commit

Git maakt nu een merge commit met een standaard bericht (je editor kan openen).

Merge afbreken (als je vastloopt)

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

git merge --abort

Werken met een remote (GitHub)

Waarom een remote?

Een remote is een “kopie” van je repository op een server. Voordelen:

SSH of HTTPS?

Hier tonen we beide opties, maar kies er één.

Remote repository aanmaken op GitHub

  1. Ga naar GitHub → New repository
  2. Kies naam (bijv. mijn-project)
  3. Maak repo aan zonder README (want je hebt al lokaal)

Je krijgt instructies met een URL, bijvoorbeeld:

Remote toevoegen

Kies één:

HTTPS:

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

SSH:

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

Controleer:

git remote -v

Eerste push

Push je main branch naar GitHub:

git push -u origin main

-u zet upstream tracking, zodat git push en git pull later automatisch weten welke remote branch bedoeld wordt.

SSH instellen (als je SSH gebruikt)

Controleer of je al een sleutel hebt:

ls -la ~/.ssh

Maak een nieuwe sleutel (ed25519 is modern):

ssh-keygen -t ed25519 -C "jij@example.com"

Start ssh-agent en voeg sleutel toe:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Kopieer je publieke sleutel:

cat ~/.ssh/id_ed25519.pub

Plak die in GitHub: Settings → SSH and GPG keys → New SSH key.

Test:

ssh -T git@github.com

Pull requests (PR’s) en samenwerken

Concept: feature branches + PR

In teams is het standaard:

  1. Maak branch voor feature/bugfix.
  2. Push branch naar remote.
  3. Open PR op GitHub.
  4. Code review + tests.
  5. Merge naar main.

Voorbeeld: nieuwe feature branch pushen

git switch -c feature-nieuw
echo "Nog een wijziging" >> README.md
git add README.md
git commit -m "Voeg nog een wijziging toe"
git push -u origin feature-nieuw

Ga naar GitHub: je ziet een knop “Compare & pull request”. Open PR, beschrijf wat je deed, vraag review.

Waarom PR’s nuttig zijn (ook solo)

Tags en releases

Wat is een tag?

Een tag is een label op een commit, vaak gebruikt voor versies zoals v1.0.0.

Maak een annotated tag:

git tag -a v1.0.0 -m "Eerste stabiele versie"

Bekijk tags:

git tag

Push tags naar remote:

git push origin v1.0.0

Of alle tags:

git push --tags

Op GitHub kun je van tags “Releases” maken met release notes.

Handige commando’s en troubleshooting

git status (meest gebruikt)

Toont:

git status

Verschillen bekijken: git diff

Wat is er veranderd maar nog niet staged?

git diff

Wat is staged (komt in de volgende commit)?

git diff --staged

Onbedoelde wijzigingen weggooien

Let op: dit kan data verliezen.

Bestand terugzetten naar laatste commit:

git restore README.md

Staging ongedaan maken (maar wijzigingen behouden):

git restore --staged README.md

Alles terugzetten (werkmap):

git restore .

Verwijderde bestanden herstellen

Als je een bestand verwijdert en dat is nog niet gecommit:

git restore pad/naar/bestand

Commit message aanpassen (laatste commit)

Als je net een commit maakte met een slechte boodschap:

git commit --amend -m "Betere commit message"

Belangrijk:

git fetch vs git pull

Gebruik fetch om veilig te kijken:

git fetch origin
git log --oneline --decorate --graph --all --max-count=20

Veelvoorkomende fout: “non-fast-forward”

Je probeert te pushen, maar remote heeft nieuwere commits.

Oplossing (meestal):

  1. Haal binnen:
git pull
  1. Los eventuele conflicts op, commit, push:
git push

Als je een rebase-workflow gebruikt:

git pull --rebase
git push

Bestand per ongeluk gecommit met geheimen

Als je per ongeluk een .env of API key hebt gecommit:

git rm --cached .env
echo ".env" >> .gitignore
git add .gitignore
git commit -m "Stop met tracken van .env"
git push

Let op: het geheim staat nog in de geschiedenis. Volledig verwijderen vereist history rewrite (bijv. git filter-repo) en is een apart, zorgvuldig proces.

Aanbevolen dagelijkse workflow (checklist)

Solo project (simpel)

  1. Bekijk status:
git status
  1. Bekijk wat je veranderd hebt:
git diff
  1. Stage bewust:
git add pad/naar/bestand
  1. Commit met duidelijke boodschap:
git commit -m "Korte samenvatting van wijziging"
  1. Push:
git push

Team workflow (met branches)

  1. Update main:
git switch main
git pull
  1. Nieuwe feature branch:
git switch -c feature-naam
  1. Werk → commit(s) → push:
git add .
git commit -m "Implementeer feature X"
git push -u origin feature-naam
  1. Open PR, laat reviewen, merge.

Extra verdieping: hoe Git “denkt” (kort maar belangrijk)

Git is geen systeem dat “verschillen” opslaat zoals sommige oudere tools. Git slaat vooral snapshots op (met deduplicatie). Kernconcepten:

Waarom is dit nuttig?

Oefening: mini-project van nul naar GitHub

Voer dit eens volledig uit om de flow te laten landen:

mkdir oefen-repo
cd oefen-repo
git init

echo "# Oefen Repo" > README.md
git add README.md
git commit -m "Init met README"

git switch -c feature-oefening
echo "Een feature regel" >> README.md
git add README.md
git commit -m "Voeg feature regel toe"

git switch main
git merge feature-oefening

git log --oneline --graph --decorate

Maak daarna een lege repo op GitHub en:

git remote add origin https://github.com/jouwnaam/oefen-repo.git
git push -u origin main

Afronding

Je kunt nu:

Als je wil, kan ik een vervolg schrijven over één specifiek pad, zoals:

Gerelateerde tutorials

Snel met Docker: bouw en draai je eerste container Hoe je snel REST API's bouwt met Python Flask Hoe je snel met Docker containers bouwt en draait