Git (software)

Da Wikipedia, l'enciclopedia libera.

Git
Sviluppatore	inizialmente Linus Torvalds, attualmente Junio Hamano
Ultima versione	1.5.3 / 1 settembre 2007
SO	POSIX
Genere	Sistema di controllo versione
Licenza	GPL
Sito web	http://git.or.cz/

Git è un sistema software di controllo versione distribuito, creato da Linus Torvalds.

La progettazione di Git è stata ispirata da BitKeeper e da Monotone. Git era stato pensato inizialmente solamente come motore a basso livello che altri potevano usare per scrivere un front-end. Tuttavia, il progetto Git è in seguito diventato un sistema completo di controllo versione, direttamente utilizzabile da riga di comando. Vari importanti progetti software adesso usano Git per il loro controllo versione, e principalmente il kernel di Linux.

Indice 1 Nome 2 Caratteristiche 3 Storia iniziale 4 Implementazione 5 Portabilità 6 Progetti correlati 6.1 Progetti che si basano su Git 6.2 Interfacce Web 6.3 Visualizzazione della cronologia

[modifica] Nome

Il nome dato al progetto da Linus Torvalds è un termine gergale britannico per indicare una persona stupida o sgradevole. Linus lo spiegò così:

	« Sono un egoista bastardo, e do a tutti i miei progetti un nome che mi riguardi. Prima Linux, adesso Git. »

Il wiki ufficiale di Git fornisce alcune spiegazioni alternative per il nome. Per esempio, a causa della difficoltà di utilizzo delle prime versioni, il programma è stato definito "il sistema di controllo versione progettato per farti sentire più stupido di quanto tu lo sia".

[modifica] Caratteristiche

Il progetto di Git è la sintesi dell'esperienza di Torvalds nel mantenere un grande progetto di sviluppo distribuito, della sua intima conoscenza delle prestazioni del file system, e di un bisogno urgente di produrre un sistema soddisfacente in poco tempo. Queste influenze hanno condotto alle seguenti scelte implementative:

• Forte supporto allo sviluppo non lineare.

Git supporta diramazione e fusione (branching and merging) rapide e comode, e comprende strumenti specifici per visualizzare e navigare una cronologia di sviluppo non lineare. Un'assunzione centrale in Git è che una modifica verrà fusa più spesso di quanto sia scritta, dato che viene passata per le mani di vari revisori. Torvalds stesso fa la maggior parte delle fusioni e una piccola parte delle correzioni dirette al codice, perciò egli stesso ha dimostrato che questo aspetto funziona bene.

• Sviluppo distribuito.

Similmente a Darcs, BitKeeper, Mercurial, SVK, e Monotone, Git dà a ogni sviluppatore una copia locale dell'intera cronologia di sviluppo, e le modifiche vengono copiate da un tale repository a un altro. Queste modifiche vengono importate come diramazioni aggiuntive di sviluppo, e possono essere fuse allo stesso modo di una diramazione sviluppata localmente.

• I repository possono essere pubblicati facilmente tramite HTTP, FTP, ssh, rsync, o uno speciale protocollo git.

Git ha anche un'emulazione del server CVS, che consente di usare gli esistenti client CVS e plugin per IDE per accedere ai repositori Git.

• Gestione efficiente di grandi progetti.

Git è molto veloce e scalabile. È tipicamente un ordine di grandezza più veloce degli altri sistemi di controllo versione, e due ordini di grandezza più veloce per alcune operazioni.

• Autenticazione crittografica della cronologia.

La cronologia di Git viene memorizzata in modo tale che il nome di una revisione particolare (secondo la terminologia Git, una "commit") dipende dalla completa cronologia di sviluppo che conduce a tale commit. Una volta che è stata pubblicata, non è più possibile cambiare le vecchie versioni senza che ciò venga notato. (Anche Monotone ha questa proprietà.)

• Progettazione del toolkit.

