Mastering Git

Struttura, contenuti e prerequisiti del corso

1. Struttura del corso

   Organizzazione interna del corso

2. Contenuti del corso

   Gli argomenti trattati nel corso

3. Prerequisiti del corso

   Cosa devo sapere per poter seguire questo corso

Metafore base di utilizzo dello strumento, poniamo le basi per conoscere Git

1. Installare e configurare Git

   Installare e configurare Git in ambiente Microsoft Windows

2. Demo: installare e configurare Git in Windows

   Demo installazione Git su Windows con Powershell

3. Cosa non è Git e database interno

   Analizziamo come Git salva gli oggetti nel suo database interno

4. Demo: salvare oggetti

   Inizializzazione e salvataggio a basso livello in Git

5. Demo: dissezione del blob

   In questa demo analizziamo come è fatto un blob internamente

6. Recap struttura binaria interna

   Ricapitoliamo quanto visto nelle demo sulla struttura interna

7. La metafora dello snapshot

   Vediamo come la metafora dello snapshot possa aiutarci a comprendere meglio il funzionamento di Git

8. Demo: il nostro primo commit

   Analizziamo quello che succede quando utilizziamo il comando commit di Git

9. Demo: dissezioniamo il nostro primo commit

   Vediamo cosa è successo dietro le quinte a seguito del nostro primo commit

10. Demo: un progetto reale

    Vediamo come preparare un progetto reale all'utilizzo di Git

11. Riepilogo del modulo

    Facciamo il punto di quello che abbiamo visto in questo secondo modulo

1. Introduzione al concetto di Refs

   Introduciamo il concetto di Refs che è alla base del funzionamento del branching in Git

2. Demo: Puntatore HEAD e le basi del comando checkout

   Torniamo nel codice e analizziamo come funziona il comando checkout

3. References

   Inoltriamoci nel concetto di references, fondamentale per capire che cos'é una branch

4. Demo: la nostra seconda branch

   Creiamo la nostra seconda branch a partire da main o master

5. Demo: visualizzazione grafica con GitViz e Git Visualizer

   Vediamo insieme due tool di visualizzazione grafica per Git molti utili a livello didattico

6. Demo: capiamo meglio cosa significa detached HEAD

   In questa demo andremo a capire meglio cosa significa detached HEAD

7. Demo: analisi di commit orfani, check del file system e recupero commit persi

   Scopriamo insieme come recuperare i commit "persi"!

8. Il comando reflog

   Scopriamo insieme il comando git reflog e la sua utilità nel trovare commit orfani

9. Demo: reflog

   Vediamo il comando git reflog in azione

10. Sviluppo parallelo tramite uso di branch

    Vediamo come le branch ci permettano di parallelizzare lo sviluppo del nostro codice

11. Demo: bugfix su branch parallele

    Vediamo come possiamo sfruttare il concetto di branch per eseguire un bug fix in produzione mentre stiamo sviluppando una feature

12. Giochiamo con le branch manipolando direttamente il database interno

    Per comprendere fino in fondo come funzionano le branch, proviamo a manipolare direttamente il database interno di Git

13. Reintegro nella branch principale: fast forward

    Vediamo come riportare sulla branch principale una modifica fatta su una branch secondaria

14. Demo: reintegro nella branch principale con fast forward

    Vediamo adesso come, nella pratica, possiamo reintegrare una branch con il fast forward

15. Merge

    Vediamo come mergiare una feature sviluppata su una apposita branch

16. Demo: merge

    In questa demo vediamo come in pratica mergiare una feature branch nella branch principale

17. Rebase

    Reintegriamo la nostra feature branch utilizzando il rebase

18. Demo: rebase

    Analizziamo con questa demo il reintegro con il rebase

19. Demo: gestione dei conflitti

    In caso di modifica dello stesso file su branch diverse, come gestiamo i conflitti? Vediamolo in questa demo

20. Demo: gestione dei conflitti con rebase

    Vediamo in questa demo come la gestione dei conflitti si complichi leggermente con i rebase

