L'utilizzo corretto di tag in SCM

Question

I miei colleghi ed io stiamo avendo una discussione sul valore e l'utilizzo di Tag nei sistemi di rilascio / SCM. Stiamo cercando per la comunità StackOverflow a mettere nei loro pensieri per aiutarci a risolvere il problema.

Un lato sostiene che I tag sono una preziosa aggiunta alla gestione delle release. Un esempio del loro utilizzo: facciamo un rilascio Maven, il che rende un nuovo tag (chiamarla 1.0) che è il codice snapshot utilizzato per questa versione. Questo tag deve essere un ramo di sola lettura. Quando un bug deve essere risolto possiamo fare una copia del tag in un nuovo ramo (chiamarla 1.1). Correzioni di bug ci vanno. Queste correzioni possono essere uniti di nuovo in tronco in modo che il ramo principale dev ottiene i correzioni di bug. Infine, 1.1 viene rilasciato e un tag 1.1 viene creato automaticamente. Questo ciclo continua. Il vantaggio principale qui del tag è che se mai bisogno di ri-release versione 1.0 per qualsiasi motivo, si può solo rilasciare il tag 1.0 con la fiducia che non è mai stato alterato da nessuno. Inoltre, dicendo "Release Tag 1.0" è più pulita che dire "rilascio revisione 1 del ramo 1.0, che è l'originale 1.0 senza le correzioni".

Gli altri crediti collaterali che Tag non forniscono alcun beneficio prezioso, soprattutto in un sistema come Subversion con le revisioni globali, che agiscono come un tag in CVS. Inoltre, Subversion dà solo un avviso quando impegnarsi in un tag; in realtà non fermarlo. Il loro metodo si sta sviluppando in tronco e al rilascio Saresti un ramo chiamato 1.0. Si potrebbe continuare a correzioni di bug nel bagagliaio e se avete bisogno di ri-rilasciare quelle correzioni di bug alla produzione, li devi unire in 1.0 Branch e re-release 1.0. Ad un certo punto, forse dopo le correzioni più importanti o le caratteristiche di Tronco, che ci si rilascia e fare Branch 1.1. Ciclo continua. Se hai bisogno di rilasciare la versione originale 1.0, che avrebbe dovuto controllare Branch 1.0 revisione 1.

Chiaramente entrambi i metodi funzionano. Mi piacerebbe sentire i pensieri della comunità su cui il metodo è preferito e perché.

Edit: Sono un po 'preoccupato che il modo "migliore" dipende dal sistema SCM sottostante. In entrambi i stabilirsi su Subversion per le risposte o, se possibile, tenerlo SCM agnostico.

Answer 1

Da un punto SCM agnostica di vista, un tag è molto diverso da una revisione.

Entrambi possono essere attuati nello stesso modo, sia rappresenta una "linea del tempo", ma il loro obiettivo è diverso:

• un tag rappresentano un immutabile stato in cui tutti i file fanno riferimento un ID univoco. Si tratta di una href="https://stackoverflow.com/questions/372321/best-practice-for-svn-tags"> nome ma soprattutto uno stato stabile, ...)
• una revisione rappresentano una transazione commit ( non tutti SCM ha quei , specialmente quelli vecchi con un 'approccio di file-by-file'). Tutti i commit non rappresentano uno stato "stabile" (come in "compilazione" o "esecuzione" con successo). Sono solo un nuovo elemento della storia globale.

Il problema con SVN è che la revisione, la modifica e rami sono tutti implementato lo stesso.
Ma vorrei ancora preferiscono l'opzione in cui un tag viene utilizzato come "sola lettura" ramo .

Answer 2

A mio parere i tag sono utili. Ci saranno momenti ad un certo punto nella vita del progetto che si incontra un bug o di un cambiamento e si desidera sapere se era lì in una versione precedente. Ci saranno motivi per confrontare il codice da una release all'altra per misurare l'efficienza sia in termini di prestazioni e in realtà lo sviluppo del codice.

Certo, c'è una possibilità che si può rovinare tutto, ma può sempre essere annullata. Non c'è davvero alcun motivo per non, e ci sono diversi motivi per cui potrebbe essere utile in futuro. Per me il suo un gioco da ragazzi.