Git è un insieme di programmi di base scritti in linguaggio C, e molti script di shell che forniscono comodi incapsulamenti. È facile concatenare i componenti per fare altre cose utili.

• Strategie di fusione intercambiabili.

Come parte della progettazione del suo toolkit, Git ha un modello ben definito di una fusione incompleta, e ha più algoritmi per tentare di completarla. Se tutti gli algoritmi falliscono, tale fallimento viene comunicato all'utente e viene sollecitata una fusione manuale. Pertanto è facile sperimentare con nuovi algoritmi di fusione.

• La spazzatura si accumula fino a quando viene raccolta.

Quando si abortisce un comando o si scartano delle modifiche si lasciano degli oggetti inutilizzabili nel database. Tipicamente, questi sono solo una piccola parte della cronologia continuamente crescente degli oggetti utili, ma il comando di recupero dello spazio, git-gc --prune, può richiedere parecchio tempo. Una proprietà di Git che ha prodotto considerevoli controversie è il fatto che prende istantanee di interi alberi di directory di file invece che di singoli file. I primi sistemi di controllo versione del codice sorgente, SCCS and RCS, lavoravano su singoli file, e vantavano il risparmio di spazio ottenibile dalla codifica a delta delle versioni simili. I successivi sistemi di controllo versione mantennero questo concetto di identità dei file al variare delle revisioni di un progetto.

Git rifiuta questo concetto e non registra esplicitamente le relazioni di revisione di file a nessun livello all'interno dell'albero del codice sorgente. Ciò comporta conseguenze rilevanti:

• È effettivamente leggermente più costoso esaminare la cronologia di modifiche di un singolo file rispetto a quella dell'intero progetto.

Per ottenere la cronologia delle modifiche che riguardano un dato file, Git deve ripercorrere la cronologia complessiva e poi determinare quali modifiche hanno riguardato quel file. Questo metodo di esaminare la cronoogia, comunque, permette a Git di produrre con altrettanta efficienza una singola cronologia che mostra le modifiche a un arbitrario insieme di file. Per esempio, una sottodirectory dell'albero dei sorgenti più un file di intestazione (header) globale a loro associato.

• I cambiamenti di nome di file e directory vengono gestiti in modo implicito invece che esplicito.

Una grossa lamentela degli utenti di CVS è che usa il nome di un file per identificare la sua cronologia di revisioni, perciò non è possibile spostare un file o cambiargli nome file senza o interrompere la sua cronologia, o cambiare nome alla cronologia e rendendo quindi inaccurata la cronologia. La maggior parte dei sistemi di controllo versioni successivi a CVS risolvono questo problema dando a ogni file un nome interno univoco di lunga vita che sopravvive al cambiamento di nome. Git non memorizza un identificatore di questo genere, e questo viene vantato come un vantaggio. I file di codice sorgente vengono talvolta spezzati o fusi oltre che semplicemente cambiati di nome, e memorizzare tali modifiche come un semplice cambiamento di nome congelerebbe per sempre nella cronologia una descrizione inaccurata di quello che è successo. Git affronta la questione rilevando i cambiamenti di nome mentre sfoglia la cronologia delle istantanee invece di memorizzarli quando si prende un'istantanea. (In breve, dato un file alla revisione N, un file con lo stesso nome alla revisione N-1 è il suo antenato di default. Tuttavia, quando non ci sono file dal nome simile alla versione N-1, Git cerca un file che esisteva solamente alla versione N-1 e che abbia un contenuto molto simile a quello del nuovo file.) Questo richiede più lavoro di CPU ogni volta che si esamina la cronologia, e alcune opzioni per calibrare l'euristica.

Inoltre, la gente talvolta è turbata dal modello di immagazzinamento:

• Impaccamento esplicito periodico degli oggetti.

