Come funziona Git internamente?

Question

Accepted Answer

Internamente, Git è un **object store indirizzabile per contenuto** — memorizza tutto come **oggetti** (blob, tree, commit, tag) identificati dal loro **hash SHA-1**. Comprendere questo modello demistifica Git e spiega perché le sue operazioni si comportano in quel modo.

## Git è un object store indirizzabile per contenuto

```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).
```

## Un commit è uno snapshot, non un 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.
```

## Come si incastrano insieme

```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.
```

## Perché questo spiega il comportamento di Git

```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)
```

## Perché è importante

Comprendere come funziona Git internamente è una conoscenza di livello senior preziosa perché **demistifica Git** e spiega *perché* le sue operazioni si comportano come fanno, approfondendo la tua capacità di ragionare e utilizzare Git con sicurezza.

Il modello fondamentale — Git come **object store indirizzabile per contenuto** con quattro tipi di oggetti (blob per i contenuti dei file, tree per le directory, commit per gli snapshot, tag) ciascuno identificato dall'**hash del suo contenuto** — è la fondazione su cui poggia tutto il resto.

Comprendere che **un commit è uno snapshot, non un diff** (ogni commit punta a un albero completo che rappresenta lo stato completo del progetto, con i file non modificati che riutilizzano efficientemente gli stessi blob, e i diff calcolati piuttosto che memorizzati) corregge un malinteso comune e spiega il modello basato su snapshot di Git.

Vedere **come si incastrano insieme** (branch e tag come puntatori/ref economici ai commit, HEAD che punta al branch corrente, commit concatenati tramite parent) rivela l'elegante semplicità nascosta.

Più preziosamente, questa comprensione **spiega il comportamento osservabile di Git**: perché i **branch sono leggeri** (solo un hash in un piccolo file, non copie di file — spiegando perché il branching è così veloce), perché Git ha **integrità** (l'indirizzamento per contenuto rileva la corruzione tramite mancate corrispondenze di hash), perché i **commit sono immutabili** e le operazioni di riscrittura della storia come rebase creano **nuovi commit con nuovi hash** (cambiare qualsiasi contenuto cambia l'hash), e perché Git **deduplica** (il contenuto identico memorizzato una sola volta).

Questo modello più profondo trasforma Git da un insieme di comandi memorizzati in un sistema comprensibile, abilitando il ragionamento fiducioso su operazioni complesse.

Poiché comprendere il modello degli oggetti interni spiega perché Git si comporta come fa (branch leggeri, commit immutabili, cambio di hash su riscrittura, integrità) e ti eleva dall'usare Git a realmente comprenderlo, comprendere gli interni di Git è una conoscenza di livello senior preziosa — un argomento che riflette la profondità attesa per ruoli senior e fornisce il modello mentale per ragionare su Git in modo sicuro, demistificandone il comportamento e rendendo le operazioni avanzate comprensibili piuttosto che misteriose.