Sono d'accordo che si dovrebbe anche utilizzare rami e facendo il vostro sviluppo lì, ma ogni volta che in realtà rilascia qualcosa, fare un tag fuori di esso.

Answer 3

Sì, si desidera utilizzare i tag.

Pensate a un tag come solo un'etichetta o un nome per una particolare revisione. E 'molto utile nella mia esperienza di tag traguardi importanti in un progetto, se è per il rilascio di produzione o anche per i rilasci intermedi QA. Spesso si vuole andare indietro nel tempo e vedere il codice sorgente di una particolare release.

Se si diramano a seguito di rilascio, si può sempre capire che la revisione è stato rilasciato per la produzione, ma questo è una specie di dolore rispetto al solo guardando un tag. Se non si utilizza rami di rilascio allora sarà facile perdere le tracce di cui revisione è stata utilizzata per creare una particolare configurazione.

Il problema con svn è che offusca la distinzione tra i tag e rami. Chiunque può sempre impegnarsi per un tag, quindi non è garantita da fissare / immutabile. In altri VCS come PVCS, un "tag" è immutabile. È possibile adottare una convenzione squadra per evitare commit ai tag, o anche magari utilizzare impegnarsi ganci per evitare commit ai tag.

Answer 4

Usiamo i tag (etichette) per la creazione di nuove linee di base. Lo facciamo una volta alla settimana, ma alcune squadre facciamo anche più volte al giorno.

Il punto (per noi) sta facendo sempre che la nuova linea di base è stabile: quindi non è solo un accumulo, è una build che passa l'intera suite di test, diverse ore di test automatizzati, più quelli esplorativi potenzialmente manuali anche

Poi la linea di base viene utilizzato come punto di partenza per tutte le attività durante la prossima iterazione: ogni nuovo ordine è una nuova filiale a partire dalla linea di fondo, che è noto per essere stabile, in modo tutto ciò che è rotto nel compito dovrebbe essere facile da rintracciare all'interno il compito stesso.

Di solito abbiamo solo messo i tag (etichette) sul ramo principale (o tronco o maestro a seconda del vostro gusto SCM), che è il punto di integrazione per tutti gli altri rami.

Quando si rilascia un prodotto ufficiale creiamo un "ramo di release per questo" in modo che riceverà solo correzioni mentre il nuovo sviluppo rimane accesa "principale". Poi possono essere taggati anche questi "rami di manutenzione" (si spera solo uno o due alla volta).

Answer 5

Mi piace pensare sui tag come "solo un nome di fantasia per una revisione". Ho sempre pensato a quel modo, e IIRC in mercuriale sono proprio questo. In Subversion però, come lei dice, che in effetti sono (a buon mercato) copie del tronco / * a tag / immaginazione-name /

Onestamente, mi piacerebbe combinare le due strategie per ottenere risultati ottimali: tag e ramo al momento del rilascio. Il tuo tag è chiamato 1.0.0, ramo 1.0-MAINT. Correzioni di bug vanno in rami, e rilascia bugfix sono di nuovo tag (1.0.1 può, con un tag destinato ad alias 1.0-MAINT a un certo punto).

Non dimentichiamo, tuttavia, che i tag e le filiali in eversione sono in realtà la stessa cosa: copie a buon mercato. L'unica differenza tra loro è la semantica si / la tua squadra attribuisce a loro, quindi si riduce praticamente verso il basso per convincere la gente ad accordarsi su un metodo particualr e attenersi a tale (potrebbero essere applicate sul server, ad esempio, non consentendo impegna nei tag / ad eccezione per i coordinatori di rilascio, ecc.)

Il problema che vedo anche se con il secondo approccio è: come hai intenzione di fare una facile distinzione tra software nel campo se si re-release 1.0? Ciò significa che si può avere un 1.0 e un altro 1,0 in realtà riferimento a una base di codice diverso ....

Answer 6

istantanee immutabili del codice sorgente di un progetto (ed eseguibili) sono preziosi per fare test di qualsiasi tipo, sia strutturato il test o un campo di utilizzo. Per il test strutturato, si sta andando ad essere la creazione di dati che possono essere referenziate mesi o anni nel futuro. Ogni volta che si rivisitare che i dati, la legge di Murphy dice che è necessario sapere che il codice viene e se non si è andato alla briga di citare un particolare un'istantanea del codice sorgente, sarà impossibile dire con fiducia quello che il codice sorgente corrisponde alla che i dati di test.

