corso laboratorio / metodo

Git e versioni

Dalla storia confusa al grafo che racconta il progetto.

Un percorso in sette moduli per sviluppatori che vogliono passare da Git per intuito a Git per metodo: modello mentale, branch, rebase, collaborazione remota, workflow di team e recupero da disastri.

Inizia dal modulo 01 Vedi la roadmap

idea centrale

Git non è uno strumento di salvataggio: è la storia tecnica del progetto.

Ogni commit, branch e merge è una decisione che lascerai a chi leggerà il codice fra sei mesi — incluso te. Per questo serve metodo: nomi chiari, commit isolati, workflow scelto, recupero pianificato.

cosa impari

Quattro abilità che reggono qualsiasi workflow.

01

Capire

Vedere Git come grafo di snapshot: oggetti, ref, HEAD. Niente magia, solo puntatori e hash.

02

Pulire

Costruire commit isolati e messaggi leggibili. La storia che lasci è documentazione.

03

Collaborare

Lavorare con branch, PR e remoti senza sovrascrivere lavoro altrui o rompere main.

04

Recuperare

Riscrivere storia in sicurezza e recuperare con reflog quando qualcosa va storto.

roadmap formativa

Sette moduli, dai fondamenti al recupero da disastri.

Prima il modello mentale (oggetti, HEAD, index), poi i comandi quotidiani, branch e merge. Quindi riscrittura della storia, collaborazione con remoti, workflow di team e casi reali di recupero.

modello

Fondamenti e modello mentale

5 lezioni

Cosa è davvero Git sotto il cofano: oggetti, riferimenti, working tree, index e HEAD. Senza modello mentale, ogni comando diventa scaramanzia.

Costruisci il modello mentale di Git: oggetti, snapshot, HEAD, index. Senza, ogni comando è magia nera.

  1. 01 Cosa è Git: snapshot, non diff
  2. 02 Working tree, index, repository: il modello a tre stadi
  3. 03 HEAD, branch, ref: cosa puntano davvero
  4. 04 Configurazione: identità, editor, alias, default
  5. 05 .gitignore, .gitattributes, fine riga, encoding

quotidiano

Lavorare in solitario: i comandi quotidiani

5 lezioni

Add, commit, status, log, diff, restore, reset: la routine giornaliera che decide se la storia del progetto sarà leggibile o un disastro.

Padroneggi la routine quotidiana: staging mirato, commit leggibili, diff letti prima di ogni azione.

  1. 06 git add e stage: scegliere cosa entra nel commit
  2. 07 git commit: messaggi che durano nel tempo
  3. 08 git status e git diff: leggere prima di agire
  4. 09 git log: leggere la storia di un progetto
  5. 10 git restore e git reset: tornare indietro in sicurezza

branch

Branch e merge

5 lezioni

Lavorare in parallelo senza intralciarsi: creare branch, integrarli, risolvere conflitti senza panico e leggere il grafo.

Lavori con branch corti, integri con merge consapevole, risolvi conflitti con metodo invece di tentativi.

  1. 11 Creare e cambiare branch: switch, checkout, branch
  2. 12 git merge: fast-forward vs three-way
  3. 13 Conflitti di merge: leggere i marker e risolvere
  4. 14 git stash: mettere via il lavoro temporaneamente
  5. 15 Strategie di branching: short-lived vs long-lived

storia

Riscrivere la storia: rebase, amend, cherry-pick

5 lezioni

Rebase interattivo, squash, amend, reflog: come ripulire la storia locale prima della condivisione, senza farsi male.

Riscrivi la storia locale con rebase interattivo, amend, cherry-pick. Reflog come rete di sicurezza.

  1. 16 git commit --amend: correggere l'ultimo commit
  2. 17 git rebase: spostare commit su un'altra base
  3. 18 Rebase interattivo: squash, fixup, reword, drop
  4. 19 git cherry-pick: portare un commit da un'altra parte
  5. 20 Reflog: la rete di sicurezza che molti ignorano

remoti

Collaborazione con remoti

5 lezioni

Clone, fetch, pull, push, tracking branch, force-with-lease, fork: lavorare con repository remoti senza sovrascrivere il lavoro altrui.

Collabori con remoti senza sovrascrivere il lavoro altrui: fetch, force-with-lease, fork, pull request.

  1. 21 Remote, origin, upstream: dove vivono i remoti
  2. 22 git fetch vs git pull: scaricare con consapevolezza
  3. 23 git push: branch, tracking, upstream
  4. 24 Force push in sicurezza: --force-with-lease
  5. 25 Fork, pull request, collaborazione open source

recupero

Casi reali, debugging della storia, recupero

6 lezioni

Bisect, blame, worktree, submodule, hook e procedure di recupero: gli strumenti che separano chi sopravvive a Git da chi lo padroneggia.

Diagnostichi regressioni con bisect, leggi storia con blame, gestisci submodule/worktree, recuperi disastri.

  1. 31 git bisect: trovare il commit che ha rotto qualcosa
  2. 32 git blame e archeologia del codice
  3. 33 git worktree: più branch in cartelle separate
  4. 34 Submodule e alternative (subtree, monorepo)
  5. 35 Hook Git: pre-commit, pre-push, commit-msg
  6. 36 Capstone: storia ripulita, workflow scelto, recupero da disastro

per chi e fatto

Pensato per chi usa Git tutti i giorni senza dominarlo.

Serve uso quotidiano di Git (anche solo add, commit, push) e almeno un progetto reale versionato. Il corso non insegna a programmare: insegna a versionare il codice come professionista.

A chi parla

  • sviluppatori che usano Git per intuito e vogliono passare al metodo
  • studenti che hanno imparato i comandi base e si bloccano davanti ai conflitti
  • team lead che devono uniformare il workflow del team
  • creator e founder tecnici che gestiscono progetti con più contributor

Prerequisiti

  • uso quotidiano di un terminale o di un client Git visuale
  • almeno un progetto reale versionato su Git
  • familiarità con file, cartelle ed editor di codice

cosa non e

Cosa il corso non è.

  • Non è una raccolta di comandi da memorizzare senza modello mentale.
  • Non è un corso su un client specifico (CLI, GitHub Desktop, GitKraken).
  • Non è un manuale di GitHub o GitLab: la piattaforma è un'aggiunta, non l'oggetto.
  • Non è una guida ai workflow 'giusti': fornisce criteri per scegliere il vostro.

risultato atteso

Competenze verificabili a fine percorso.

  • spiegare in 60 secondi il modello a tre stadi: working tree, index, repository
  • scrivere commit leggibili e isolati che raccontano una storia tecnica
  • lavorare con branch senza paura di rompere main
  • risolvere conflitti di merge senza copia-incolla a caso
  • riscrivere la storia locale con rebase interattivo e amend
  • recuperare lavoro perso con reflog, stash e cherry-pick
  • collaborare con remoti via fetch, pull, push e force-with-lease in sicurezza
  • scegliere un workflow di team (trunk-based, GitHub Flow, GitFlow) in modo motivato
  • leggere una storia con log, blame, bisect per trovare la causa di un bug
  • configurare hook, alias e tag per automatizzare le parti ripetitive