🐉 Diventa un drago di Git: perché usare il Terminale e panoramica dei Meccanismi interni

Git non è solo un sistema di versionamento.

È un modello mentale per gestire la storia del software.

Chi impara Git dal terminale capisce Git.

Chi impara Git da una GUI spesso non capisce cos’è Git.

Questa guida ti porta dalle basi fino ai meccanismi interni, così da dominarlo davvero.

🔥 1. Perché Git? (e perché è importante capirlo bene)

Git nasce nel 2005 da Linus Torvalds, durante lo sviluppo del kernel Linux, con tre obiettivi:

• essere velocissimo
• essere sicuro e resistente alla corruzione dei dati
• funzionare in modo distribuito (ogni clone contiene tutta la storia)

Git non è stato progettato per essere semplice: è stato progettato per non rompersi.

Ma una volta compreso il modello mentale, diventa uno strumento potentissimo che ti fa lavorare più velocemente e con meno paura di sbagliare.

🧬 2. MODELLO MENTALE: come Git “vede” il mondo

Git non salva file.

Git salva snapshot (stati del progetto) collegati tra loro tramite hash.

Ogni commit è come un “checkpoint” che contiene:

• lo stato dei file
• un puntatore al commit precedente
• metadati (autore, data, messaggio)

La bellezza?

Ogni commit è immutabile. Se lo cambi, Git crea un nuovo commit con una nuova hash.

🔍 3. Le tre aree di lavoro: il concetto più importante

Git ha tre livelli:

1️⃣ Working Directory

La cartella dove modifichi i file.

2️⃣ Staging Area

La “lista della spesa” di cosa entrerà nel prossimo commit.

3️⃣ Repository

La storia salvata dentro .git.

Questo è tutto Git.

Capito questo, il resto è solo sintassi.

🗂️ 4. Dentro la cartella .git — cosa c’è davvero?

Questa è la parte che nessuno ti spiega, ma è ciò che ti dà una comprensione profonda.

Apri la cartella .git e troverai:

📁 .git/objects/

Cuore di Git.

Qui vengono salvati TUTTI gli oggetti Git:

• commit
• tree (directory)
• blob (file)

Ogni oggetto è identificato da un hash SHA-1.

Esempio di struttura:

jsx

Git salva gli oggetti compressi e deduplicati:

se due file sono uguali → Git salva un solo blob.

📁 .git/refs/

Contiene i puntatori ai branch e ai tag.

Esempi:

jsx

Un branch è solo un file di testo che contiene l’hash dell’ultimo commit!

📄 HEAD

Un file che dice “dove sei”:

jsx

Se HEAD punta direttamente a un hash → sei in “detached HEAD state”.

📁 .git/index

È la staging area.

È una struttura binaria che contiene:

• lista dei file da committare
• hash dei contenuti
• permessi
• timestamp

È grazie a questa struttura che Git sa cosa è cambiato.

📁 .git/hooks/

Script che si attivano su eventi (pre-commit, pre-push…).

Se vuoi automatizzare qualcosa, questo è il posto giusto.

📁 .git/config

Configurazione del repository:

• remote
• branch di default
• merge tool

🧱 5. I comandi fondamentali

🔸 git status

Mostra:

• branch attuale
• file modificati
• file in staging
• file non tracciati

È il comando più importante.

🔸 git add

Aggiunge file allo staging:

jsx

🔸 git commit

jsx

Ti consigliamo di utilizzare il conventional commit

🔸 git commit --amend

Ricrea l’ultimo commit:

• per aggiungere file dimenticati
• per correggere il messaggio
• per combinare più modifiche in un unico commit

jsx

⚠️ Cambia la hash → non usarlo dopo un push senza sapere cosa fai.

🔸 git log --oneline --graph --decorate --all

Visualizza la storia come un pro:

jsx

🌿 6. Branch

Un branch è solo un file di testo che contiene un hash.

Crearlo:

jsx

Switch:

jsx

🔄 7. Merge vs Rebase — cos’è meglio?

Merge

Unisce due branch → crea un commit “merge”.

Storia più realistica ma più “rumorosa”.

Rebase

Riscrive la storia come se il tuo branch fosse partito da uno stato più recente.

Pulitissimo:

jsx

⚠️ Rebase riscrive la storia → evitare su branch condivisi.

🧙‍♂️ Livello Avanzato: Rebase Interattivo

Pulire la storia è ciò che distingue un dev junior da uno senior.

jsx

Puoi:

• squash (unire commit)
• reword (cambiare messaggio)
• edit (modificare un commit passato)
• drop (cancellarlo)

Serve per creare una storia pulita e leggibile prima di aprire una PR.

🎯 8. Cherry-pick

Vuoi un commit da un altro branch?

jsx

📦 9. Patch da una PR GitHub

Vuoi applicare una PR senza fare merge?

Scarica la patch:

jsx

Applicala:

jsx

Perfetta per review offline o hotfix veloci.

🌍 10. Remote: cosa sono davvero?

I remote non sono “server GitHub”. Sono semplicemente percorsi verso altri repository.

Lista:

jsx

Push:

jsx

Fetch:

jsx

Pull = fetch + merge (o rebase se configurato).

🔥 11. Reflog: il pulsante “annulla” che nessuno conosce

Anche se elimini un branch, modifichi la storia o resetti tutto… Git ricorda tutto.

jsx

Puoi recuperare commit persi, branch cancellati, errori di rebase.

Mostra ogni operazione che ha spostato HEAD.

👉 Se un collega sbaglia comando, con reflog potete ricostruire esattamente cosa è successo: chi ha fatto cosa, quando, e verso quale commit si è spostata la storia.

È il comando che salva vite.

🧪 12. Reset: capire bene cosa fa

--soft

Mantiene tutto in staging.

--mixed (default)

Mantiene tutto in working directory.

--hard

Butta via tutto e torna allo stato precedente.

Esempio:

jsx

Occhio: è definitivo (ma reflog può salvarti).

🧠 13. Perché prima il terminale e poi la GUI

La GUI è super utile, ma solo dopo che hai capito:

• working → staging → repository
• snapshot immutabili
• hash
• reflog
• reset
• rebase
• cherry-pick

Usare Git senza capire Git porta a paura, errori e PR incasinate. Capire Git → libertà totale.

🎮 14. Allenarsi con Git: strumenti consigliati

🧩 Learn Git Branching

Learn Git Branching è uno dei migliori strumenti interattivi per imparare Git in modo visuale.

Simula un vero repository Git e ti permette di vedere graficamente cosa succede quando esegui i comandi.

📘 Pro Git (gratuito)

Pro Git è il libro ufficiale su Git, scritto da Scott Chacon e Ben Straub, ed è completamente gratuito. Copre tutto: dalle basi (commit, branch, merge) fino ai meccanismi interni del sistema (oggetti, hashing, reflog, protocolli di rete).

🎯 Creare un repository personale e sperimentare

Testa reset, rebase, reflog, patch, tutto senza paura.

🚀 Conclusione: Git è un superpotere

Capire Git non ti rende solo uno sviluppatore migliore. Ti rende:

• più veloce
• più sicuro
• più collaborativo
• più senior nella testa
• capace di risolvere problemi che bloccano interi team

Hai dubbi o vuoi saperne di più su git? Entra nella nostra community Discord