Git immagazina ogni nuovo oggetto in un file distinto. Sebbene tale file sia in un formato compresso, può occupare parecchio spazio ed essere inefficiente. Questo problema è risolto dall'uso di "impaccamenti" ("packs") che immagazzinano molti oggetti in un solo file (o in un flusso di dati via rete), che hanno essi stessi una compressione delta. Gli impaccamenti vengono compressi con l'euristica che i file con lo stesso nome sono probabilmente simili, funzionano correttamente anche se questo supposizione non è valida. Gli oggetti appena creati (cioè appena aggiunti alla cronologia) sono ancora immagazzinati singolarmente, e per mantenere l'efficienza si dovrebbe effettuare periodicamente un impaccamento.

Git implementa varie strategie di fusione; in fase di fusione si può scegliere un comportamento diverso da quello di default:

• risolvi (resolve): Questo è l'algoritmo tradizionale di fusione a 3 vie.
• ricorsivo (recursive): Questo è l'algoritmo di default quando si estrae o si fonde un ramo, ed è una variante dell'algoritmo di fusione a 3 vie. "Quando ci sono più antenati comuni possono esser usati per una fusione a 3 vie, crea un albero di fusione degli antenati comuni e lo utilizza come albero di riferimento per la fusione a 3 vie. Questo risulta produrre meno conflitti di fusione senza provocare mal-fusioni dalle prove effettuate su effettive fusioni di rilascio prese dalla cronologia di sviluppo del kernel Linux 2.6. Inoltre, questo può rivelare e gestire i cambiamenti di nome."
• piovra (octopus): Questo è l'algoritmo di default quando si fondono più di due teste.

[modifica] Storia iniziale

Lo sviluppo di Git è iniziato dopo che molti sviluppatori del kernel di Linux sono stati costretti ad abbandonare l'accesso ai sorgenti tramite il sistema proprietario BitKeeper. La possibilità di utilizzare BitKeeper gratuitamente era stata ritirata dal detentore dei diritti d'autore Larry McVoy dopo avere sostenuto che Andrew Tridgell aveva fatto il reverse engineering dei protocolli di BitKeeper, violando la licenza d'uso di BitKeeper. Alla conferenza Linux.Conf.Au del 2005, Tridgell dimostrò nel suo intervento che il procedimento di reverse engineering che aveva usato era semplicemente collegarsi con telnet alla porta appropriata di un server Bitkeeper e digitare "help".

Torvalds voleva un sistema distribuito che potesse usare come BitKeeper, ma nessuno dei sistemi disponibili gratuitamente soddisfaceva i suoi bisogni, particolarmente il suo bisogno di velocità. Ecco un messaggio e-mail che scrisse il 7 aprile 2005 mentre stava scrivendo il primo prototipo, tradotto in italiano:

« Tutti i sistemi di controllo versione che ho preso in considerazione rendono [il lavoro] difficile. Una delle cose (in realtà, la cosa principale) a cui ho lavorato è rendere quel procedimento realmente efficiente. Se ci vuole mezzo minuto per applicare una patch, e ci si deve ricordare i confini delle modifiche applicate, ecc. (e francamente, si potrebbe considerare mezzo minuto poco per la maggior parte dei sistemi di controllo versione che ci sono in giro, e per un progetto della dimensione di Linux), allora una serie di 250 e-mail (che non è affatto inaudito quando mi sincronizzo con Andrew, per esempio) richiede due ore. Se una delle patch intermedie non si può applicare, le cose vanno male male male. Ora, neanche BitKeeper era proprio velocissimo (in effetti, confrontato a qualunque altra cosa, BitKeeper è velocissimo, spesso uno o due ordini di grandezza megliore), e richiedeva circa 10–15 secondi per ogni e-mail quando mi fondevo con Andrew. Tuttavia, con BitKeeper quello non era un problema tanto grosso, dato che le fusioni BitKeeper<->BitKeeper sono più semplici, e non ho mai dovuto fare un più lento merge manuale con gli altri sviluppatori principali. Perciò il merge, in un sistema di controllo versione basato sull'applicazione di patch dovrebbe essere più veloce di BitKeeper. Il che è veramente veramente difficile. E per questo sto scrivendo alcuni script per tentare di tener traccia delle cose in modo nettamente più veloce. Le indicazioni iniziali sono che dovrei essere in grado di farlo con la stessa velocità della sola applicazione delle patch. Ma francamente, sono al massimo a metà del lavoro, e se mi imbatterò in qualche ostacolo può darsi che non sarà affatto così. La ragione per cui posso fare questo così velocemente è che i miei script non saranno un sistema di controllo versione, saranno un tipo di cosa molto specifica del tipo “log dello stato di Linus”. Ciò renderà il merge tramite patch molto più veloce, e quindi fattibile. (Se per applicare una patch ci vogliono tre secondi, anche una lunga serie di patch non è un problema: se vengo avvertito entro uno o due minuti che il merge è fallito a metà strada, va bene, in tal caso posso procedere a correggerlo a mano. Questo è il motivo per cui la latenza è critica — se dovessi fare le cose del tutto “offline”, per definizione non sarei in grado di correggere i problemi quando accadono).  »

