Welche "Versionsnamenskonvention" verwenden Sie? [geschlossen]

Passen unterschiedliche Versionsnamenskonventionen zu unterschiedlichen Projekten? Was benutzt du und warum?

Ich persönlich bevorzuge eine hexadezimale Build-Nummer (z. B. 11BCF), die sehr regelmäßig erhöht werden sollte. Und dann für Kunden eine einfache 3-stellige Versionsnummer, dh 1.1.3.

1.2.3 (11BCF) <- Build number, should correspond with a revision in source control
^ ^ ^
| | |
| | +--- Minor bugs, spelling mistakes, etc.
| +----- Minor features, major bug fixes, etc.
+------- Major version, UX changes, file format changes, etc.

Ich bin selten ganz mit Jeff Atwood einverstanden, aber ich neige dazu, seiner Meinung zur .NET-Konvention der Versionsnummerierung zu folgen .

(Hauptversion). (Nebenversion). (Versionsnummer). (Build-Nummer)

In den meisten Fällen empfinde ich persönliche Projekte als übertrieben. Die wenigen Male, in denen ich an umfangreichen Projekten wie Suchmaschinen in C # gearbeitet habe, habe ich mich an diese Konvention gehalten und konnte sie als internen Tracker effektiv einsetzen.

Die semantische Versionierung ( http://semver.org/ ) verdient hier eine Erwähnung. Dies ist eine öffentliche Spezifikation für ein Versionsschema in Form von [Major].[Minor].[Patch]. Die Motivation für dieses Schema besteht darin, die Bedeutung mit der Versionsnummer zu kommunizieren.

Ich benutze es nicht, aber ich habe es gesehen und es ist eine interessante Struktur:

Year.Month.Day.Build

Selbsterklärend.

Ich versuche, die RubyGems Rational Versioning-Richtlinie zu verwenden, in der:

• Die Major-Versionsnummer wird erhöht, wenn die Binärkompatibilität unterbrochen wird
• Die Nebenversionsnummer wird erhöht, wenn neue Funktionen hinzugefügt werden
• Die Build-Nummer ändert sich für Bugfixes.

Hier ist ein sehr differenzierter Ansatz zur Versionsnummerierung:

• N.x.K, wo Nund Ksind ganze Zahlen. Beispiele: 1.x.0, 5.x.1, 10.x.33. Wird für Zwischenbauten verwendet .
• N.M.K, Wo N, Mund Kganze Zahlen sind. Beispiele: 1.0.0, 5.3.1, 10.22.33. Wird für Releases verwendet .
• N.x.x, wo Nist eine ganze Zahl. Beispiel: 1.x.x. Wird für Supportzweige verwendet .
• N.M.x, wo Nund Msind ganze Zahlen. Beispiel: 1.0.x. Wird für Release-Zweige verwendet .

Hier ist das Bild zur einfachen Veranschaulichung des Versionsnummerierungsansatzes:

PAbedeutet Pre-Alpha A bedeutet Alpha B bedeutet Beta AR bedeutet Alpha-Release BR bedeutet Beta-Release RC bedeutet Release Candidate ST bedeutet Stabil

Vorteile eines solchen Versionsnummerierungsansatzes sind folgende:

• Es repräsentiert Besonderheiten des agilen Softwareentwicklungslebenszyklus .
• Es berücksichtigt Besonderheiten der Quellcode-Repository-Struktur .
• Es ist selbsterklärend für diejenigen, die sich an die Muster gewöhnt haben. Jedes Muster repräsentiert ein anderes Artefakt. Solche Muster können einfach analysiert und für andere Zwecke verwendet werden, beispielsweise zur Verfolgung von Problemen.
• Das Versionsmuster-Set, das für den beschriebenen Versionsansatz grundlegend ist, kann zum Sammeln von Metriken und zum Planen verwendet werden .
• Es konzentriert sich auf die Konzepte der Reife und des Qualitätsniveaus . Sehr oft werden solche Versionsnummern wie 1.0.0 ohne große Notwendigkeit zugewiesen (wenn Software in Deep Alpha vorliegt). Der vorgestellte Ansatz der Versionsnummerierung ermöglicht es, mehrere Reifegrade festzulegen. Im einfachsten Fall hat es nur zwei Ebenen: Intermediate Build ( N.x.K) und Release ( N.M.K). Release bedeutet, dass eine Software mit der vollständigen Versionsnummer ( N.M.K) eine Art Qualitätsmanagementprozess innerhalb des Lieferantenunternehmens / der Organisation / des Teams durchlaufen hat.
• Es ist ein Beweis für die Agilität sowohl der Entwicklung als auch der Erprobung.
• Fördert einen modularen Ansatz für die Softwarestruktur und -architektur.

Es gibt auch ein komplexeres Diagramm, das den Versionsansatz im Detail darstellt. Außerdem finden Sie möglicherweise nützliche Präsentationsfolien , die den Übergang zum Versionsansatz und zur Anwendung SCMFViz beschreiben und die Grundprinzipien des Versionsnummerierungsansatzes veranschaulichen. Präsentationsfolien erläutern auch, warum es wichtig ist, während der gesamten Laufzeit des Softwareprojekts denselben Versionsansatz einzuhalten.

Persönlich geht meine Einstellung zur Verwendung von Datumsversionen anstelle von realen Versionsnummern davon aus, dass Entwickler der Software mit datierten Versionen:

• Wissen Sie nichts über den Lebenszyklus der Softwareentwicklung . Entwicklung ist in der Regel agil und iterativ. Der Ansatz der Versionsnummerierung sollte den iterativen Charakter des Softwareentwicklungsprozesses widerspiegeln.
• Kümmern Sie sich nicht um die Softwarequalität . Qualitätskontrolle und -sicherung sind agil und iterativ. Genau wie bei der Entwicklung. Die Versionsnummer sollte den Beweis für die Agilität und den iterativen Charakter sowohl der Entwicklung als auch der Qualitätskontrolle / -sicherung liefern.
• Interessieren Sie sich nicht für die Architektur oder die Idee ihrer Anwendung. Die Hauptversionsnummer ( Nin N.M.K) ist sowohl für die architektonische Lösung als auch für das zugrunde liegende Prinzip der Anwendung verantwortlich. Die Hauptversionsnummer Nist entsprechend den Änderungen in der Architektur oder den Änderungen der Hauptideen und Prinzipien ihrer Arbeitsweise / Funktionsweise zu ändern.
• Haben Sie keine Kontrolle über ihre Codebasis . Es gibt wahrscheinlich nur einen Zweig (Stamm) und er wird für alles verwendet. Was ich persönlich nicht für richtig halte, da es die Codebasis dazu ermutigt, eine große Müllkippe zu werden.

Dieser Ansatz mag ein wenig kontrovers erscheinen, aber ich glaube, dass dies die einfachste Möglichkeit ist, Software die entsprechenden Versionsnummern zuzuweisen.

Für jede Hauptversion, die Sie veröffentlichen, ist es nicht ungewöhnlich, dass Sie eine funktionierende Version verwenden, die Sie intern aufrufen. In meinem letzten Job haben wir uns beispielsweise auf eine Hauptversion mit der folgenden Ubuntu-inspirierten Namenskonvention bezogen:

[kranker Zustand] [alliterativer Tiername]

Die Namen wie " Limp Lamprey ", " Wounded Wombat " und " Asthmatic Anteater " gaben .

Vergewissern Sie sich, dass Ihre Kunden nichts davon wissen, es sei denn, es ist ein wirklich cooler Name.

Generation.Version.Revision.Build (9.99.999.9999)

Die Generation wechselt selten. Nur ein großes Produkt einschalten: DOS -> Windows, komplette Reengineering.

Die Version ist für große inkompatible Änderungen, neue Funktionen, Änderungen an bestimmten Paradigmen der Software usw. gedacht.

Überarbeitungen werden häufig durchgeführt (kleinere Funktionen und Fehlerbehebung).

Build ist interne Information.

git describeBietet eine schöne Erweiterung der von Ihnen gewählten Nummerierungskonvention. Es ist einfach genug, dies in Ihren Build / Packaging / Deployment-Prozess einzubetten.

Angenommen, Sie nennen Ihre markierten Release-Versionen ABC (major.minor.maintenance). git describeBei einem bestimmten Commit wird der letzte getaggte Vorgänger des Commits gefunden, anschließend die Anzahl der seitdem durchgeführten Commits und das abgekürzte SHA1 des Commits angegeben:

1.2.3-164-g6f10c

Wenn Sie sich tatsächlich in einer der Versionen befinden, erhalten Sie nur den Tag (1.2.3).

Dies hat den schönen Vorteil, dass Sie genau wissen , von welcher Quelle Sie gebaut haben, ohne jeden einzelnen Build einzeln nummerieren zu müssen.

Major.Minor.Public (Build) [Alpha / Beta / Trial], wie "4.08c (1290)"

• Mit Major als Hauptversionsnummer (1, 2, 3 ...)
• Minor ist eine zweistellige Mollversion (01, 02, 03 ...). Normalerweise wird die Zehnerstelle erhöht, wenn wichtige neue Funktionen hinzugefügt werden, die nur zur Behebung von Fehlern dienen.
• Öffentlich ist die öffentliche Version des Builds (a, b, c, d, e), die sich häufig von der Nebenversion unterscheidet, wenn eine Nebenversion niemals als öffentliches Update veröffentlicht wird
• build ist die tatsächliche Build-Nummer, die der Compiler verfolgt.
• mit TRIAL, ALPHA, BETA X oder RC X als Anhang für diese Sonderfälle.

Ich bevorzuge Versionsnummern, die eine semantische Bedeutung haben. Solange Sie die Versionsnummer verwenden können, um mit einer bestimmten Version gemeldete Fehler in Bezug auf Änderungen im Quellcode (und in Ihrem Aktivitätsmanagementsystem) zu verfolgen, verwenden Sie wahrscheinlich die richtige Methode.

Ich benutze .NET, damit ich mit dem .NET-Versionsnummerierungssystem nicht weiterkomme, aber ich versuche, den Zahlen so mit eine semantische Bedeutung zu geben

Major.Minor.Build.Revision

• major = (bis zum Projekt)
• minor = (bis zum Projekt)
• build = Build-Nummer von Hudson (Sie können hier TeamCity oder TeamBuild usw. verwenden)
• Revision = Subversion oder Basar Revision (abhängig vom Projekt und dessen Verwendung)

Wir stellen immer sicher, dass die Versionsnummer in irgendeiner Weise sichtbar ist (mit unseren Batch-Konsolen-basierten Programmen werden sie auf die Konsole und in eine Protokolldatei gedruckt, mit Web-Apps in der Menüleiste in der Regel ganz oben).

Auf diese Weise können Kunden, die Probleme melden, anhand der Versionsnummer nachverfolgen, ob sie die neueste Version verwenden und wie viele Probleme mit bestimmten Versionen aufgetreten sind.

Auf die Rückverfolgbarkeit kommt es an!

Wir verwenden Major.Minor.Build # .YYMMDD [Suffix], da wir normalerweise nur einen Produktionsbuild an einem bestimmten Tag ausführen (aber ab / c / d-Suffix verwenden, wenn es mehr als einen gibt) und das YYMMDD Benutzern / Kunden / Management gibt ein Hinweis auf das Alter des Builds, 6.3.1389 nicht.

Die Hauptzahlen steigen mit signifikanten Produktmerkmalen (bezahlt).

Kleinere Zahlen steigen mit Korrekturen / Verbesserungen (kostenloses Update).

Build nimmt immer zu; Nicht alle bauen ein Schiff, es ist also kein linearer Fortschritt.

Versionsnummern sollten genügend Informationen enthalten, um Konflikte zu vermeiden und einen Fehler in den Problemen mit dem falschen Release-Typ zu beheben, aber keine zusätzlichen Informationen enthalten, die nicht relevant sind.

Wenn Sie beispielsweise das Datum verwenden, können Kunden feststellen, dass sie eine ältere Version haben, und Patches für ältere Versionen können verwirrende Versionen haben.

Ich persönlich mag die semantische Versionierung :

• Veröffentlichungen sind Major. Minor.Patch
• Patch erhöht sich jedes Mal, wenn Sie einen Build freigeben.
• Minor erhöht sich jedes Mal, wenn abwärtskompatible Funktionen hinzugefügt werden.
• Major Inkrementiert, wenn neue Funktionen nicht abwärtskompatibel sind.
• Wenn Major== 0, bist du in Alpha / Pre-Release. Major> = 1 sind Ihre öffentlichen Veröffentlichungen.
• Niedrigere Zahlen werden bei jeder Erhöhung auf 0 zurückgesetzt

  1.5.3-> 1.5.4(Bugfix) -> 1.6.0(Minor Feature) -> 2.0.0(Breaking Change)

              1.0.0
                |
              1.0.1
                |
(public 1.0) 1.0.2 -----
                | \
              2.0.0 1.1.0
                | |
              2.0.1 1.1.1 (public 1.1)
                |
(public 2.0) 2.0.2 -----
                | \
              3.0.0 2.1.0
                         |
                       2.1.1 (öffentlich 2.1)
                         |
                       2.2.0
                         |
                       2.2.1

X.Y.Zist unsere interne Versionsnummer. X.Yist die öffentliche Versionsnummer, die für unsere Kunden eine Bedeutung hat. Wenn eine X.Y.ZVersion veröffentlicht wird, wird es nie eine X.Y.(Z+1)Version geben: Die öffentliche Version ist immer die letzte der Serie.

X wird erhöht, wenn eine Hauptversion veröffentlicht wird.

Y wird für die Wartungszweige dieser Hauptversionen verwendet, nur für Fehlerbehebungen.

Zwird intern verwendet und hat keine feste Bedeutung. Bis jetzt erstelle ich eine neue ZVersion, wenn ich denke, dass die Anwendung eine Reihe von Funktionen hat, die für Nicht-Entwickler interessant und relativ stabil sind. Auf diese Weise kann ich eine Demo der "letzten bekannten guten Version" der Anwendung anzeigen, wenn jemand danach fragt. In naher Zukunft plane ich, die ZNummernversionen für die Benennung eines "Ziels" von Funktionen in unserem Bugtracker zu verwenden.

Als Randnotiz verwenden wir maven (mit dem releaseBefehl), um die Versionsnummer zu erhöhen . Es gibt also auch X.Y.Z-SNAPSHOTVersionen (die jede Version zwischen X.Y.(Z-1)und anzeigen X.Y.Z).