Best Practice: Software Versioning

Esistono linee guida o best practice standard su come eseguire la versione di un software che sviluppi nel tempo libero per divertimento, ma comunque saranno utilizzate da alcune persone? Penso che sia necessario per la versione di tale software in modo che tu sappia con la versione uno sta parlando (ad esempio per la correzione dei bug, supporto e così via).

Ma da dove comincio il versioning? 0.0.0? o 0.0? E poi come posso aumentare i numeri? major release.minor change? e non dovrebbe esserci alcun impegno per un sistema di controllo versione essere un’altra versione? o è solo per le versioni che vengono utilizzate in modo produttivo?

Dovresti iniziare con la versione 1, a meno che tu non sappia che la prima versione “rilasciata” è incompleta in qualche modo.

Per quanto riguarda il modo in cui incrementate le versioni, dipende da voi, ma usate la numerazione principale, secondaria, delle build come guida.

Non è necessario avere tutte le versioni che si impegnano per il controllo del codice sorgente come un’altra versione: presto avrete un numero di versione molto grande. Hai solo bisogno di incrementare il numero di versione (in qualche modo) quando rilasci una nuova versione all’esterno.

Quindi, se si apportano modifiche importanti, passare dalla versione 1.0.0.0 alla versione 2.0.0.0 (ad esempio, è stato modificato da WinForms a WPF). Se esegui una modifica più piccola, passa da 1.0.0.0 a 1.1.0.0 (hai aggiunto il supporto per i file png). Se fai una piccola modifica, vai da 1.0.0.0 a 1.0.1.0 (hai corretto alcuni bug).

Se vuoi davvero ottenere un uso dettagliato, il numero finale come numero di build che incrementerebbe per ogni checkin / commit (ma penso che stia andando troppo lontano).

Vorrei usare il tipo di versione di xyz

x – versione principale
y – versione minore
z – numero di build

In pratica seguo questo schema:

  • inizia da 0.1.0

  • quando è pronto, dirigo il codice nel repository di origine, tag 0.1.0 e creo il ramo 0.1.0, la testina / trunk diventa 0.2.0-snapshot o qualcosa di simile

  • Aggiungo nuove funzionalità solo al trunk, ma il backport corregge il ramo e nel tempo rilascio da esso 0.1.1, 0.1.2, …

  • Dichiaro la versione 1.0.0 quando il prodotto è considerato completo di funzionalità e non presenta grandi carenze

  • da quel momento in poi, tutti potranno decidere quando incrementare la versione principale …

Io uso questa regola per le mie applicazioni:

xyz

Dove:

  • x = numero di versione principale, 1- ~.
  • y = numero funzione, 0-9. Aumentare questo numero se la modifica contiene nuove funzionalità con o senza correzioni di errori.
  • z = numero di aggiornamento rapido, 0- ~. Aumentare questo numero se la modifica contiene solo correzioni di bug.

Esempio:

  • Per la nuova applicazione, il numero di versione inizia con 1.0.0.
  • Se la nuova versione contiene solo correzioni di bug, aumentare il numero di aggiornamento rapido in modo che il numero di versione sia 1.0.1.
  • Se la nuova versione contiene nuove funzionalità con o senza correzioni di bug, aumentare il numero di funzionalità e reimpostare il numero di aggiornamento rapido su zero in modo che il numero di versione sia 1.1.0. Se il numero della funzione raggiunge 9, aumentare il numero di versione principale e reimpostare la funzione e il numero di aggiornamento rapido a zero (2.0.0, ecc.)

Usiamo abcd dove

  • a – maggiore (incrementato alla consegna al cliente)
  • b – minore (incrementato alla consegna al cliente)
  • c – revisione (incrementata su versioni interne)
  • d – build (incrementato dal cruise control)

Ancora un altro esempio dell’approccio ABC è il controllo del pacchetto Eclipse . I bundle di Eclipse hanno invece un quarto segmento:

In Eclipse, i numeri di versione sono composti da quattro (4) segmenti: 3 interi e una stringa rispettivamente denominati major.minor.service.qualifier . Ogni segmento cattura un diverso intento:

  • il segmento principale indica la rottura nell’API
  • il segmento minore indica le modifiche “esternamente visibili”
  • il segmento del servizio indica correzioni di bug e il cambiamento del stream di sviluppo
  • il segmento qualificatore indica una particolare build