Linus aveva vari criteri di progettazione:

1. Prendi CVS come esempio di che cosa non fare; se hai un dubbio, fai l'esatto contrario.

Per citare Linus, che parlava un po' ironicamente:

1. “Per i primi 10 anni di manutenzione del kernel, usavamo letteralmente tarball (archivi compressi) e patch, che è un sistema di gestione del codice sorgente molto migliore di CVS. Poi ho finito per usare CVS per 7 anni in un'azienda [presumibilmente Transmeta] e lo odio appassionatamente.

Quando dico che odio CVS appassionatamente, devo anche dire che se ci sono utenti SVN (Subversion) tra il pubblico, potreste volervene andare. Perché a causa del mio odio di CVS ritengo Subversion il progetto meno sensato che sia mai cominciato. Per un po' lo slogan di Subversion era ‘CVS fatto bene’, o qualcosa di simile, e se incominci con quel tipo di slogan, non puoi andare da nessuna parte. Non c'è modo di fare CVS bene.”

1. Supporto di un flusso di lavoro distribuito, simile a BitKeeper. Come BitKeeper, Git non usa un server centralizzato.

   “BitKeeper non è solamente il primo sistema di controllo dei sorgenti che abbia mai pensato che valesse la pena usare; è stato anche il sistema che mi ha fatto capire perché ce ne sia effettivamente bisogno, e come si possa operare in modo efficace.

Perciò, sebbene da un punto di vista tecnico Git è molto molto diverso da BitKeeper (il che era un altro obiettivo di progettazione, perché volevo rendere chiaro che non era un clone di BitKeeper), molti dei procedimenti che usiamo con Git vengono direttamente dai procedimenti che abbiamo imparato da BitKeeper.”

1. Salvaguardia dalla corruzione dei dati, sia accidentale che intenzionale
2. Altissime prestazioni

I primi tre criteri non erano soddisfatti da alcun preesistente sistema di controllo versione eccetto Monotone, e il quarto ha escluso anche Monotone. Perciò, immediatamente dopo lo sviluppo della versione 2.6.12-rc2 del kernel di Linux, si è dedicato a scrivere il suo.

Lo sviluppo di Git è cominciato il 3 aprile 2005. Il progetto è stato annunciato il 6 aprile 2005, ed è stato usato per gestire il proprio sorgente a partire dal 7 aprile 2005. La prima fusione di più branch in uno è stata fatta il 18 aprile 2005. Torvalds ha raggiunto i suoi obiettivi in termini di prestazioni: il 29 aprile 2005, Git riusciva ad applicare 6 o 7 patch a Linux in un secondo. Il 16 giugno 2005 è stata rilasciata la versione 2.6.12 del kernel di Linux, la prima gestita con Git.

Sebbene fortemente influenzato da BitKeeper, Torvalds ha deliberatamente tentato di evitare approcci convenzionali, il che ha prodotto un sistema molto innovativo.