21. Squash

    In chiusura di questo modulo sulle branches non può mancare il concetto di squash

22. Demo: squash

    Vediamo, praticamente, come lo squash ci aiuta a mantenere lineare la storia del nostro progetto

23. Riepilogo

    Riepiloghiamo i contenuti di questo lungo e intenso modulo sul branching

1. Introduzione

   Vediamo di cosa parleremo in questo modulo

2. Server e Remotes demystified

   Git non ha bisogno di server per funzionare, vediamo insieme perchè

3. Demo: copiare il repository manualmente

   Vediamo in questa demo come copiare il nostro repository semplicemente con un copia e incolla da file system

4. Demo: repository bare

   Scopriamo che cos'é un repository bare e come ci aiuta nel lavorare in team

5. Gestire il remote

   Analizziamo il concetto di remote

6. Demo: aggiungere remote

   Vediamo praticamente come aggiungere una remote al nostro repository Git

7. Demo: creare un repository da un remote esistente

   Simuliamo un secondo sviluppatore che vuole lavorare sul nostro progetto creando un repository a partire dalla remote condivisa.

8. Demo: clonazione di un repository

   Vediamo come sfruttare il comando git clone per velocizzare il lavoro di un secondo sviuppatore

9. Branch remote e branch locali

   Facciamo il punto sulla gestioine delle branch in git e come vengono usate dagli sviluppatori

10. Demo: due sviluppatori modificano la branch principale

    Vediamo cosa succede quando due sviluppatori lavorano in contemporanea sulla stessa branch principale

11. Demo: il primo sviluppatore invia le modifiche

    Simuliamo il primo sviluppatore che invia le proprie modifiche alla branch remota

12. Demo: il secondo sviuppatore tenta l'invio delle proprie modifiche

    Vediamo adesso che succede quando il secondo sviluppatore tenta l'invio delle proprie modifiche alla branch remota

13. Risoluzione dei conflitti

    Vediamo che cos'è un conflitto e come gestirlo al meglio

14. Demo: risoluzione dei conflitti

    Vediamo in questa demo come praticamente si risolvono i conflitti dovuti alle modifiche contemporanee di più sviluppatori

15. Lascia il campo più pulito di come l'hai trovato

    Quando si lavora in team è importante fare tutto il possibile per lasciare pulito lo spazio comune, vediamo come.

16. Demo: configurare Git per usare rebase durante il pull

    Vediamo in questo demo come configurare Git per usare rebase durante il pull

17. Commit logici e commit tecnici

    Con Git possiamo fare tanti commit, alcuni logici e altri tecnici: vediamo la differenza.

18. Demo: squash e rebase

    Vediamo come rendere lineare la storia del repository in presenza di commit tecnici utilizzando il comando squash

19. Lavorare con più branch pubbliche

    Vediamo come tutto quello che abbiamo imparato si applica alle branch pubbliche

20. Demo: lavorare con due branch pubbliche

    Vediamo nella pratica come due sviluppatori possano condividere una branch pubblica per collaborare su una funzionalità da sviluppare.

21. Demo: merge di branch pubbliche

    Vediamo in questa demo come eseguire il merge da branch pubbliche

22. Demo: push force

    Vediamo come forzare un push rimuovendo ramificazioni che sappiamo essere state già reintegrate con rebase

23. Demo: rebase branch pubbliche

    Vediamo in questa demo come fare il rebase di branch pubbliche

24. Demo: rebase finale

    In questa ultima parte di questa lunga demo, ultimiamo il lavoro di rebase e rendiamo lineare le branch di tutti gli sviluppatori.

25. Demo: Github

    Vediamo in questa demo un esempio di server Git: Github

26. Conclusioni

    Facciamo un riepilogo di quello che abbiamo visto in questo modulo

1. Cosa abbiamo imparato

   In questo video conclusivo riassumiamo tutto quello che abbiamo imparato