Come versioni dei tuoi progetti?

StackOverflow https://stackoverflow.com/questions/142340

  •  02-07-2019
  •  | 
  •  

Domanda

Comprendo che Microsoft utilizza questo modello per il controllo delle versioni dei suoi prodotti: Major.Minor.Build.Revision.

Major viene modificato quando il " sviluppatori " voglio dimostrare che c'è un grande cambiamento nel software e non si può presumere la retrocompatibilità. Forse una riscrittura importante del codice è stata eseguita.

Il numero minore rappresenta un miglioramento significativo con l'intenzione di retrocompatibilità.

Il numero di build è una piccola modifica, ad esempio una ricompilazione della stessa fonte.

La revisione viene utilizzata per correggere una falla di sicurezza e dovrebbe essere completamente intercambiabile. Sia Build che Revision sono opzionali. Queste informazioni si basano su Classe versione MSDN .

Come versioni i tuoi progetti e perché li versioni in questo modo?

È stato utile?

Soluzione

Generalmente facciamo major.minor [.maintenance [.build]] dove lavoro, ma sembra variare leggermente per progetto.

Maggiore / minore come hai menzionato. la manutenzione verrebbe incrementata per piccole correzioni (bug) e compilata per ogni esecuzione del server di compilazione.

Altri suggerimenti

Personalmente mi piace utilizzare uno schema incentrato sul livello di compatibilità con le versioni precedenti che gli utenti del progetto / prodotto possono aspettarsi:

Prima dell'1:

  • 0.0.1 = Prima versione
  • 0 .-. X = Aggiornamento compatibile con le versioni precedenti
  • 0.X.0 = Aggiornamento incompatibile all'indietro

Dopo 1.0:

  • -.-. X = Aggiorna senza modifiche all'interfaccia
  • -.X.0 = Aggiornamento con aggiunte di interfaccia compatibili con le versioni precedenti
  • X.0.0 = Aggiornamento incompatibile all'indietro

L'uso della compatibilità come punto centrale nel numero di versione rende più semplice per gli utenti, soprattutto se il prodotto è una libreria, giudicare se possono aspettarsi un aggiornamento graduale e sicuro .

Vedo spesso Xyz dove X è l'anno dopo il numero di rilascio e yz è il mese dell'anno. Cioè 201 è gennaio, 2 anni dopo il rilascio. Cioè quando il prodotto verrà lanciato a maggio, il primo numero di versione è 105. La versione a febbraio del prossimo anno è 202.

Generalmente eseguiamo la versione dei nostri progetti in base alla data di rilascio corrente, YYYY.MM.DD. * e lasciamo che il numero di build venga generato automaticamente, quindi, ad esempio, se avessimo un rilascio oggi sarebbe il 2008.9.26.BUILD .

Uso major.minor.point.revision, dove point è una versione solo bugfix e la revisione è la revisione del repository. È facile e funziona bene.

Lavoro su molti piccoli progetti e l'ho trovato personalmente utile.

PatchNumber.DateMonthYear

Questo è per piccoli strumenti basati sul web in cui gli utenti possono vedere quando l'ultimo aggiornamento e la frequenza con cui è stato aggiornato.

PatchNumber è il numero di versioni che sono state fatte e il resto è usato per mostrare agli utenti quando è stato pubblicato.

Major.minor.patch.build   con patch che è l'aggiornamento rapido o rilascio di patch.

Se riesci a ottenere il QA entro e sei su SVN, puoi usare la revisione svn HEAD come numero di build. In questo modo, ogni build descrive da dove proviene in termini di controllo del codice sorgente e cosa c'è nella build. Questo significa che avrai build che aumentano con le lacune (1.0.0.1, 1.0.0.34 ....)

Major.Minor.BugFix.SVNRevision

ad es. 3.5.2.31578

  • La Revisione SVN ti dà l'esatta tranquillità del codice inviato al cliente. Sei assolutamente sicuro che quel bugfix fosse presente o meno.
  • Inoltre aiuta a trovare il PDB corretto in caso di errore dell'applicazione. Basta abbinare le revisioni SVN sul server di compilazione, copiare il PDB nella posizione EXE, aprire il debugger e ottenere la traccia dello stack di arresto.

Faccio solo Major.minor. Dato che sono un singolo sviluppatore (con un aiuto occasionale) che lavora su un'app Web, alla maggior parte delle persone non potrebbe fregare di meno delle correzioni minori che faccio. Quindi eseguo solo l'iterazione delle versioni secondarie mentre inserisco nuove funzionalità e numeri di versione principali quando eseguo un enorme cambiamento / aggiornamento. Altrimenti, ignoro solo le piccole correzioni per quanto riguarda i numeri di versione (anche se ho numeri di revisione di Subversion se devo fare riferimento per me stesso).

Ho solo un numero. La prima versione è 001. La terza beta della seconda versione è 002b3 e così via. Questo è solo per la mente delle cose personali, al momento non ho nulla di "rilasciato", quindi questa è tutta teoria.

Ho iniziato a utilizzare un formato pseudo-simile come Ubuntu: Y.MMDD

Questo aiuta per alcuni motivi:

  • è più facile controllare i requisiti di versione: if (versione < 8.0901) die/exit/etc. ;
  • può essere generato automaticamente nel processo di generazione

Su quel secondo punto (ruby & amp; rake): 

def serial(t)
   t = Time.now.utc if not t.instance_of?(Time)
   t.strftime("%Y").to_i - 2000 + t.strftime("0.%m%d").to_f
end

serial(Time.now)     #=> 8.0926
serial(Time.now.utc) #=> 8.0927

NOTA: t.strftime ("% Y.% m% d "). to_f - 2000 incontra imprecisioni in virgola mobile: 8.09269999999992

Mi piaceva il modo Nantucket di eseguire il versioning del compilatore Clipper negli anni '80:

Clipper Winter 1984
Clipper Estate 1985
Clipper Winter 1985
Clipper Autunno 1986
Clipper Summer 1987

Oh e sovrapposizioni ....

[si strappa gli occhi]

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top