Esiste anche lo schema di controllo delle versioni delle date , ad esempio: YYYY.MM , YY.MM , YYYYMMDD

È abbastanza istruttivo perché una prima occhiata dà un’impressione sulla data di rilascio. Ma preferisco lo schema xyz, perché voglio sempre conoscere il punto esatto di un prodotto nel suo ciclo di vita (Major.minor.release)

La risposta di base è “Dipende”.

Qual è il tuo objective nel controllo delle versioni? Molte persone usano version.revision.build e pubblicizzano solo version.revision al mondo in quanto è una versione di rilascio piuttosto che una versione di sviluppo. Se utilizzi la “versione” del check-in, troverai rapidamente che i numeri di versione diventano grandi.

Se si sta pianificando il progetto, incrementerei la revisione per le versioni con modifiche minori e la versione di incremento per le versioni con modifiche importanti, correzioni di errori o funzionalità / funzionalità. Se offri versioni di versioni beta o notturne, estendi il controllo delle versioni per includere la generazione e incrementale con ogni versione.

Eppure, alla fine della giornata, dipende da te e deve avere senso per te.

Come dice Mahesh: userei il tipo di versione di xyz

x – major release y – minor release z – build number

potresti voler aggiungere un datetime, forse invece di z.

Si incrementa la versione secondaria quando si ha un’altra versione. La versione principale rimarrà probabilmente 0 o 1, la cambierai quando apporterai modifiche importanti (spesso quando il tuo software è in un punto in cui non è retrocompatibile con le versioni precedenti o hai cambiato l’intero framework)

Sai che puoi sempre controllare per vedere cosa stanno facendo gli altri. I software open source tendono a consentire l’accesso ai loro repository. Ad esempio potresti indirizzare il tuo browser SVN a http://svn.doctrine-project.org e dare un’occhiata al sistema di versioning utilizzato da un progetto reale.

Numeri di versione, tag, è tutto lì.

Seguiamo l’approccio abc come:

aumento ‘a’ se si verificano alcuni cambiamenti importanti nell’applicazione. Come se avessimo aggiornato l’applicazione .NET 1.1 su .NET 3.5

aumento ‘b’ se ci sono alcune modifiche minori come qualsiasi nuovo CR o Enhancement è implementato.

aumento ‘c’ se ci sono dei difetti risolti nel codice.

Inizio il controllo delle versioni al segmento più basso (non l’aggiornamento rapido). Non limito questo segmento a 10. A meno che non si stiano monitorando le build, è sufficiente decidere quando applicare un incremento. Se si dispone di una fase di controllo qualità, potrebbe essere il punto in cui si applica un incremento al segmento più basso e quindi il segmento successivo quando passa QA e viene rilasciato. Lascia il segmento più in alto per il comportamento principale / le modifiche all’interfaccia utente.

Se sei come me lo renderai un ibrido dei metodi in modo da far coincidere il ritmo della progressione del tuo software.

Penso che il modello abc o abcd più accettato, specialmente se si ha il controllo qualità / conformità nel mix. Ho avuto un sacco di informazioni su date che sono una parte normale delle versioni che ho abbandonato per il mainstream.

Non tracciamo le build quindi mi piace usare il pattern abc a meno che non sia coinvolto un hotfix. Quando devo applicare una correzione rapida, applico il parametro d come una data con l’ora. Ho adottato il parametro time come d perché c’è sempre il potenziale di diversi in un giorno in cui le cose esplodono davvero in produzione. Applico solo il segmento d (YYYYMMDDHHNN) quando divergo per una correzione di produzione.

Personalmente non sarei contrario a uno schema software di va.b revc dove c è YYYYMMDDHHMM o YYYYMMDD.

Tutto ciò che ha detto. Se riesci a impadronirti di uno strumento per configurarlo ed eseguirlo, ti manterrai dal mal di testa che deve gestire l’aspetto del parere del versioning e puoi semplicemente dire “usa lo strumento” … perché tutti nel processo di sviluppo sono in genere così conformi .