Quando dovrei smettere di impegnarmi a padroneggiare nuovi progetti?

Immediatamente.

La chiave è la domanda su quale sia la politica per il Master. Con git, in genere, la politica di ramo su Master è la versione stabile buildable . A volte, Master è la "linea principale" da cui i rami vengono creati e uniti prima di unirsi a un ramo Release. Questi sono due diversi approcci ruolo / politica.

Spesso è una fonte di errori per le persone cambiare il ruolo o la politica di una parte della filiale attraverso il progetto. È più facile per uno sviluppatore solista comunicare queste modifiche ai contributori, ma cercare di ottenere una dozzina di programmatori per riconoscere tutti "Il master è ora a 1.0, si prega di ramificare le caratteristiche piuttosto che tutti spingendo ad esso"

Ho accennato all'approccio politico sopra riportato. La politica per Master è che è la versione stabile buildable . Controllare in piccole modifiche incrementali in questo significa che non hai qualcosa buildable stabile in ogni momento. Non controllare piccoli cambiamenti va contro i "molti piccoli (ma completi) check-in" che tendono ad essere la miglior politica (e incoraggiati da facili ramificazioni).

Da una prospettiva basata sui ruoli, hai iniziato a gestire i ruoli di sviluppo principale, rilascio, manutenzione, e e poi alcuni punti in cui il ruolo di sviluppo e manutenzione si sposta sulle filiali. Ciò significa nuovamente un cambiamento in ciò che è consentito al master e può confondere i contributori su dove le cose appartengono. Può anche (leggermente) confondere la storia del ramo, incoraggiando grandi commit che significano più grande e più difficile capire le fusioni.

Chiave i ruoli e le politiche sui rami semplici e coerenti fin dall'inizio.

Questo "ramo sulla modifica delle politiche" può essere visto nei Modelli di ramificazione . L'idea di ciascun ramo con ruoli può essere letta in Strategie di ramificazione avanzata SCM . Entrambe queste sono ottime letture.

Ci sono principalmente due situazioni in cui in genere vuoi iniziare a lavorare con i rami:

• quando tu o il tuo team dovete avviare una nuova funzione che ha la minima possibilità di non essere aggiunta alla prossima versione (che potrebbe essere la prima versione di sempre), quindi avviare lo sviluppo in un ramo di funzione separato

• quando devi fornire correzioni per gravi bug alla versione più recente, e vuoi creare una nuova versione di bugfix contenente solo quelle correzioni, ma nessuna funzionalità appena sviluppata (e probabilmente instabile)

Per questo tipo di decisioni, penso che sia utile pensare sempre in termini di "nuove funzionalità" o "correzioni di bug", dal punto in cui si dispone di una prima versione compilabile / eseguibile del programma.

Michael Feathers elenca quattro motivi per cambiare nel suo famoso libro, ma metterei "ottimizzare le risorse" sotto "nuovo ramo funzionale" (per una funzione non funzionale) e "migliorare il design" più volte in "nuovo ramo di funzionalità" come beh, dal momento che IMHO non dovrebbe mai migliorare il design quando questo non è inteso allo scopo di facilitare l'implementazione di una funzione specifica .

Se segui git-flow - e, francamente, penso che tu " se usi Git e non usi quel modello di ramificazione, allora dovresti mai impegnarsi a master finché non sarai effettivamente pronto per un rilascio pubblico.