Torvalds ha sviluppato il sistema fino a quando è diventato usabile da utenti tecnici, poi, il 26 luglio 2005, ha ceduto la manutenzione a Junio Hamano, un importante contributore al progetto. Hamano è stato il responsabile della versione 1.0, rilasciata il 21 dicembre 2005, e rimane oggi il manutentore.

[modifica] Implementazione

Le primitive di Git non costituiscono inerentemente un sistema di controllo versione. Per esempio, git non fornisce una numerazione progressiva delle revisioni del software.

Torvalds spiega che,

« in molti modi si può considerare git come un filesystem — è indirizzabile in base al contenuto, e include il concetto di versione, ma io in realtà lo ho progettato guardando il problema dal punto di vista di una persona esperta di filesystem (beh, i kernel sono quello che faccio), e effettivamente ho assolutamente zero interesse nel creare un sistema tradizionale di gestione della configurazione software.  »

(Si noti che in seguito la suo opinione è cambiata.)

Git ha due struttura dati, un indice modificabile che mantiene le informazioni sul contenuto della prossima revisione, e un database di oggetti a cui si può solo aggiungere e che contiene quattro tipi di oggetti:

• Un oggetto blob è il contenuto di un file. Gli oggetti blob non hanno nome, data, ora, né altri metadati. Git memorizza ogni revisione di un file come un oggetto blob distinto.
• Un oggetto albero è l'equivalente di una directory: contiene una lista di nomi di file, ognuno con alcuni bit di tipo e il nome di un oggetto blob o albero che è il file, il link simbolico, o il contenuto di directory. Questo oggetto descrive un'istantanea dell'albero dei sorgenti.
• Un oggetto commit (revisione) collega gli oggetti albero in una cronologia. Contiene il nome di un oggetto albero (della directory dei sorgenti di livello più alto), data e ora, un messaggio di archiviazione (log message), e i nomi di zero o più oggetti di commit genitori. Le relazioni tra i blob si possono trovare esaminando gli oggetti albero e gli oggetti commit.
• Un oggetto tag (etichetta) è un contenitore che contiene riferimenti a un altro oggetto può tenere meta-dati aggiuntivi riferiti a un altro oggetto. Il suo uso più comune è memorizzare una firma digitale di un oggetto commit corrispondente a un particolare rilascio dei dati gestiti da Git.

Ogni oggetto è identificato da un codice hash SHA-1 del suo contenuto. Git calcola tale codice hash, e usa questo codice come nome dell'oggetto.

L'indice è uno strato intermedio che serve da punto di collegamento fra il database di oggetti e l'albero di lavoro.

Il database ha una struttura semplice. L'oggetto viene messo in una directory che corrisponde ai primi due caratteri del suo codice hash; Il resto del codice costituisce il nome del file che contiene tale oggetto. Quando si aggiunge un nuovo oggetto, questo viene memorizzato per intero dopo averlo compresso con zlib.

Questo fatto può far sì che in poco tempo venga occupato molto spazio sul disco fisso, perciò gli oggetti possono essere combinati in pack, che usano la compressione delta (memorizzando solo le modifiche tra un blob e un altro blob) per risparmiare spazio.

[modifica] Portabilità

Git è pensato per funzionare in ambiente Linux, ma può essere portato su altri sistemi operativi Unix-like, tra cui BSD, Solaris e Darwin. Git è estremamente veloce su sistemi basati su POSIX come i suddetti.

Git può essere portato anche in ambiente Windows. Ci sono in effetti due possiblità per farlo: quella "ufficiale" richiede di installare e usare l'ambiente Cygwin (che è una emulazione POSIX); l'alternativa è un port nativo, cioè una modifica del codice sorgente per adattarlo a Windows. Git su Windows è sensibilmente più lento, a causa del massiccio uso da parte di Git di funzionalità POSIX del file system che devono essere emulate in ambiente Windows. Inoltre, molta gente trova che l'installazione di Cygwin sia troppo grande e invasiva per un tipico utente di Windows.