Non posso dirvi quante volte qualcuno è venuto da me e mi ha detto: "Questo codice microcontrollore non funziona, potete aiutarmi?" e chiedo loro: "Quale versione stai usando?" e dicono "Non sono sicuro" perché non stanno facendo gestione buon rilascio (per lo meno mettere un adesivo sul dispositivo, meglio mettere informazioni in EEPROM che può essere interrogato in tempo reale delle versioni). >: (

Answer 7

In SVN, la differenza tecnica tra utilizzando un nome e il monitoraggio di una revisione è pari a zero. Mi ritrovo a ridurre al minimo l'uso di tag in base a come l'implementazione di SVN è semplicemente una copia a buon mercato e ingombra il vostro "spazio struttura".

La vera differenza viene quando comunicare una particolare linea di base per un grande team di sviluppatori. monitoraggio Revisione porta un ulteriore livello di astrazione che può diventare una fonte di errori. E come siamo tutti consapevoli, quando hai a che fare con 50 + sviluppatori, ogni fonte di errore diventerà una zona di confusione e perdite di tempo. Un tag verbose può eliminare quella confusione e togliere ogni dubbio su ciò che lo scopo di una linea di base è.

Answer 8

Mi piacerebbe combinare i due approcci. Ogni volta che si effettua una liberazione, usa il tag. Tag dovrebbero non cambiano mai, per cui la presenza di un tag "1.0.0" è un indicatore che non si dovrebbe cercare di rilasciare qualsiasi altra cosa come 1.0.0.

Allo stesso tempo, quando è arrivato il momento di fare 1.0.0, che avevo messo su un ramo 1.0. Quindi il flusso è: ramo tronco a 1,0, taggare questo nuovo 1.0 come 1.0.0, e distribuire. Poi correzioni di bug può essere fatto sul ramo 1.0 (per evitare di essere confuso con qualsiasi sviluppo 1.1-targetted che possono essere già sul tronco ora) e fuse in tronco. Ogni release della fissa 1.0 è etichettato come 1.0.x dal ramo 1.0. Questo è fondamentalmente l'approccio che usiamo al lavoro con Perforce, e che è molto simile in effetti a Subversion. (Leggendo le risposte, penso che sia praticamente identico a raccomandazione di Vincent)

Per quanto riguarda il commento sui tag di essere ridondante perché avete i numeri di revisione --- questo è in gran parte vero, tranne che i tag anche specificare un ambito: vale a dire quali file nel repository sono coperti dal tag. Si può ragionevolmente chiedere a qualcuno di guardare /svn/proj1/tag/1.0.0 e vengono immediatamente guardando uno spazio di lavoro coerente. Se si chiede loro di guardare la revisione X, devono prima occhiata a revisione X per vedere che stava cambiando (diciamo) / svn / proj1 / trunk / Makefile e quindi dedurre che / svn / proj1 / trunk / @ X è quello che essi dovrebbero essere guardando. Cosa succede se la revisione X toccato i file in proj1 e proj2? Che naturalmente è il male, ma a rigor di termini si dovrebbe dire / svn / proj1 / trunk / @ X. E dove è l'elenco dei numeri di revisione memorizzato? Come facciamo a sapere che la 1.0.0 è la revisione X? Dovrebbe essere IMHO possibile determinare che proprio dal repository.

In sistemi come Git, tag e rami sono ancora fondamentalmente la stessa cosa (solo riferimenti al database degli oggetti), ma il convegno è che i tag arbitri non cambiano, e arbitri filiali fanno ( e preferibilmente con un vincolo specifico su come cambiano). Perforce ha anche "etichette" che sono modi di raggruppare un insieme di revisioni dei file insieme indipendentemente un changelist; che è essenzialmente un tag, ma più confusa: i numeri dell'elenco modifiche storicamente abbiamo usato (equivalenti a numeri di revisione in Subversion) qualificato con il nome del ramo che dovrebbe essere su per identificare le versioni. I due sono quasi identici in qualsiasi modo, ecco immagino TMTOWTDI.