HEAD, branch, ref: cosa puntano davvero

Un branch non è una copia del progetto. Non è una cartella. Non è un contenitore di file. Un branch è un riferimento, cioè un puntatore mobile a un commit.

HEAD è il riferimento che dice dove ti trovi adesso. Normalmente HEAD punta a un branch. Il branch punta a un commit. Quando fai un nuovo commit, Git crea l’oggetto commit e sposta il branch in avanti.

Perché questa lezione conta

Molti comandi Git sembrano rischiosi perché immaginiamo branch e commit come entità pesanti. In realtà spostare un branch significa spesso aggiornare un file minuscolo dentro .git.

Capire HEAD, branch e ref rende più chiari checkout, switch, detached HEAD, reset, rebase e recupero con reflog. Quando sai cosa puntano, sai anche cosa puoi recuperare.

Obiettivo operativo

Alla fine della lezione devi saper disegnare HEAD, branch e commit in un grafo e spiegare cosa cambia quando crei commit, cambi branch o entri in detached HEAD.

HEAD

In un repo normale:

cat .git/HEAD

può restituire:

ref: refs/heads/main

Significa: HEAD non punta direttamente a un commit, ma al branch main. Poi main punta a un commit.

HEAD -> main -> commit C

Quando fai commit su main, Git aggiorna refs/heads/main al nuovo SHA.

Branch

Un branch è un nome che punta a un commit. Se apri:

cat .git/refs/heads/main

vedi uno SHA. Quel file è il branch, nella forma più semplice.

Quando crei un branch:

git switch -c feature/login

Git crea un nuovo riferimento che punta allo stesso commit in cui eri:

main          -> C
feature/login -> C
HEAD -> feature/login

Da quel momento, i nuovi commit spostano feature/login, non main.

Detached HEAD

Detached HEAD significa che HEAD punta direttamente a un commit, non a un branch:

HEAD -> commit B
main -> commit C

Succede quando fai:

git checkout <sha>

Non è un disastro. È una modalità utile per ispezionare storia vecchia. Diventa rischiosa solo se fai commit e poi cambi branch senza salvare quel nuovo commit con un riferimento.

Se in detached HEAD fai lavoro utile:

git switch -c recupero-lavoro

crei un branch che punta lì e il lavoro torna ad avere un nome.

Ref: nomi per commit

I ref principali vivono in:

.git/refs/heads/      branch locali
.git/refs/remotes/    remote-tracking branch
.git/refs/tags/       tag

Non serve manipolarli a mano, ma sapere che esistono aiuta a capire che Git non sposta “codice”: sposta riferimenti a oggetti.

Comandi essenziali

git branch -vv
git log --oneline --decorate --graph --all
cat .git/HEAD
git rev-parse HEAD
git rev-parse main
git switch -c esperimento
git switch main
git checkout HEAD~1
git switch -

git log --decorate è fondamentale perché mostra i nomi dei ref accanto ai commit.

Laboratorio guidato

Crea un repo con tre commit su main. Poi:

1. crea feature/a;
2. fai un commit su feature/a;
3. torna a main;
4. osserva il grafo;
5. fai checkout del commit precedente;
6. verifica lo stato detached HEAD;
7. crea un branch da quel punto.

Dopo ogni passo disegna:

HEAD ->
main ->
feature/a ->

Output atteso

Una pagina con tre disegni:

1. HEAD su branch;
2. due branch che divergono;
3. detached HEAD e recupero con nuovo branch.

Questi tre disegni sono più importanti di imparare dieci opzioni a memoria.

Errori comuni

Paura del detached HEAD. Non è pericoloso se non committi lavoro nuovo o se lo salvi subito in un branch.

Pensare che cancellare un branch cancelli subito i commit. Se i commit sono raggiungibili da altri ref o dal reflog, sono ancora recuperabili.

Non usare --decorate. Senza nomi dei ref, il grafo è molto meno leggibile.

Checklist di verifica

• so dire a cosa punta HEAD;
• so distinguere HEAD su branch e detached HEAD;
• so creare un branch da un commit vecchio;
• so leggere branch e tag in git log --graph --decorate.

Collegamenti

• Modulo: Fondamenti e modello mentale — lezione 3 del corso.
• Il reflog del modulo 4 diventa molto più chiaro se questi puntatori sono chiari.