Come unico sviluppatore (per ora), come dovrei usare Git? [chiuso]


60

Ho diversi progetti su Git che alla fine voglio coinvolgere altri. Tuttavia, in questo momento sono solo io e io uso Git e GitHub in modo molto semplice: niente rami e fondamentalmente solo usando i commit come backup dei miei file locali. A volte torno indietro e guardo le versioni precedenti dei miei file come riferimento, ma non ho dovuto fare alcun rollback a questo punto, anche se apprezzo l'opzione se dovessi averne bisogno in futuro.

Come unico sviluppatore, quali funzionalità di Git o GitHub potrei sfruttare e che potrebbero trarne beneficio in questo momento? Come dovrebbe essere il mio flusso di lavoro?

Inoltre, ci sono pratiche particolari che devo iniziare a fare in previsione di aggiungere altre persone ai miei progetti in futuro?


3
Come altri hanno spiegato, Git ti dà molto potere. Come unico sviluppatore, però, la cosa più importante che apprezzerai in seguito è che se ti dà una registrazione delle modifiche apportate (raggruppando le modifiche in più file in un unico set), quando le hai apportate e perché! È anche un'ottima pratica per quando diventi parte di una squadra.
Leading Geek,

1
Chiuso perché interessante. :)

@ user93458 come sempre! Gli argomenti chiusi sono in genere esattamente ciò che sto cercando.
Miroslav Popov,

ottima domanda che non avrebbe mai dovuto essere chiusa.
volume uno il

Risposte:


64

Inoltre, ci sono pratiche particolari che devo iniziare a fare in previsione di aggiungere altre persone ai miei progetti in futuro?

Ovviamente. Esiste una semplice buona pratica che puoi usare anche se non hai un team in questo momento: creare un ramo separato per lo sviluppo. L'idea è che il ramo master conterrà solo versioni di codice rilasciate o modifiche importanti. Questo può essere adottato facilmente dai nuovi sviluppatori che aderiscono al tuo progetto.

Inoltre, la ramificazione è utile anche se lavori da solo. Ad esempio, trovi un bug mentre stai codificando una nuova funzione. Se non usi i rami, dovrai fare entrambi: aggiungere nuove funzionalità e correggere il bug nello stesso ramo. Questo non va bene: P D'altra parte, se hai creato un nuovo ramo per creare la tua nuova funzionalità, puoi semplicemente controllare il ramo di sviluppo, correggere il bug e ricontrollare il nuovo ramo di funzionalità.

Questo è solo un breve esempio di cosa puoi fare come unico programmatore. Sono sicuro che devono esserci più buone pratiche.

Consiglio vivamente questo articolo: un modello di ramificazione Git di successo


+1 - Ha senso. Guarderò più da vicino anche quell'articolo, sembra molto utile.
VirtuosiMedia,

Non sono uno specialista git, principalmente un utente Mercurial. Questo consiglio del ramo di sviluppo è ancora valido nel caso di Mercurial? Sembra che lo sia, ma forse alcune differenze non lo rendono una buona idea in questo caso?
Klaim,

2
Sì, vale praticamente per tutto il controllo del codice sorgente. In realtà lo faccio all'indietro con SVN; il tronco "principale" è per l'ultimo sviluppo, che va ogni giorno o anche più spesso. Quando viene richiesta una versione, il codice viene bloccato e viene tagliato un ramo. Quel ramo ottiene solo piccoli aggiornamenti per risolvere i problemi di rilascio principali e quindi il distribuibile viene creato da quello. In questo modo, ho un ramo del codice sorgente dietro ogni versione rilasciata. Questo è meglio che semplicemente taggare o etichettare b / c se i commit arrivano dopo l'etichetta ma prima del rilascio, non si sa se sono stati effettivamente esclusi.
KeithS,

+1 per l'articolo; @Klaim - sì, funziona benissimo anche per HG. dovrebbe davvero essere chiamato "modello di ramificazione DCVS di successo"
Wyatt Barnett,

+1 grazie per il link, ha cambiato il modo in cui lavorerò con Git, non tanto per te ma come si dice, ogni piccolo aiuto!
Newtopian,

14

Sono esattamente in questa situazione ma ho optato per un flusso di lavoro leggermente più complesso ma non necessariamente più complicato con Git.

All'inizio l'obiettivo era imparare la git così quindi ho esplorato un po '. poi è tornato praticamente al flusso di lavoro che hai descritto.

Dopo un po 'è diventato difficile lavorare con il verificarsi di alcune situazioni e mi ha dato cattive abitudini che sarebbero state difficili da spezzare una volta entrato in una squadra.

così ho optato per il seguente:

  • Deposito locale per lavorare.
  • Ramo principale come trunk stabile per l'applicazione
  • Un ramo per ogni caratteristica / refactor, in sostanza un ramo per ogni cambiamento considerevole che verrà fatto.
  • Unire nuovamente al tronco quando il ramo è stabile e tutti i test passano.

