Il grafo, le soluzioni
I disegni giusti, le risposte, le trappole
Per ogni scenario, sempre lo stesso ordine: in italiano → il disegno e le risposte → le trappole. Per i più difficili, anche il passo per passo: dove stanno HEAD e le etichette dopo ogni comando.
Il tuo disegno è diverso ma i test sono verdi? Va bene. Controlla solo che le frecce vadano all'indietro e che ogni etichetta stia sul commit giusto.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · Il primo turno
In italiano. Sergio fa tre commit in fila: C1, C2, C3, con main sull'ultimo. Poi git switch -c straordinari crea un'etichetta nuova su C3 e sposta HEAD lì. Il commit successivo, C4, nasce dove sta HEAD (regola 3): nasce sopra C3 e solo straordinari avanza.
C1 ◀── C2 ◀── C3 ◀── main
▲
└── C4 ◀── straordinari ◀── HEADLe risposte.
domanda 1: 4
domanda 2: C2
domanda 3: straordinariDa HEAD torni indietro: C4, C3, C2, C1. HEAD non si conta, perché non è un commit.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: 5 | Hai contato HEAD come se fosse un commit: è «tu sei qui», non una foto | test_domanda_1_quanti_commit_da_head |
domanda 2: C4 | Hai scelto il commit dopo: le frecce vanno all'indietro, non in avanti (regola 2) | test_domanda_2_il_genitore_di_c3 |
2 · Un branch per la notte
In italiano. C1 e C2 stanno su main. Nadia crea notte su C2 e fa tre commit: C3, C4, C5. A ogni commit si sposta notte; main non lo tocca nessuno, quindi resta su C2.
C1 ◀── C2 ◀── main
▲
└── C3 ◀── C4 ◀── C5 ◀── notte ◀── HEADLe risposte.
domanda 1: C2
domanda 2: 5
domanda 3: 3Da notte si raggiungono C5, C4, C3 e poi, tornando indietro, anche C2 e C1: cinque. Quelli che main non ha sono i tre fatti su notte.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: C5 | Hai spostato main insieme a notte: un commit fatto su un branch fa avanzare solo quel branch | test_domanda_1_dove_punta_main |
domanda 3: 5 | Hai contato anche C1 e C2, che si raggiungono da tutte e due le etichette | test_domanda_3_quanti_in_piu |
3 · Il salto in avanti
In italiano. Ernesto fa C1 e C2 su main, crea freni e fa C3 e C4. Poi torna su main e unisce freni. Chi riceve è main, che è fermo su C2: da quando è nato freni non ha fatto niente. Regola 5: nessun commit nuovo, l'etichetta main salta su C4.
Prima del merge:
C1 ◀── C2 ◀── main ◀── HEAD
▲
└── C3 ◀── C4 ◀── freniDopo:
C1 ◀── C2 ◀── C3 ◀── C4 ◀── main ◀── HEAD
▲
freniLe risposte.
domanda 1: no
domanda 2: 4
domanda 3: C4Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: sì | Hai disegnato un commit di merge: ma main non era andato avanti, quindi basta spostare l'etichetta | test_domanda_1_il_merge_crea_un_commit |
domanda 2: 5 | Hai dato un numero anche al merge, che non esiste: C5 non nasce mai | test_domanda_2_quanti_commit_in_tutto |
4 · Due strade
In italiano.
- Marta fa C1 e C2 su
main. - Crea
sabatoe ci fa C3. - Torna su
maine fa C4: oramainesabatohanno storie diverse. - Da
mainuniscesabato: nasce C5, con due genitori, C4 e C3.
C1 ◀── C2 ◀── C4 ◀── C5 ◀── main ◀── HEAD
▲ │
└── C3 ◀──────┘
▲
sabatoLe risposte.
domanda 1: C5
domanda 2: C2
domanda 3: C3Le due strade partono da C2: è l'ultimo commit che hanno in comune. sabato non si muove: il merge l'ha lanciato Marta da main.
Passo per passo.
| Comando | HEAD | main | sabato | Commit nuovi |
|---|---|---|---|---|
| due commit | main | C2 | non c'è | C1, C2 |
git switch -c sabato | sabato | C2 | C2 | nessuno |
| commit | sabato | C2 | C3 | C3 |
git switch main | main | C2 | C3 | nessuno |
| commit | main | C4 | C3 | C4 |
git merge sabato | main | C5 | C3 | C5 (genitori C4 e C3) |
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: C4 | Hai scelto l'ultimo commit fatto su main: il commit con due frecce è quello del merge, C5 | test_domanda_1_commit_con_due_genitori |
domanda 3: C5 | Hai spostato anche sabato sul merge: si muove solo l'etichetta del branch che riceve | test_domanda_3_dove_punta_sabato |
5 · Il merge al contrario
In italiano.
- Lucia fa C1 e C2 su
main. - Crea
festivie ci fa C3. - Torna su
maine fa C4 e C5. - Passa su
festivie lanciagit merge main. Qui ricevefestivi: nasce C6, con due genitori, C3 (dove stavafestivi) e C5 (dove stamain).
Chi riceve si muove: festivi va su C6. main ha solo dato, e resta su C5.
C1 ◀── C2 ◀── C4 ◀── C5 ◀── main
▲ ▲
│ └───────┐
└── C3 ◀───────────── C6 ◀── festivi ◀── HEADLe risposte.
domanda 1: C5
domanda 2: C6
domanda 3: 4Da main si raggiungono C5, C4, C2, C1: quattro. Il commit C3, fatto su festivi, per main non esiste.
Passo per passo.
| Comando | HEAD | main | festivi | Commit nuovi |
|---|---|---|---|---|
| due commit | main | C2 | non c'è | C1, C2 |
git switch -c festivi + commit | festivi | C2 | C3 | C3 |
git switch main + due commit | main | C5 | C3 | C4, C5 |
git switch festivi | festivi | C5 | C3 | nessuno |
git merge main | festivi | C5 | C6 | C6 (genitori C3 e C5) |
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: C6 | Hai spostato main sul merge: ma il merge l'ha lanciato festivi, e main non ha ricevuto niente | test_domanda_1_dove_punta_main |
domanda 3: 6 | Hai contato tutti i commit del grafo: da main C3 e C6 non si raggiungono | test_domanda_3_quanti_commit_da_main |
6 · Due branch in fila
In italiano.
- Lucia fa C1 su
main. - Crea
avvisida C1 e ci fa C2. Torna sumain. - Crea
fermateda C1 e ci fa C3. Torna sumain. - Unisce
avvisi:mainè ancora su C1, che è il genitore di C2. Nessuna strada divisa: l'etichetta salta su C2 (regola 5). - Unisce
fermate: adessomainè su C2, ma C3 è nato da C1. Le strade sono divise: nasce C4, con due genitori, C2 e C3 (regola 4).
C1 ◀── C2 ◀── C4 ◀── main ◀── HEAD
▲ ▲ │
│ avvisi │
└── C3 ◀──────┘
▲
fermateLe risposte.
domanda 1: 1
domanda 2: C2 e C3
domanda 3: 4Passo per passo.
| Comando | HEAD | main | avvisi | fermate | Commit nuovi |
|---|---|---|---|---|---|
| commit | main | C1 | non c'è | non c'è | C1 |
git switch -c avvisi + commit | avvisi | C1 | C2 | non c'è | C2 |
git switch main, git switch -c fermate + commit | fermate | C1 | C2 | C3 | C3 |
git switch main | main | C1 | C2 | C3 | nessuno |
git merge avvisi | main | C2 | C2 | C3 | nessuno (salto) |
git merge fermate | main | C4 | C2 | C3 | C4 (genitori C2 e C3) |
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: 2 | Hai disegnato un commit di merge per ogni merge: il primo era un salto in avanti, senza commit | test_domanda_1_quanti_commit_di_merge |
domanda 2: C1 e C3 | Hai messo C1 come genitore: al secondo merge main era già su C2, non più su C1 | test_domanda_2_i_due_genitori |
7 · Il branch del branch
In italiano.
- Nadia fa C1 su
main. - Crea
turnie ci fa C2. - Da
turnicreaturni-nottee ci fa C3 e C4. - Torna su
turnie unisceturni-notte.turninon si è mosso da quando è natoturni-notte: salto, nessun commit nuovo.turniva su C4. - Torna su
main, fa C5. - Unisce
turni: stavoltamainè andato avanti, le strade sono divise. Nasce C6, con due genitori, C5 e C4.
C1 ◀── C5 ◀───────────── C6 ◀── main ◀── HEAD
▲ │
└── C2 ◀── C3 ◀── C4 ◀───┘
▲
turni, turni-notteLe risposte.
domanda 1: no
domanda 2: C4 e C5
domanda 3: 6Da main arrivano tutti: C6, poi C5 e C4, e tornando indietro C3, C2, C1. Sono sei, e non sette: il primo merge non ha creato nessun commit.
Passo per passo.
| Comando | HEAD | main | turni | turni-notte | Commit nuovi |
|---|---|---|---|---|---|
| commit | main | C1 | non c'è | non c'è | C1 |
git switch -c turni + commit | turni | C1 | C2 | non c'è | C2 |
git switch -c turni-notte + due commit | turni-notte | C1 | C2 | C4 | C3, C4 |
git switch turni | turni | C1 | C2 | C4 | nessuno |
git merge turni-notte | turni | C1 | C4 | C4 | nessuno (salto) |
git switch main + commit | main | C5 | C4 | C4 | C5 |
git merge turni | main | C6 | C4 | C4 | C6 (genitori C5 e C4) |
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: sì | Hai disegnato un merge anche per il primo: ma turni non si era mosso, e l'etichetta salta | test_domanda_1_il_primo_merge |
domanda 3: 7 | Hai dato un numero anche al primo merge, che non esiste: C5 è il commit di main, C6 il merge vero | test_domanda_3_quanti_commit_da_main |
8 · Il commit sbagliato
In italiano.
- Ernesto fa C1 su
main. - Crea
scheda-m16e ci fa C2: ha scritto il treno sbagliato. - Se ne accorge e fa C3, che corregge. Non cancella C2: regola 1.
- Torna su
maine unisce:mainnon si era mosso, quindi salta su C3. git branch -d scheda-m16toglie l'etichetta. I commit restano, emainli raggiunge.
C1 ◀── C2 ◀── C3 ◀── main ◀── HEADLe risposte.
domanda 1: 3
domanda 2: sì
domanda 3: 1L'unico branch che resta è main. Ma C2, l'errore, è ancora nel grafo: lo trovi nell'album, con C3 sopra che lo corregge.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
domanda 1: 2 | Hai tolto dal conto i commit del branch cancellato: ma branch -d toglie l'etichetta, non i commit | test_domanda_1_quanti_commit_da_main |
domanda 2: no | Hai creduto che la correzione cancelli l'errore: la correzione è un commit nuovo, C2 resta | test_domanda_2_il_commit_sbagliato_resta |