Introduzione a Git – Usare Git come strumento di collaborazione online

Ricapitolando: nella prima lezione vi ho spiegato cos’è Git, come installarlo e come configurarlo all’interno del vostro sistema, mentre nella seconda lezione vi ho introdotto alle principali funzionalità di questo version control system.

In questa lezione imparerete a usare Git come strumento di collaborazione online: come lavorare su più rami, come pubblicare il vostro codice, come scaricare gli aggiornamenti e così via.

I rami

In Git, i rami (branch) sono una parte fondamentale del processo di sviluppo. Quando lo sviluppatore vuole aggiungere una nuova feature o correggere un bug crea un nuovo ramo, ovvero una nuova linea di sviluppo indipendente dalle altre. In questo modo i cambiamenti vengono incapsulati all’interno di questo ramo e il nuovo codice non va a rendere instabile il nostro progetto.

Sembra difficile ma non lo è, nella prossima sezione vedremo come funziona attraverso un esempio pratico.

Utilizzo

Immaginiamo di lavorare a un tema WordPress da inserire su ThemeForest. Avremo un ramo, il principale, chiamato master che contiene il codice che verrà messo in produzione. Ipotizziamo ora di voler aggiungere una nuova feature: il portfolio.

Per organizzare il lavoro creo un nuovo ramo chiamato feature/portfolio.

git branch feature/portfolio

A questo punto è come se Git copiasse tutto il contenuto di master all’interno di una nuova cartella dandovi modo di modificare il codice senza andare a compromettere l’intero progetto.

Attraverso il comando git branch possiamo ora controllare che il nostro ramo sia presente: Git ci restituirà la lista di tutti i rami esistenti evidenziando il ramo corrente (quello in cui stiamo sviluppando). Nel nostro caso il risultato sarà il seguente:

Il ramo corrente è ancora master. Per iniziare a sviluppare all’interno del ramo che abbiamo appena creato dobbiamo eseguire:

git checkout feature/portfolio

Ora possiamo iniziare lo sviluppo della nuova feature utilizzando una linea di sviluppo indipendente da master. Completata e testata la nuova feature, ci basta unire (merge) il ramo feature/portfolio al ramo master e il gioco è fatto. Per farlo, prima di tutto salviamo tutte le nostre modifiche all’interno del ramo feature/portfolio attraverso un semplice git commit (vedi lezione 2), successivamente torniamo al branch master (git checkout master) e infine uniamo la nostra feature al nostro ramo di sviluppo principale attraverso il comando:

git merge feature/portfolio

Questo ci permette di prendere un ramo di sviluppo creato con il comando git branch e integrarlo all’interno di un altro ramo.

Per semplificare questo discorso, ecco uno schema di come funziona il processo appena descritto:

Ora non ci resta che imparare come condividere il codice con i nostri collaboratori.

Sincronizzazione

In Git ogni sviluppatore, all’interno del proprio computer, possiede la copia completa della repository a cui sta lavorando. Gli sviluppatori quindi devono avere un modo per condividere il loro codice così che tutti i loro collaboratori possano avere accesso alle varie modifiche.

I comandi presentati successivamente vi danno la possibilità di gestire le connessioni con altre repository, pubblicare il vostro codice e caricare le modifiche eseguite dai vostri collaboratori.

git remote

Per sincronizzare il codice con gli altri dobbiamo necessariamente connettere la nostra repository a un server remoto che funga da “centro operativo”. Il comando git remote ci dà la possibilità di creare, visualizzare o cancellare le connessioni a questi server remoti.

Per vedere le connessioni attive all’interno della nostra repository ci basta usare:

git remote

che ci restituirà la lista dei server remoti a cui siamo connessi. Solitamente se la repository è stata clonata, vedremo di default un server chiamato origin (che è il nome predefinito che Git associa al server da cui cloni).

Se volessimo aggiungere una nuova connessione a un server remoto, non dovremmo far altro che utilizzare questo comando:

git remote add

Questa funzionalità vi risulterà utile quando inserirete il controllo di versione all’interno di un vostro progetto e vorrete spedire tutto il codice e lo storico a un server remoto come GitHub o BitBucket.

git pull

Immaginiamo che un nostro collaboratore abbia completato una feature e abbia caricato questa feature nella nostra repository remota. Come facciamo a caricare le sue modifiche all’interno della repository su cui stiamo lavorando in locale?

In questo caso utilizzeremo il comando:

git pull