Il tuo primo commit su master dovrebbe essere un repository vuoto. Il prossimo commit a master dovrebbe essere un commit di merge dal ramo develop o un ramo di rilascio temporaneo, e dovrebbe essere stabile, testato e pronto per la distribuzione (se si tratta di un'applicazione) o distribuzione pubblica (se si tratta di una libreria ).

Ci sono altri modelli di ramificazione per Git, ma la maggior parte di essi deriva da vecchi modelli SCM centralizzati e può portare a seri problemi in un ambiente DVCS. Non è necessario utilizzare effettivamente l'estensione git-flow e non è necessario necessariamente tutti i rami di rilascio / hotfix / funzionalità, ma le ossa nude sono develop e master e il codice instabile va in develop .

Sono passati due anni dall'ultima risposta a questa domanda e ora penso che la storia cambi. Per me la risposta è "Ogni volta che si utilizza il controllo del codice sorgente per tenere traccia delle versioni".

Per elaborare, in questi giorni il monitoraggio delle versioni del progetto con il controllo del codice sorgente non sempre funziona. (per esempio usando npm per gestire la dipendenza e specificare le versioni semantiche con '^') In questo caso le risorse del progetto cambiano ogni volta che avviene una compilazione, senza che sia necessario corrispondere ogni volta alle modifiche del codice sorgente. Per gestire questo tipo di nuove sfide, alcuni team scelgono di aver già creato "artefatti" salvati nel sistema di controllo degli artefatti (ad esempio JFrog Artifactory) per le versioni dei progetti di binari.

Ovviamente, quando hai già il controllo della versione delle risorse, non devi estrarre il "codice di produzione" da un ramo GIT e creare / distribuire in produzione, ma consulta il sistema di controllo delle risorse per una versione direttamente eseguibile per la distribuzione. In questi casi il concetto di "ramo di rilascio" perde improvvisamente il suo significato. E ogni volta che la tua squadra decide di non associare il ramo git alla versione di rilascio, commettendo / spingendo direttamente al master diventa una scelta valida ancora una volta: viene come ramo predefinito ogni volta che il repository viene clonato, quindi automaticamente data la semantica ampiamente accettata e ben comunicata i cambiamenti. Tuttavia, come suggerisce la risposta accettata, dovresti probabilmente andare a un ruolo di assegnazione ai rami incluso il master, e usare quei rami solo per quei particolari ruoli.

Infine, ho fatto un ulteriore passo avanti e suggerisco di utilizzare il master come ramo di sviluppo in progetti con solo una manciata di core committer. Qual è il caso della mia squadra e probabilmente lo stesso per la maggior parte dei negozi di micro-servizi. Il commit su master rimuove la comunicazione del processo di modifica e potenzialmente evita l'unificazione dell'inferno quando si lavora sulle funzionalità tra più sprint. Inoltre, il codice nel ramo principale non deve nemmeno "funzionare", il processo di build / test automatizzato ti dirà cosa è andato storto ed è comunque abbastanza facile controllare la cronologia git e contattare l'autore che ha rotto la build / test: -)

Ho intenzione di assumere una posizione radicale: ramo su ogni idea. Per prima cosa i rami git sono economici, il costo principale di un ramo è ricordare a cosa serve. Sono anche d'accordo che il primo impegno da padroneggiare è un candidato alla release. Consiglio di iniziare con un ramo di prova del concetto. Quando hai dimostrato il tuo concetto puoi fonderlo con il tuo ramo di sviluppo vuoto o riscriverlo a seconda di quanto è buono il tuo primo tentativo. da questo punto ti dirigi da devel per ogni bug, feature, astrazione, ecc.

Neal Ford of Thoughtworks sostiene che l'uso di funzioni alterna la ramificazione per evitare il problema di "unire l'inferno". Si consideri il caso in cui due programmatori si uniscono doverosamente ogni giorno dal ramo principale e uno dei fa considerevoli cambiamenti nelle settimane di somes e poi si impegna. L'altro programmatore potrebbe benissimo finire nell'inferno di fusione. Per evitare questo problema, Ford consiglia di "portare avanti il dolore" (un attributo agile noto) avendo un solo ramo e impegnandosi quotidianamente. Le funzionalità aggiuntive vengono aggiunte tramite i pulsanti di selezione delle funzioni che disattivano la funzione fino a quando non sono state testate completamente.

Questa metodologia sembrerebbe funzionare meglio in un ambiente che implementa la consegna continua in quanto i problemi con un commit verrebbero immediatamente rilevati.