Perché tutti usano Git in modo centralizzato?

Ho usato Git nelle mie ultime due società per il controllo delle versioni. Da quanto ho sentito, circa il 90% delle aziende utilizza Git su altri sistemi di controllo delle versioni.

Uno dei maggiori punti di forza di Git è che è decentralizzato, ovvero tutti i repository sono uguali; non esiste un deposito / fonte di verità centrale. Questa era una caratteristica sostenuta da Linus Torvalds .

Ma sembra che ogni azienda abbia usato Git in modo centralizzato, proprio come uno userebbe SVN o CVS. C'è sempre un repository centrale su un server (di solito su GitHub) da cui le persone estraggono e spingono. Non ho mai visto o sentito parlare (nella mia esperienza certamente limitata) persone che usano Git nel modo veramente decentralizzato in cui era previsto, cioè spingendo e tirando verso i repository di altri colleghi quando lo ritenevano opportuno.

Le mie domande sono:

1. Perché in pratica le persone non usano un flusso di lavoro distribuito per Git?
2. La capacità di lavorare in modo distribuito è persino importante per il controllo delle versioni moderne o suona semplicemente bene?

modificare

Mi sono reso conto che non avevo trovato il tono corretto nella mia domanda originale. Sembrava che mi chiedessi perché qualcuno avrebbe lavorato in modo centralizzato quando un sistema di controllo di versione distribuito (DVCS) era ovviamente superiore. In realtà, ciò che intendevo dire era che non vedo alcun beneficio per DVCS . Eppure spesso ascolto persone che predicano la sua superiorità, mentre il mondo reale sembra concordare con il mio punto di vista.

Ahh, ma in realtà si sta utilizzando git in modo decentrato!

Confrontiamo il predecessore di git in mindshare, svn. Subversion aveva solo un "repo", una fonte di verità. Quando hai fatto un commit, è stato per un singolo repository centrale, a cui si stavano impegnando anche tutti gli altri sviluppatori.

Questo tipo di funzionamento ha funzionato, ma ha portato a numerosi problemi, il più grande dei quali è il temuto conflitto di unione . Questi si sono rivelati ovunque da fastidiosi a incubi da risolvere. E con una sola fonte di verità, avevano la cattiva abitudine di bloccare il lavoro di tutti fino a quando non fossero stati risolti. I conflitti di unione certamente esistono con git, ma non sono eventi che fermano il lavoro e sono molto più facili e veloci da risolvere; generalmente influenzano solo gli sviluppatori coinvolti nelle modifiche in conflitto, piuttosto che tutti.

Poi c'è l'intero singolo punto di fallimento e i problemi che ne derivano. Se il tuo repository svn centrale muore in qualche modo, sei tutto fregato fino a quando non può essere ripristinato dal backup, e se non c'erano backup, sei doppiamente fregato. Ma se il repository git "centrale" muore, puoi ripristinarlo dal backup o anche da una delle altre copie del repository che si trovano sul server CI, sulle stazioni di lavoro degli sviluppatori, ecc. Puoi farlo proprio perché sono distribuiti, e ogni sviluppatore ha una copia di prima classe del repository.

D'altra parte, poiché il tuo repository git è un repository di prima classe a sé stante, quando esegui il commit, i tuoi commit vanno nel tuo repository locale. Se vuoi condividerli con altri o con la fonte centrale di verità, devi farlo esplicitamente spingendo verso un telecomando. Altri sviluppatori possono quindi eliminare tali modifiche quando è conveniente per loro, piuttosto che dover controllare costantemente svn per vedere se qualcuno ha fatto qualcosa che li rovinerà.

Il fatto che, invece di spingere direttamente verso altri sviluppatori, invii le modifiche indirettamente ad essi tramite un altro repository remoto, non importa molto. La parte importante dal nostro punto di vista è che la tua copia locale del repository è un repository a sé stante. In svn, la fonte centrale della verità è imposta dal design del sistema. In effetti, il sistema non ha nemmeno questo concetto; se esiste una fonte di verità, viene decisa esternamente.