Questa funzionalità va a prendere il codice aggiornato nel server remoto, lo carica in locale ed esegue un merge automatico. Il merge, tra l’altro, è uno strumento molto potente, infatti poniamo il caso che entrambi abbiate modificato la stessa porzione di codice: Git non sa qual è quella giusta, ma ve lo segnala attraverso un apposito messaggio in modo che voi possiate andare a scegliere cosa mantenere e cosa cancellare.

git push

Ora veniamo all’ultima funzionalità che vi spiegherò oggi: il push. Questo comando vi permette di trasferire le vostre modifiche dalla vostra repository locale alla repository remota, dando quindi la possibilità a tutti i vostri collaboratori di accedere alle vostre modifiche. Per farlo non vi basta che digitare:

git push

Fatto questo Git procederà con l’upload di tutti i cambiamenti che avete effettuato. Il processo può richiedere un tempo variabile a seconda del peso delle vostre modifiche.

Mi raccomando, prestate attenzione quando usufruite di questa funzionalità in quanto, se avete commesso un errore durante la programmazione del codice, questo errore verrà diffuso a tutti i vostri collaboratori. Inoltre ricordatevi sempre di eseguire un git pull prima del push, altrimenti le modifiche eseguite dai vostri collaboratori andranno perse.

Conclusione

Con questa lezione avete imparato due cose fondamentali, l’utilizzo dei branch e la sincronizzazione del codice tra i vostri collaboratori.

Per ora vi ho spiegato l’utilizzo di queste risorse a livello teorico ma, nella prossima lezione, andremo ad utilizzare quanto imparato finora attraverso un caso studio dove simuleremo l’implementazione e l’utilizzo di un sistema di controllo versione all’interno di un nostro ipotetico progetto.


INTRODUZIONE A GIT: INDICE LEZIONI

– Cos’è e come installarlo
– Quali sono le funzioni principali di Git
– Usare Git come strumento di collaborazione online

Introduzione a Git – Quali sono le funzioni principali di Git

Nella prima puntata di “Introduzione a Git” abbiamo visto cos’è un sistema di controllo versione e perché Git è tra i sistemi più usati per la gestione di progetti a distanza e non.

Nella guida abbiamo spiegato come installare e impostare Git, quindi ora dovreste averne una versione funzionante e configurata con i vostri dati.

Nell’articolo di oggi, invece, impareremo a utilizzare i comandi base per operare in tutta tranquillità.

Inizializzare o clonare una repository

Una repository è la location dove sono conservati tutti i dati relativi a un progetto; nel nostro caso può essere riferita alla cartella contente tutto il codice a cui stiamo lavorando.

Per tracciare un progetto con Git per la prima volta è possibile sia inizializzare la repository che clonarla.

Se decidiamo di inizializzare la repository, tracceremo il progetto partendo da zero. Se invece decidiamo di clonarla, scaricheremo un progetto già tracciato che si trova online.

1) Inizializzare una repository

Per inizializzare la repository dovete:

– aprire il terminale (prompt dei comandi)

– posizionarvi nella root del vostro progetto

– digitare “git init”

$ mkdir mioprogetto // Crea una cartella dal nome “mioprogetto”
$ cd mioprogetto // Entra nella cartella “mioprogetto”
$ git init // Inizializza la repository

Verrà creata una cartella nascosta chiamata .git che conterrà tutti i file necessari per il tracciamento della vostra repository. Ricordate però che, a questo punto, il vostro progetto non è ancora tracciato.

Clonare una repository

Per avere una copia di una repository Git già esistente e reperibile online, basta aprire il terminale, entrare nella cartella dove vogliamo posizionare il codice e digitare:

$ git clone URL

ovviamente, sostituiremo URL con l’indirizzo del repository.

Ad esempio, mettiamo caso che dovete utilizzare bootstrap nel vostro progetto:

Normalmente andreste su http://getbootstrap.com/ per scaricare il file zip e inserireste i file presenti nell’archivio all’interno del vostro progetto.

Con Git invece basterà eseguire sul terminale il comando:

$ git clone https://github.com/twbs/bootstrap

Questo comando, nell’ordine:

  • crea una cartella “bootstrap”
  • inizializza una cartella .git dentro di essa
  • scarica tutti i dati per questo repository
  • imposta la copia di lavoro dell’ultima versione

In questo modo il framework sarà presente nel vostro progetto e potrete aggiornarlo in qualsiasi momento (dopo vedremo come).

Controllare lo status del repository

