Struttura, contenuti e prerequisiti del corso

1. Struttura del corso Gratis

   Organizzazione interna del corso

   01:56
2. Contenuti del corso Gratis

   Gli argomenti trattati nel corso

   01:53
3. Prerequisiti del corso Gratis

   Cosa devo sapere per poter seguire questo corso

   01:16

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

   04:11
2. Demo: installare e configurare Git in Windows

   Demo installazione Git su Windows con Powershell

   04:11
3. Cosa non è Git e database interno

   Analizziamo come Git salva gli oggetti nel suo database interno

   05:41
4. Demo: salvare oggetti

   Inizializzazione e salvataggio a basso livello in Git

   06:43
5. Demo: dissezione del blob

   In questa demo analizziamo come è fatto un blob internamente

   06:44
6. Recap struttura binaria interna

   Ricapitoliamo quanto visto nelle demo sulla struttura interna

   03:06
7. La metafora dello snapshot

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

   05:33
8. Demo: il nostro primo commit

   Analizziamo quello che succede quando utilizziamo il comando commit di Git

   05:16
9. Demo: dissezioniamo il nostro primo commit

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

   05:58
10. Demo: un progetto reale

    Vediamo come preparare un progetto reale all'utilizzo di Git

    07:03
11. Riepilogo del modulo

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

    03:38

1. Introduzione al concetto di Refs

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

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

   Torniamo nel codice e analizziamo come funziona il comando checkout

   05:42
3. References

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

   05:17
4. Demo: la nostra seconda branch

   Creiamo la nostra seconda branch a partire da main o master

   06:13
5. Demo: visualizzazione grafica con GitViz e Git Visualizer

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

   04:53
6. Demo: capiamo meglio cosa significa detached HEAD

   In questa demo andremo a capire meglio cosa significa detached HEAD

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

   Scopriamo insieme come recuperare i commit "persi"!

   08:35
8. Il comando reflog

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

   01:08
9. Demo: reflog

   Vediamo il comando git reflog in azione

   02:32
10. Sviluppo parallelo tramite uso di branch

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

    03:39
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

    03:53
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

    06:40
13. Reintegro nella branch principale: fast forward

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

    01:25
14. Demo: reintegro nella branch principale con fast forward

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

    02:51
15. Merge

    Vediamo come mergiare una feature sviluppata su una apposita branch

    01:54
16. Demo: merge

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

    03:54
17. Rebase

    Reintegriamo la nostra feature branch utilizzando il rebase

    05:15
18. Demo: rebase

    Analizziamo con questa demo il reintegro con il rebase

    09:37
19. Demo: gestione dei conflitti

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

    06:34
20. Demo: gestione dei conflitti con rebase

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

    06:17
21. Squash

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

    01:27
22. Demo: squash

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

    09:11
23. Riepilogo

    Riepiloghiamo i contenuti di questo lungo e intenso modulo sul branching

    07:22

1. Introduzione

   Vediamo di cosa parleremo in questo modulo

   01:02
2. Server e Remotes demystified

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

   07:13
3. Demo: copiare il repository manualmente

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

   04:03
4. Demo: repository bare

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

   02:54
5. Gestire il remote

   Analizziamo il concetto di remote

   02:45
6. Demo: aggiungere remote

   Vediamo praticamente come aggiungere una remote al nostro repository Git

   08:11
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.

   09:38
8. Demo: clonazione di un repository

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

   03:08
9. Branch remote e branch locali

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

   05:39
10. Demo: due sviluppatori modificano la branch principale

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

    02:50
11. Demo: il primo sviluppatore invia le modifiche

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

    04:01
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

    06:13
13. Risoluzione dei conflitti

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

    06:43
14. Demo: risoluzione dei conflitti

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

    10:47
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.

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

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

    05:53
17. Commit logici e commit tecnici

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

    05:01
18. Demo: squash e rebase

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

    11:27
19. Lavorare con più branch pubbliche

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

    03:47
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.

    08:51
21. Demo: merge di branch pubbliche

    Vediamo in questa demo come eseguire il merge da branch pubbliche

    07:53
22. Demo: push force

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

    11:52
23. Demo: rebase branch pubbliche

    Vediamo in questa demo come fare il rebase di branch pubbliche

    06:58
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.

    11:39
25. Demo: Github

    Vediamo in questa demo un esempio di server Git: Github

    10:26
26. Conclusioni

    Facciamo un riepilogo di quello che abbiamo visto in questo modulo

    05:05

1. Cosa abbiamo imparato

   In questo video conclusivo riassumiamo tutto quello che abbiamo imparato

   06:52