Ho anche impostato un account git hub in cui sincronizzo il trunk. Questo mi ha permesso di iniziare facilmente a lavorare su diversi computer. Era per necessità, ma mi ha permesso di trovare bug che erano legati all'ambiente in cui mi trovavo e che non erano disponibili sugli altri computer. Quindi ora ho l'abitudine di provare almeno una volta un progetto su un diverso sistema "vergine". Mi risparmia un sacco di mal di testa quando arriva il momento di distribuire al cliente.

  • Taggo tutte le versioni che lo trasformano in github come versione rilasciabile.
  • Se rilasciato al cliente, partirò da questa versione per creare un secondo trunk stabile per le correzioni di bug dichiarate dal cliente.

Inizialmente i molteplici rami sembravano eccessivi, ma REALMENTE ha aiutato molto. Potrei iniziare un'idea in un ramo, lavorarci per un po 'e quando comincio a correre i circoli ho rinunciato e ho iniziato un altro ramo per lavorare su qualcos'altro. Più tardi mi è venuta l'idea di tornare al ramo mezzo cotto ed esplorare questa idea. questo nel complesso mi ha reso MOLTO più produttivo in quanto ho potuto agire rapidamente su flash e idee e vedere se funzionava. Il costo del cambio di filiali con GIT è estremamente basso, il che mi rende molto agile con la mia base di codice. Detto questo, devo ancora padroneggiare il concetto di rebase per ripulire la mia storia, ma dato che sono tutto solo, dubito di averne davvero bisogno. L'ho spinto come "bello da imparare".

Quando tutte le ramificazioni sono diventate complicate, ho esplorato l'opzione di registro per disegnare un albero di modifiche e vedere quale ramo sono dove.

Per farla breve, git non è come SVN, CVS o (brrr) TFS. La ramificazione è molto economica e fare errori che spazzano via il lavoro è in realtà piuttosto difficile. Solo una volta ho perso un po 'di lavoro ed è stato perché ho fatto i miei impegni troppo grandi (vedi sopra le cattive abitudini). Se ti impegni spesso, con piccoli pezzi git sarà sicuramente il tuo miglior alleato.

Per me git mi ha aperto la mente su cosa sia veramente il controllo del codice sorgente. Qualcos'altro prima era solo tentativi di ottenerlo, Git è il primo, che nella mia mente, capito. Detto questo, non ho provato altri DVCS, molto probabilmente questa affermazione potrebbe essere ampliata a tutta la famiglia.

Un ultimo consiglio, la riga di comando è il tuo amico. Per non dire che gli strumenti grafici non sono buoni, anzi, al contrario, ma mi sono davvero imbrogliato quando sono passato alla riga di comando e l'ho provato da solo. In realtà è molto ben fatto, facile da seguire con un sistema di aiuto molto completo. Il mio più grande problema era legato alla ma brutta console di Windows fino a quando non ho trovato alternative.

Ora utilizzo entrambi, l'integrazione di Eclipse con Git per vedere cosa sta succedendo in tempo reale e fare alcune operazioni come diff, esplorare la cronologia di un file, ecc. E la riga di comando per ramificare, unire, spingere, ottenere e gli alberi di registro più complessi . alcuni script di base e non sono mai stato così produttivo per quanto riguarda il controllo del codice sorgente e non ho mai avuto così tanto controllo sul mio codice sorgente.

Buona fortuna, spero che questo abbia aiutato.


4

Sono esperto in diversi sofisticati modelli di diramazione e ne uso alcuni al lavoro. Tuttavia, quando lavoro da solo su progetti, faccio praticamente esattamente quello che stai facendo ora. Posso sempre creare un ramo dopo il fatto se ne ho bisogno, ma non lo faccio quasi mai. Lavorando da solo, raramente ho correzioni di bug che non possono attendere fino al termine della mia attività corrente. Il mio consiglio è di familiarizzare con alcuni modelli di ramificazione, ma non ha senso complicare le cose fino a quando non è necessario.


4

Per un modello più semplice, puoi vedere cosa fa GitHub. "GitHub flow" è molto semplice e qui c'è un'eccellente guida: https://guides.github.com/introduction/flow/index.html

Riepilogo (dal blog di Scott Chacon ):

Quindi, cos'è GitHub Flow?

  • Tutto nel ramo principale è distribuibile
  • Per lavorare su qualcosa di nuovo, crea un ramo descrittivo del master (ad esempio: new-oauth2-scopes)
  • Impegnati in quel ramo localmente e invia regolarmente il tuo lavoro allo stesso ramo sul server
  • Quando hai bisogno di feedback o aiuto o pensi che il ramo sia pronto per l'unione, apri una richiesta pull
  • Dopo che qualcun altro ha esaminato e sottoscritto la funzionalità, puoi unirla in master
  • Una volta che è stato unito e trasferito a "master", puoi e dovresti distribuire immediatamente
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.