Git: Branching. Introduzione

Il concetto di branching (ramificazione) è presente in quasi tutti i sistemi di controllo di versione (Version Control Systems – VCS).

In termini generali, creare un branch significa divergere dalla linea principale di sviluppo per proseguire il lavoro in modo indipendente, senza interferire con il codice stabile o condiviso.

Nella maggior parte dei VCS tradizionali, questa operazione risulta computazionalmente onerosa, in quanto comporta spesso la creazione di una copia fisica dell’intero albero dei sorgenti. Nei progetti di grandi dimensioni, ciò può implicare tempi di attesa considerevoli e un uso intensivo delle risorse.

Il Modello di Branching in Git

Git si distingue radicalmente da questo approccio.

Il suo sistema di branching è considerato una delle caratteristiche più innovative e determinanti dell’intero strumento — spesso definita la sua "killer feature".

La ragione principale di questa superiorità risiede nel fatto che, in Git, i branch sono entità estremamente leggere: si tratta di semplici puntatori (reference) a specifici commit della cronologia del repository.

Questo design permette di:

• creare nuovi branch in modo quasi istantaneo,
• passare da un branch all’altro in maniera immediata,
• gestire e fondere (merge) rami multipli con grande efficienza.

Tali caratteristiche rendono Git non solo più performante, ma anche più flessibile nella gestione dei flussi di lavoro complessi.

Grazie alla leggerezza del modello, Git favorisce un uso intensivo e naturale del branching, incoraggiando sviluppatori e team a creare, unire e rimuovere branch anche più volte nel corso della stessa giornata.

Questo approccio incentiva una metodologia di sviluppo più sperimentale e iterativa, in cui ogni funzionalità, correzione o prova può essere isolata in un branch dedicato, riducendo i rischi di regressione e migliorando la qualità del codice.

Comprendere la Struttura dei Branch in Git

Per comprendere appieno il funzionamento del branching in Git, è necessario analizzare in dettaglio come Git gestisce e archivia i dati internamente.

1. Il Modello di Memorizzazione in Git

A differenza di molti altri sistemi di controllo di versione, Git non archivia i dati come sequenze di differenze incrementali (changeset o delta).

Invece, ogni commit rappresenta uno snapshot completo dello stato dei file al momento della conferma (commit).

Quando si esegue un commit, Git crea un oggetto commit che contiene:

• Un puntatore (reference) allo snapshot del contenuto “staged” (nell’area di preparazione),
• Il nome e l’email dell’autore,
• Il messaggio di commit,
• Uno o più puntatori ai commit genitori (parent commit)

2. Esempio Pratico: Creazione di un Primo Commit

Supponiamo di avere una directory con due file (leggimi.txt, main.cs ), che vengono aggiunti e poi confermati:

git add leggimi.txt main.cs
git commit -m "Initial commit"

Durante l’operazione di git add, Git:

1. Calcola un checksum (SHA-1 hash) per ciascun file.
2. Archivia la versione del file nel repository come blob.
3. Aggiunge il riferimento di ogni blob all’area di staging.

Al momento del commit, Git:

• calcola un checksum anche per la directory (creando un oggetto tree),
• genera un oggetto commit che punta a tale tree,
• registra i metadati (autore, messaggio, timestamp).

Il repository conterrà ora quattro oggetti:

• 2 blob -> rappresentano il contenuto dei singoli file,
• 1 tree -> struttura della directory e mapping tra nomi file e blob,
• 1 commit -> metadati e riferimento al tree radice.

FIG 1 - Commit, tree e blob

3. Evoluzione della Cronologia dei Commit

Ogni nuovo commit aggiunge un nuovo oggetto commit con un puntatore al commit precedente.

In questo modo si crea una catena di commit, dove ogni nodo conosce il suo predecessore.

Questo modello garantisce integrità e tracciabilità, poiché ogni commit è referenziato crittograficamente.

FIG 2 - Commit, Child, Parent

4. Il Ruolo dei Branch

Un branch in Git non è altro che un puntatore mobile e leggero a un commit specifico.

Il branch predefinito si chiama master (o main).

Ogni volta che si effettua un nuovo commit, il puntatore del branch si sposta automaticamente in avanti, aggiornandosi per indicare l’ultimo commit nella sequenza.

Il branch master non ha alcun comportamento speciale.

È un branch come tutti gli altri, creato semplicemente come default dal comando git init.

FIG 3 - Master