Abbiamo creato la cartella “mioprogetto” e abbiamo inizializzato Git, ora possiamo cominciare a lavorarci e a inviare le modifiche al database di Git ogni volta che il progetto raggiunge uno stato che vogliamo registrare.

Ogni file presente nella cartella di lavoro può avere due stati: tracciato o non tracciato. I file tracciati possono essere non modificatimodificati staged.

I file non tracciati sono tutti gli altri.

Lo strumento principale per determinare quali file sono in un certo stato è il comando git status. Lanciando questo comando direttamente dopo aver fatto una clonazione accadrà questo:

$ git status
# On branch master
nothing to commit (working directory clean)

Questo significa che la cartella su cui stiamo lavorando è pulita (clean), non c’è traccia di file modificati. Git inoltre non individua altri file non tracciati, altrimenti li elencherebbe.

Infine, il comando ci dice in quale ramo del progetto ci troviamo (branch) ma di questo parleremo più tardi.

Ora provate ad aggiungere un file “myfile.html” all’interno della cartella “mioprogetto” ed eseguite di nuovo Git status. Vedremo il file non tracciato come segue.

$ git status
# On branch master
# Untracked files:
# (use "git add ..." to include in qwhat will be committed)
#
# myfile.html
nothing added to commit but untracked files present (use "git add" to track)

Come potete vedere, il nuovo file è nell’elenco degli “Untracked files”; ciò significa che non è tracciato nel database. Git inizierà ad includerlo nel db solo quando gli daremo il comando atto a farlo.

Tracciare un file: git add

Per iniziare a tracciare un nuovo file, usiamo il comando:

$ git add [nome_file]

Per tracciare il file da noi aggiunto poco fa useremo quindi:

$ git add myfile.html

e lanciando nuovamente il nostro git status noteremo che Git ci risponde nel seguente modo:

$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD ..." to unstage)
#
# new file: README

Il file risulta tracciato e in stato di stage. Ora possiamo eseguire il nostro primo commit ovvero possiamo memorizzare lo stato attuale in cui si trova il nostro progetto. Ricordate che qualsiasi file che non si trovi in stato di stage non andrà nel commit, rimarrà solamente nel disco rigido e non verrà registrato nel database.

Registrare lo stato del progetto: git commit

Per poter ripristinare in qualsiasi momento una qualsiasi fase del progetto a cui stiamo lavorando è necessario registrare man mano lo stato in cui si trova il progetto. Il modo più semplice per farlo è attraverso il comando:

$ git commit

Possiamo inoltre aggiungere un parametro che ci permette di inserire una descrizione del cambiamento che stiamo registrando. Per farlo basta specificare l’opzione -m seguita dalla descrizione tra virgolette.

$ git commit -m “Primo commit”
[master]: created 463dc4f: "Primo commit"
1 files changed, 3 insertions(+), 0 deletions(-)
create mode 100644 myfile.html

Ora abbiamo creato il nostro primo commit!

Possiamo vedere che il commit ha riportato alcune informazioni sull’operazione. Indica infatti:

  • a quale ramo abbiamo affidato il commit (in questo caso, master)
  • quale checksum (versione) ha il commit
  • quanti file sono stati modificati
  • le statistiche sulle linee aggiunte e rimosse nel commit

Se volessimo vedere i vari stati del progetto che sono stati registrati ci basterà usare il comando git log che restituirà un output con gli ultimi commit fatti nel repository. Ecco un esempio:

$ git log
commit ca82a6dff817ec66f44342007202690a93763949
Author: Simone Chinaglia <hello@simonechinaglia.net>
Date: Tue Jul 17 21:52:11 2019 +0100

Fixed comments

commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
Author: Giovanna <xxx@xxx.xxx>
Date: Sat Mar 15 16:40:33 2013 -0900

Added core.js

commit a11bef06a3f659402fe7563abf99ad00de2209e6
Author: Simone Chinaglia <hello@simonechinaglia.net>
Date: Tue Jul 17 21:52:11 2019 +0100


Added Analytics tracking code

Queste stringhe indicano il codice del commit, il nome dell’autore, la sua mail, la data di scrittura e la descrizione inserita dall’autore del commit.

Rimuovere la tracciatura di un file

Abbiamo visto come si può tracciare un file con il comando git add ma se volessimo rimuovere la tracciatura, cosa dobbiamo fare? Semplice, inserire  il comando:

$ git rm [file]

che permette di rimuovere un file da quelli tracciati.