Quando il server di build (che si sta utilizzando CI, giusto?) Crea un accumulo, in cui ci si tira da? Certo, una build di integrazione che si potrebbe sostenere non ha bisogno di "un vero repository", ma sicuramente una build di distribuzione (cioè ciò che dai al cliente).

In altre parole: frammentazione. Se si designa un repository come "repository" e si nominano tutori che controllano le richieste pull, si ha un modo semplice per soddisfare la richiesta "dammi un software build" o "Sono nuovo del team, dov'è il codice?"

Il punto di forza del DVCS non è tanto l'aspetto peer-to-peer, ma il fatto che sia gerarchico . Modifico il mio spazio di lavoro, quindi mi impegno a locale. Una volta completata la funzionalità, unisco i miei commit e li spingo sul mio telecomando. Quindi chiunque può vedere il mio codice provvisorio, fornire feedback, ecc. Prima che crei una richiesta pull e un amministratore del progetto lo unisca nel repository One True.

Con i CVCS tradizionali ti impegni o meno. Questo va bene per alcuni flussi di lavoro (io uso entrambi i tipi VCS per progetti diversi), ma non si adatta a un progetto pubblico o OSS. La chiave è che DVCS ha più passaggi, che richiedono più lavoro, ma forniscono un modo migliore per integrare il codice da estranei attraverso un processo integrato che consente una migliore visibilità in ciò che viene archiviato. Usarlo in modo centralizzato significa che puoi ancora avere quel gold standard dello stato attuale del progetto e allo stesso tempo fornire un miglior meccanismo di condivisione del codice.

Non so come definire "tutti", ma il mio team ha "un repository centrale su un server" e anche di tanto in tanto estraiamo dai repository di altri colleghi senza passare attraverso quel repository centrale. Quando lo facciamo, andiamo comunque attraverso un server, perché scegliamo di non inviare per e-mail le patch sul luogo, ma non tramite il repository centrale. Questo in genere accade quando un gruppo sta collaborando su una particolare funzione e desidera tenersi aggiornato l'uno con l'altro, ma non ha ancora interesse a pubblicare la funzione per tutti. Naturalmente, dal momento che non siamo dei silos-lavoratori segreti, queste situazioni non durano a lungo, ma DVCS offre la flessibilità di fare ciò che è più conveniente. Siamo in grado di pubblicare un ramo di funzionalità o meno secondo il gusto.

Ma il 90% + delle volte, sicuramente, passiamo attraverso il repository centrale. Quando non mi interessa alcun particolare cambiamento o il lavoro di un particolare collega, è più conveniente, e si adatta meglio, tirare "tutte le modifiche dei miei colleghi che sono state esaminate nel repository centrale", piuttosto che estrarre separatamente le modifiche da ciascuna di N colleghi. DVCS non sta cercando di impedire che il "pull dal repository principale" sia il flusso di lavoro più comune, sta cercando di impedire che sia l'unico flusso di lavoro disponibile.

"Distribuito" significa che tutti i repository sono tecnicamente equivalenti per quanto riguarda il gitsoftware, ma non ne consegue che abbiano tutti lo stesso significato per quanto riguarda gli sviluppatori e i nostri flussi di lavoro. Quando rilasciamo ai client o ai server di produzione, il repository che utilizziamo ha un significato diverso da un repository utilizzato solo da uno sviluppatore sul proprio laptop.

Se "veramente decentrato" significa "non ci sono repos speciali", quindi non penso che è quello che Linus significa campione, dato che in punto di fatto che non mantiene repo speciali che sono più importante nel grande schema delle cose, che è un clone casuale di Linux che ho creato ieri e ho intenzione di usare solo per sviluppare qualche piccola patch e poi eliminarla una volta accettata la patch. gitnon privilegia il suo repository rispetto al mio, ma Linus lo privilegia. Il suo "è lo stato attuale di Linux", il mio no. Quindi i cambiamenti naturali tendonopassare attraverso Linus. Il punto di forza del DVCS rispetto al VCS centralizzato non è che non ci deve essere un centro di fatto, è che i cambiamenti non devono passare attraverso alcun centro perché (i conflitti lo consentono) chiunque può fondere qualcosa.