Esistono molti progetti open source che per ora hanno esplicitamente rinunciato a usare Git a causa della sua poca compatibilità con Windows, tra cui Mozilla e Ruby.

Un port nativo per Windows, con il nome di "WinGit", si avvicina al completamento utilizzando il compilatore MinGW, ma l'interfaccia-utente è ancora a riga di comando.

In alcuni casi (particolarmente per l'accesso remoto anonimo), si possono ammettere gli utenti Windows tramite il git-cvsserver (che emula un server CVS, consentendo l'uso di client CVS per Windows). Altre alternative sono:

• Un client GIT basato su EclipseIDE, che usa un'implementazione in puro Java delle funzioni interne di GIT
• Un'estensione di Windows Explorer basata su libgit + cygwin.dll (è già iniziato un progetto per unsoftware simile a TortoiseCVS)

Incapsulando in una libreria le operazioni di git a livello più basso in teoria consentirebbe la re-implementazione delle componenti di livello più basso per Windows senza dover riscrivere il resto.

Questi sforzi in generale dovrebbero aiutare a migliorare le prestazioni e la facilità di installazione su Windows; non è chiaro però se aiuteranno a risolvere la questione dei diversi modelli di autorizzazione.

[modifica] Progetti correlati

[modifica] Progetti che si basano su Git

• git-gui è una GUI basata su Tk per le operazioni più common di Git. Questo progetto è incorporato in Git versione 1.5.0 e successive. (Si lancia con il comando "git gui").
• Cogito (homepage) - Petr Baudiš ha mantenuto un insieme di script chiamato Cogito (precedentemente git-pasky), che formano un sistema di controllo versione che usa Git come backend. Lo sviluppo di Cogito è stato interrotto nell'aprile 2007 quando la sua funzionalità è stata ritenuta ridondante con gli strumenti di frontend di Git, comunemente chiamati "porcellana" ("porcelain").
• StGIT (homepage) - Stacked GIT è un'applicazione Python che fornisce funzionalità simili a Quilt (homepage) (cioè aggiungere/togliere patch a/da uno stack) appoggiandosi a Git, per gestire le patch fino a quando vengo fuse.
• pg (Patchy GIT) è un'interfaccia a Git costituita da script di shell per aiutare l'utente a gestire un insieme di patch ai file. pg è in un certo senso simile a Quilt o a StGIT, ma ha un insieme di caratteristiche leggermente diverso. pg non viene più mantenuto dal 29 aprile, 2007
• DarcsGit è un'estensione di Darcs che gli consente di interagire con i repositori Git.
• bzr-git è un plugin per Bazaar per leggere gli alberi di Git. Sebbene sia ancora in fase alpha, fornisce abbastanza supporto per la visualizazione bzrk.

[modifica] Interfacce Web

• gitweb – un'implementazione in Perl mantenuta da Kay Sievers. Usata presso dal sito kernel.org
• wit – Un'implementazione Python mantenuta da Christian Meder.
• gitarella – un'implementazione Ruby mantenuta da Diego Pettenò
• git-php – un'implementazione PHP di Zack Bartel
• cgit - un'implementazione C di Lars Hjemli

[modifica] Visualizzazione della cronologia

• Gitk è una semplice GUI Tcl/Tk per consultare facilmente la cronologia dei repository Git, distribuita con Git.
• QGit (SourceForge project page) è una GUI Qt per consultare la cronologia dei repository, simile a Gitk.
• Giggle è una GUI GTK+ ispirata da Gitk.
• gitview è una GUI Python e Gtk+, distribuita con Git.
• tig è un'interfaccia testuale a pieno schermo basata su ncurses per Git".
• git-browser è un programma di consultazione della cronologia scritto in JavaScript che è utilizzabile in un browser web. (Pare che non consenta di esaminare le modifiche al codice, ma solo le descrizioni.)