Hoe werkt Git intern?

Question

Accepted Answer

Intern is Git een **content-addressable object store** — het slaat alles op als **objecten** (blobs, trees, commits, tags) geïdentificeerd door hun **SHA-1 hash**. Het begrijpen van dit model ontmystificeert Git en verklaart waarom de operaties zich gedragen zoals ze doen.

## Git is een content-addressable object store

```text
Git stores 4 types of OBJECTS, each identified by the SHA-1 HASH of its content:
  BLOB   → file CONTENTS (just the data, no filename)
  TREE   → a directory: maps names → blobs (files) and trees (subdirs) + permissions
  COMMIT → a snapshot: points to a TREE (the root) + parent commit(s) + author/message
  TAG    → an annotated tag object (points to a commit, with metadata)
→ Content-addressable: an object's ID IS the hash of its content (same content = same hash).
```

## Een commit is een snapshot, geen diff

```text
→ Each COMMIT points to a complete TREE (the full state of the project at that point)
→ Git stores SNAPSHOTS, not diffs (though it compresses/deduplicates internally):
  unchanged files → the commit's tree just REUSES the same blob (same hash) → efficient
→ Diffs you see are COMPUTED between snapshots, not stored.
```

## Hoe het allemaal samenkomt

```text
Branch (e.g. main) → a pointer (a ref) to a COMMIT
HEAD → points to the current branch (or commit)
Commit → tree → blobs (the snapshot)
Commit → parent → parent → ... (the history chain)
→ Branches/tags are just small files containing a commit hash (cheap pointers).
  That's WHY branching is so lightweight.
```

## Waarom dit Git's gedrag verklaart

```text
✓ Branches are cheap → they're just a 40-char hash in a file (not file copies)
✓ Integrity → content-addressing means corruption/changes are detectable (hash mismatch)
✓ Commits are immutable → changing anything = a new hash = a new commit (why rebase
  creates NEW commits, why history rewriting changes hashes)
✓ Deduplication → identical content stored once (shared blobs)
```

## Waarom het belangrijk is

Het begrijpen van hoe Git intern werkt is waardevolle kennis op senior-niveau omdat het **Git ontmystificeert** en verklaart *waarom* de operaties zich gedragen zoals ze doen, waardoor je vermogen om over Git na te denken en Git zelfverzekerd te gebruiken verdiept.

Het kernmodel — Git als een **content-addressable object store** met vier objecttypen (blobs voor bestandsinhoud, trees voor directories, commits voor snapshots, tags) elk geïdentificeerd door de **hash van de inhoud** — is de basis waarop alles anders rust.

Het begrijpen dat **een commit een snapshot is, geen diff** (elke commit wijst naar een complete tree die de volledige projectstatus vertegenwoordigt, waarbij onveranderde bestanden efficiënt dezelfde blobs hergebruiken, en diffs eerder berekend dan opgeslagen zijn) corrigeert een veelgemaakte misvatting en verklaart Git's snapshot-gebaseerde model.

Het zien van **hoe het allemaal samenkomt** (branches en tags als goedkope pointers/refs naar commits, HEAD wijzend naar de huidige branch, commits gekoppeld via ouders) onthult de elegante eenvoud eronder.

Meest waardevol verklaart dit begrip **Git's waarneembare gedrag**: waarom **branches lichtgewicht zijn** (slechts een hash in een klein bestand, geen bestandskopieën — wat verklaart waarom branching zo snel is), waarom Git **integriteit** heeft (content-addressing detecteert beschadiging via hash-mismatch), waarom **commits onveranderbaar zijn** en operaties waarbij geschiedenis wordt herschreven, zoals rebase, **nieuwe commits met nieuwe hashes creëren** (het veranderen van inhoud verandert de hash), en waarom Git **deduplicatie** uitvoert (identieke inhoud eenmaal opgeslagen).

Dit diepere model transformeert Git van een reeks onthouden commando's in een begrijpelijk systeem, wat zelfverzekerd redeneren over complexe operaties mogelijk maakt.

Omdat het begrijpen van het interne objectmodel verklaart waarom Git zich gedraagt zoals het doet (lichtgewicht branches, onveranderbare commits, hashveranderingen bij herschrijven, integriteit) en men verheft van het gebruiken van Git naar het echt begrijpen ervan, is het begrijpen van Git-internals waardevolle kennis op senior-niveau — een onderwerp dat de diepgang weerspiegelt die voor senior-functies wordt verwacht en het mentale model biedt om zelfverzekerd over Git na te denken, waardoor het gedrag wordt ontmystificeerd en geavanceerde operaties begrijpelijk zijn in plaats van mysterieus.