I sistemi DVCS sono anche costretti , poiché sono decentralizzati, a fornire alcune utili funzionalità basate sul fatto che è necessario disporre di una cronologia completa (ovvero un repository) a livello locale per poter fare qualsiasi cosa. Ma se ci pensate, non c'è motivo fondamentale per cui non sia possibile configurare un VCS centralizzato con una cache locale che mantenga obsoleta l'intera cronologia delle operazioni di sola lettura (penso che Perforce abbia un'opzione per questa modalità, ma non ho mai usato Perforce). O in linea di principio potresti configurare gitcon il tuo.git/directory su un filesystem montato in remoto per emulare la "caratteristica" di SVN che non funziona quando non si dispone di una connessione di rete. In effetti, DVCS forza l'impianto idraulico ad essere più robusto di quanto si possa cavare in un VCS centralizzato. Questo è un effetto collaterale (molto gradito) e ha contribuito a motivare la progettazione di DVCS, ma questa distribuzione di responsabilità a livello tecnico non è la stessa del decentramento completo di ogni responsabilità umana .

La cosa interessante della natura del DVCS è che se altre persone lo usano in modo distribuito, probabilmente non lo sapresti se non interagiscono direttamente con te. L'unica cosa che puoi dire definitivamente è che tu e i tuoi compagni di squadra diretti non usate git in questo modo. Ciò non richiede una politica a livello aziendale. Quindi vi chiedo, perché non si usa git in maniera decentrata?

Per risolvere la tua modifica, forse hai bisogno di un po 'di esperienza lavorando con un vero controllo centralizzato della versione per apprezzare le differenze, perché sebbene possano sembrare sottili, sono pervasive. Queste sono tutte cose che il mio team fa effettivamente sul lavoro che non potevamo fare quando avevamo centralizzato VCS:

• Avere un elenco molto piccolo di sviluppatori core con accesso commit al repository "centrale" per ciascun microservizio. Tutti gli altri possono lavorare con le forcelle e inviare tramite richieste pull.
• Può impegnarsi molto più frequentemente, di solito più volte all'ora rispetto a una o due volte al giorno.
• Può creare rami per qualsiasi motivo per coordinarsi temporaneamente con i colleghi e spingerlo verso di esso e tirare da esso più volte al giorno, quindi schiacciarlo quando è pronto per condividerlo con un gruppo più grande. Hai idea di quanto sia difficile ottenere il permesso di creare un ramo temporaneo per qualcosa di simile in un CVCS tradizionale?

A rischio di sembrare vecchio per averlo detto, davvero non sai quanto sia facile averlo.

Penso che la tua domanda provenga da una mentalità (comprensibile) sempre connessa . cioè il server ci "verità" centrale è sempre (o quasi sempre) disponibile. Sebbene ciò sia vero nella maggior parte degli ambienti, ho lavorato in almeno uno che era tutt'altro.

Un progetto di simulazione militare su cui il mio team ha lavorato diversi anni fa. Tutto il codice (stiamo parlando di una base di codici da 1 miliardo di dollari) doveva (per legge / accordo internazionale, uomini in abito scuro venire se non lo facevi) essere su macchine fisicamente isolate da qualsiasi connessione Internet . Ciò significava che la solita situazione di ognuno di noi aveva 2 PC, uno per scrivere / eseguire / testare il codice, l'altro per cose di Google, controllare la posta elettronica e così via. E c'era una rete locale all'interno del team di queste macchine, ovviamente non collegata in alcun modo a Internet.

La "fonte centrale di verità" era una macchina su una base militare, in una stanza sotterranea senza finestre tutta in cemento (edificio rinforzato, yada-yada). Quella macchina anche non aveva alcuna connessione a Internet.

Periodicamente, sarebbe compito di qualcuno trasportare (fisicamente) un disco con il repository git (contenente tutte le nostre modifiche al codice) alla base dell'esercito - che era a diverse centinaia di chilometri di distanza, quindi, puoi immaginare.

Inoltre, in sistemi molto grandi in cui ci sono molti team. Ognuno di essi avrà generalmente il proprio repository "centrale", che risale quindi al repository centrale "centrale" effettivo (livello di dio). Conosco almeno un altro appaltatore che ha fatto lo stesso trattino repository git con il proprio codice.

Inoltre, se consideri qualcosa sulla scala del kernel Linux ... Gli sviluppatori non inviano semplicemente una richiesta pull a Linus stesso. È essenzialmente una gerarchia di repository - ognuno dei quali era / è "centrale" per qualcuno / qualche squadra.

La natura disconnessa di git significa che può essere utilizzato in ambienti in cui gli strumenti di controllo del codice sorgente collegati (ad esempio SVN, per esempio) non possono essere utilizzati - o non possono essere utilizzati con la stessa facilità.

Alla fine, stai costruendo un prodotto. Questo prodotto rappresenta il tuo codice in un singolo momento. Detto questo, il tuo codice deve fondersi da qualche parte . Il punto naturale è un server ci o un server centrale da cui viene creato il prodotto e ha senso che questo punto centrale sia un repository git.

L'aspetto distribuito di un DVCS si manifesta continuamente nello sviluppo open source, sotto forma di biforcazione. Ad esempio, alcuni dei progetti a cui contribuisco sono stati abbandonati dall'autore originale e ora hanno un sacco di forchette in cui i manutentori talvolta traggono funzionalità specifiche l'una dall'altra. Anche in generale, i progetti OSS prendono contributi esterni tramite richiesta pull, piuttosto che concedere a persone casuali l'accesso push al repository di verità.

Questo non è un caso d'uso molto comune quando si costruisce un prodotto concreto con una versione ufficiale specifica, ma nel mondo F / OSS è la norma, non l'eccezione.

Perché tutti usano git in modo centralizzato?

Non ci siamo mai incontrati, come mai dici tutti? ;)