Ignorare i file

Spesso, si ha una classe di file che si vogliono nascondere a Git. In questi casi, potete creare un file chiamato .gitignore con una lista di file o pattern che non devono essere mostrati a Git. Questo è un file d’esempio:

# Git Ignore #
##############
*.log
.DS_Store
/app/cache/*

La prima linea dice di ignorare tutti i file con estensione .log, la seconda linea di ignorare tutti i files chiamati .DS_Store e infine l’ultima riga dice di ignorare tutti i files presenti all’interno della cartella /app/cache/.

Conclusioni

In questa seconda guida abbiamo imparato a utilizzare  i comandi di base di Git, abbiamo visto come tracciare i file e come registrare uno stato del repository nello storico di Git.

Nella prossima guida capiremo come usare Git come strumento di collaborazione online: come lavorare su più rami, come pubblicare il nostro codice, come scaricare gli aggiornamenti e così via.

Infine nell’ultima puntata della guida vedremo un esempio pratico di come fare per pubblicare il codice su Github.


INTRODUZIONE A GIT: INDICE LEZIONI

– Cos’è e come installarlo
– Quali sono le funzioni principali di Git
– Usare Git come strumento di collaborazione online

Introduzione a Git – Cos’è e come installarlo

Prima ancora di essere un web designer sono uno sviluppatore freelance. Lavorando a molti progetti in remoto ho capito quanto sia importante utilizzare strumenti che facilitino la collaborazione online e permettano la condivisione di codice, testi e, perché no, dei propri design. Un modo per farlo è utilizzare un sistema di version control, come il programma Git.

Un sistema di controllo versione serve a registrare i cambiamenti che si fanno su un file o su una serie di file nel tempo, così da poter richiamare una versione specifica di quei dati in qualsiasi momento.

Perché usare un version control system?

Alcuni anni fa, prima di conoscere i version control systems, ogni volta che mi trovavo a dover fare un backup del mio codice, dovevo copiare tutti i file in un’altra directory che chiamavo “yyyy.mm.dd-backup-project”. Questo è un metodo molto usato perché semplice e veloce, ma è anche incredibilmente scomodo e soggetto ad errori.

Per questo motivo, quando ho iniziato a gestire i progetti utilizzando questi sistemi, ho fatto i salti di gioia. Grazie a un version control system posso:
– ripristinare i file ad uno stato precedente
– ripristinare l’intero progetto allo stato precedente
– confrontare i cambiamenti all’interno dei file
– nel caso di lavoro in team, vedere chi ha realizzato determinate modifiche, quando e perché
… e molto altro ancora.

Per capire meglio l’utilità dei sistemi di controllo versione mi basti dire che prima, se facevo dei pasticci o per errore cancellavo dei file, rischiavo l’infarto, ora invece, se succede, scrivo 4 parole sul terminale e tutto torna a posto.

Perché Git?

Una domanda che potreste farmi è: “Ci sono tanti tipi di controllo versione, perché dovremmo usare proprio Git?”.

I motivi sono molteplici.

Gratis e open source

Git è nato dopo che molti sviluppatori di Linux furono costretti ad abbandonare l’utilizzo di un controllo versione chiamato BitKeeper poiché il detentore dei diritti aveva ritirato la possibilità di utilizzarlo gratuitamente.

Torvald Linus allora si mise a cercare un sistema simile ma non trovò nulla che lo soddisfacesse. Nel 2005quindi fece partire lo sviluppo di Git e pochi mesi dopo venne rilasciata la prima versione gratis e open source.

Veloce e sicuro perché è un sistema distribuito

I sistemi di controllo versione possono essere di tre tipi:

– Locale
– Centralizzato
– Distribuito

1) I primi funzionano attraverso un semplice database installato in locale che registra tutti i cambiamenti dei file. Se però il computer contenente i dati incorre in qualche problema, non sarebbe possibile recuperarli.

2) I sistemi di controllo centralizzati hanno un singolo server che contiene tutte le versioni dei file. Se per qualche motivo, però, il server dovesse avere dei problemi, nessuno potrebbe più riuscire a collaborare e a salvare le proprie modifiche.

3) Se si uniscono i primi due sistemi, nascono i sistemi di controllo distribuiti. Tutti gli utenti che lavorano al progetto hanno una copia completa del repository (l’insieme di tutte le versioni dei vari file). In questo modo è come se esistesse una copia di backup per ogni persona che lavora al progetto, senza che i membri del team abbiano bisogno di connettersi al server per visualizzare la storia di un progetto.

Quest’ultimo è il sistema utilizzato da Git, per questo motivo risulta più sicuro e veloce degli altri sistemi. Sicuro perché la copia completa del repository è presente nel server ed è posseduta da tutti gli utenti che lavorano al progetto. Veloce perché opera in locale quindi c’è bisogno di connettersi al server solamente per eseguire un aggiornamento dei dati.

Stabile e popolare

Grazie a queste e a molte altre caratteristiche che non ho elencato, Git è diventato estremamente popolare in quest’ultimo periodo e viene usato da tutte le più grosse company della Silicon Valley (Google, Facebook, Linux, Android, Apple, Twitter, etc. etc.).

Come opera Git?

È molto importante capire questo punto per affrontare al meglio il processo di apprendimento.

I file controllati da Git possono assumere tre stati principali:

  • Modified: il file è stato modificato ma non è stato contrassegnato in modo da essere aggiunto al database
  • Staged: Il file modificato è stato contrassegnato in modo da essere inserito nel database
  • Committed: il file modificato è stato registrato nel database

Quindi il flusso di lavoro in Git funziona come segue:

  1. Modifico i file nella mia directory di lavoro e i file assumono lo stato di “modified”
  2. Eseguo l’operazione di stage dei file e li contrassegno in modo che vengano aggiunti al database nel commit successivo
  3. Eseguo il commit che immagazzina in modo permanente i miei file modificati all’interno del database

“Immaginate il flusso di lavoro di un ristorante. Il cuoco prepara il piatto (status = modified), non appena ha finito mette il piatto nel bancone (status = staged). A questo punto se il cuoco vuole aggiungere altri ingredienti può sempre prendere il piatto dal bancone, aggiungere gli ingredienti e rimettere il piatto nel bancone oppure può chiamare il cameriere e ordinargli di portare il piatto al cliente (status = committed)“.

Primo passo: installiamo Git

Installare Git è semplicissimo, vi basterà connettervi al  link e seguire l’installazione guidata:

http://git-scm.com/download

Per controllare che l’installazione sia avvenuta con successo, apriamo il nostro terminale (o prompt dei comandi) e digitiamo il comando:

$ git --version

Se è stato installato correttamente allora riceverete in risposta la versione di Git presente nel vostro sistema.

GUI per Git

Quando Git è installato nel sistema è possibile effettuare tutte le operazioni da riga di comando oppure utilizzare alcuni software che facilitano questo processo.

Windows

– SourceTree

– Github

– TortoiseGit 

– Msysgit 

Mac

– SourceTree 

– Github 

– GitX 

Linux

– SmartGit 

– GitCola 

Questa guida vi introdurrà alle operazioni da riga di comando così da aiutarvi a capire in modo più approfondito come opera questo sistema di controllo versione.

Configurazione di Git

Ora che è stato installato è opportuno personalizzare il nostro ambiente di lavoro. Questa configurazione è necessaria solo la prima volta, le informazioni da voi inserite rimarranno invariate dopo ogni aggiornamento. Tuttavia, se ne avete bisogno, potete cambiarle in ogni momento.

La prima cosa che occorre fare è impostare il proprio nome utente e indirizzo mail. Ciò è importante così che gli altri componenti del team possano riconoscere chi ha fatto determinati cambiamenti. Per far ciò basterà eseguire i seguenti comandi nel terminale:

$ git config --global user.name "Mario Rossi"
$ git config --global user.email "mario.rossi@gmail.com"

L’opzione –global ci permette di eseguire questa modifica una sola volta, dopo di che Git utilizzerà sempre queste informazioni per qualsiasi operazione fatta sul sistema.

Se volete controllare le informazioni che avete inserito, vi basterà eseguire:

$ git config --global user.name
$ git config --global user.email

Ognuna di queste istruzioni vi restituirà le informazioni che avete inserito.

Conclusioni

In questa prima guida abbiamo imparato quindi cos’è un sistema di version control, perché Git è la scelta migliore tra i tanti, come installarlo e come eseguire la prima configurazione.

Nel prossimo articolo di questa guida Git, invece, impareremo ad utilizzare questo sistema in modo da poter gestire al meglio i nostri progetti.


INTRODUZIONE A GIT: INDICE LEZIONI

– Cos’è e come installarlo
– Quali sono le funzioni principali di Git
– Usare Git come strumento di collaborazione online