In secondo luogo, ci sono altre funzionalità che trovi in ​​Git ma non in CVS o SVN. Forse sei solo tu a supporre che questa debba essere l' unica caratteristica per tutti .

Sicuramente molte persone possono usarlo centralizzato come CVS o SVN. Ma non dimenticare l'altra caratteristica intrinsecamente fornita con un VCS distribuito: tutte le copie sono più o meno "complete" (tutti i rami e la cronologia completa è disponibile) e tutti i rami possono essere estratti senza connettersi a un server.

Ritengo che questa sia un'altra caratteristica da non dimenticare.

Sebbene non sia possibile farlo con CVS e SVN out-of-box, Git può essere utilizzato centralmente come i precedenti senza problemi.

Quindi sono in grado di eseguire il commit delle mie modifiche, magari comprimere i work-in-progress insieme, quindi recuperare e reimpostare il mio lavoro sul ramo di sviluppo principale.

Altre caratteristiche che escono fuori dalla scatola con Git:

• il segno crittografico si impegna
• rebasing (riordino e commit di squash; modifica commit, non solo messaggio)
• raccogliere le ciliegie
• sezionare la storia
• filiali locali e modifiche stashing (chiamate "scaffalature" in Wikipedia)

Vedi anche queste tre tabelle in Wikipedia - Confronto del software di controllo versione :

• Caratteristiche

• Comandi di base

• Comandi avanzati

Quindi, di nuovo, forse il modo decentralizzato non è l' unica caratteristica che fa sì che le persone lo usino.

1. Perché in pratica le persone non usano un flusso di lavoro distribuito per Git?

Chiunque contribuisca o ospiterà un progetto più grande su Bitbucked, GitHub ecc. Lo farà esattamente. I manutentori mantengono il repository "principale", un collaboratore clona, ​​esegue il commit e quindi invia una richiesta pull.

Nelle aziende, anche con piccoli progetti o team, un flusso di lavoro distribuito è un'opzione quando esternalizzano i moduli e non vogliono che gli esterni modifichino i rami del sacro sviluppo senza che le loro modifiche siano state riviste in precedenza.

2. La capacità di lavorare in modo distribuito è importante anche per il controllo delle versioni moderne, ...

Come sempre: dipende dai requisiti.

Utilizzare un VCS decentralizzato se si applica un punto qualsiasi:

• desidera eseguire il commit o la navigazione della cronologia offline (ovvero terminando il sottomodulo nella baita di montagna durante le vacanze)
• fornire repository centrali ma si desidera mantenere separato il repository "vero" per rivedere le modifiche (ad esempio per grandi progetti o team distribuiti)
• desidera fornire (una copia di) tutta la storia e le filiali di tanto in tanto impedendo l'accesso diretto al repository centrale (simile al secondo)
• vuoi eseguire la versione di qualcosa senza doverlo archiviare in remoto o impostare un repository dedicato (specialmente con Git un semplice git init .dovrebbe essere sufficiente per essere pronto a versione qualcosa)

Ce ne sono altri ma quattro dovrebbero bastare.

... o suona semplicemente bene?

Ovviamente suona bene - per i principianti.

La flessibilità è una maledizione e una benedizione. E come Git è estremamente flessibile, è quasi sempre di gran lunga troppo flessibile per la situazione tipica. In particolare, la maggior parte dei progetti Git non sono Linux.

Di conseguenza, la scelta intelligente è quella di rimuovere parte di quella flessibilità teorica durante l'implementazione di Git. In teoria i repository possono formare qualsiasi grafico, in pratica la solita scelta è un albero. Possiamo vedere i chiari benefici usando la teoria dei grafi: in un albero di repository, ogni due repository condivide esattamente un antenato. In un grafico casuale, l'idea di un antenato non esiste nemmeno!

Il tuo client git, tuttavia, ha quasi sicuramente il valore predefinito del modello "single antenor". E i grafici in cui i nodi hanno un singolo antenato (tranne un nodo radice) sono esattamente alberi. Quindi il tuo client git si imposta automaticamente sul modello ad albero, e quindi sui repository centralizzati.

La logica aziendale premia un server centralizzato. Per quasi tutti gli scenari aziendali realistici, un server centralizzato è una caratteristica fondamentale del flusso di lavoro.

Solo perché hai la capacità di fare DVCS non significa che il tuo flusso di lavoro principale deve essere DVCS. Quando uso git al lavoro, lo usiamo in modo centralizzato, ad eccezione di quegli strani strani casi in cui il bit distribuito era essenziale per mantenere le cose in movimento.

Il lato distribuito delle cose è complicato. In genere si desidera mantenere le cose lisce e facili. Tuttavia, usando git ti assicuri di avere accesso al lato distribuito per affrontare le situazioni gnarly che possono sorgere lungo la strada.

Per un collega estrarre da un repository git sulla mia macchina significa che devo avere un demone git in esecuzione a livello di root come attività in background. Sono molto diffidente nei confronti dei demoni in esecuzione sul mio computer o sul mio laptop fornito dalla società. La soluzione più semplice è "NO"! Per un collega di estrarre da un repository git sulla mia macchina significa anche che il mio indirizzo Internet deve essere corretto. Viaggio, lavoro da casa e ogni tanto lavoro dal mio ufficio.

D'altra parte, il VPN per il sito aziendale e l'inoltro di una filiale al repository centrale richiede meno di un minuto. Non ho nemmeno bisogno di VPN se sono in ufficio. I miei colleghi possono facilmente tirare da quel ramo.

D'altra parte, il mio repository git locale è un repository completo. Posso impegnare nuovo lavoro, creare una nuova filiale per il lavoro sperimentale e ripristinare il lavoro quando faccio un casino di cose, anche quando lavoro in un aereo che vola a 30.000 piedi nel mezzo del nulla. Prova a farlo con un sistema di controllo versione centralizzato.

Complessità:

Con un repository centrale, potrebbe essere un flusso di lavoro tipico

branch off from the central master branch
change the code
test
possibly go back to changing the code
commit
merge any new changes from the central master branch
test
possibly go back to changing the code
merge changes into the central master branch and push

La complessità rispetto al numero di sviluppatori in O (1).

Se invece ogni sviluppatore ha il proprio ramo principale diventa, per lo sviluppatore 0:

branch off from master branch 0
merge from master branch 1
...
merge from master branch N-1
change the code
test
possibly go back to changing the code
commit
merge any changes from master branch 0
merge any changes from master branch 1
...
merge any changes from master branch N-1
test
possibly go back to changing the code
merge changes into master branch 0

L'approccio peer-to-peer è O (N).

Consistenza:

Ora considera se c'è un conflitto di unione tra il ramo principale di Alice e il ramo principale di Bob. Ognuno degli sviluppatori N potrebbe risolvere il conflitto in modo diverso. Risultato: caos. Esistono modi per ottenere un'eventuale coerenza, ma fino a quando ciò non accade, è possibile perdere ogni tipo di tempo per gli sviluppatori.

Semplice:

Le aziende sono organizzazioni centralizzate, con flusso di lavoro centralizzato.

Ogni programmatore ha un capo e lui ha il suo capo, ecc. Fino al CTO. CTO è l'ultima fonte di verità tecnica. Qualunque sia la compagnia di utensili utilizzata, deve riflettere questa catena di comando. Una compagnia è come un esercito: non puoi permettere ai privati ​​di eludere un generale.

GIT offre funzionalità utili alle aziende (es. Richieste pull per la revisione del codice) e che da sole le fanno passare a GIT. La parte decentralizzata è semplicemente una caratteristica di cui non hanno bisogno, quindi la ignorano.

Per rispondere alla tua domanda: la parte distribuita è davvero superiore nell'ambiente distribuito, ad esempio open-source. I risultati variano a seconda di chi sta parlando. Linus Torvalds non è esattamente il tuo topo cubicolo, ecco perché diverse caratteristiche di GIT sono importanti per lui che per la tua azienda github-centrica.

Forse è perché l'elaborazione delle buste paga è centralizzata, quindi dobbiamo mantenere una persona centrale se vogliamo essere pagati.

Forse è perché stiamo creando un prodotto, quindi abbiamo bisogno di una copia master del software per i clienti.

Forse è perché è molto più facile per un programmatore andare in un posto per ottenere le modifiche di tutti, piuttosto che dover connettersi a molte macchine diverse.

Forse è perché il database dei bug è centralizzato e deve essere sincronizzato con il codice .

Essere centralizzati è fantastico, fino a quando non c'è un problema ...

Essendo un sistema distribuito, è possibile creare un nuovo centro a basso costo da qualsiasi repository aggiornato (basta esporre il repository alla rete). Git consente inoltre di aggiornare un backup obsoleto dai repository sui computer degli sviluppatori, semplificando il ripristino del centro.

Essere in grado di unire ecc. Su una copia locale di un repository quando la rete è inattiva è fantastico, ma non ha bisogno di un sistema distribuito; necessita solo di un sistema che mantenga una copia locale di tutti i dati. Allo stesso modo con il check in codice con volo ecc.

Alla fine della giornata ci sono pochi costi per la distribuzione e alcuni vantaggi. La maggior parte del costo della distribuzione è in un'area necessaria se si desidera un ottimo monitoraggio delle filiali, ecc. Se si progettasse un sistema per l'utilizzo nella maggior parte delle aziende, non si progetterebbe che fosse distribuito, come controllo centralizzato del codice sorgente è chiaramente il principale "caso d'uso".