Moderiert von Christian S.: Abgetrennt von [url=www.delphi-forum.de/...p?t=79572]hier[/url]

Popov hat folgendes geschrieben:

Das was ich jetzt sage ist nicht böse gemeint, aber wieso setzen alle die erste Alpha/Beta Versionsnummer immer bei 0.9.0 an? Eigentlich ist das Programm noch sehr weit von 1.0 entfernt, aber die hoch angesetzte Nummer führt zu schnell zu einer 1 die noch nicht fertig ist. Ein Tipp: solange man entwickelt immer unter 0.0.x bleiben. Die erste funktionierende Version kann man dann auf 0.1.x setzen. Und dann solange bleiben bis alle Bugs raus sind. Wenn man alles umprogrammiert, kann man meinetwegen auf 0.2.x setzen, aber nicht vorher. Wenn alle Test durch sind, kann man die 1 wählen, nicht vorher.

Kurz OT: Meine Programme beginnen grundsätzlich bei Version 1.0, egal ob Alpha, Beta, Gamma, Delta oder auch Epsilon. Es ist nun mal die 1. Version, die Version 1 und nicht die 0.1. Version, sowas gibt es nämlich nicht. Ich kann Programme nicht ab, die mit der Version 0.0.1.1 beginnen und nie die 1.0 erreichen. Aber das muss jeder selber entscheiden.

GTA-Place hat folgendes geschrieben:

Kurz OT: Meine Programme beginnen grundsätzlich bei Version 1.0, egal ob Alpha, Beta, Gamma, Delta oder auch Epsilon. Es ist nun mal die 1. Version, die Version 1 und nicht die 0.1. Version, sowas gibt es nämlich nicht. Ich kann Programme nicht ab, die mit der Version 0.0.1.1 beginnen und nie die 1.0 erreichen. Aber das muss jeder selber entscheiden.

Zuerst sollte geklärt werden, daß es hier nicht nur um dieses Programm geht, sondern allgemein. Ich wollte mich nur mal zu der Versionierung äußern.

Natürlich sollte die Version 1 die Version 1 sein, nur sollte die 1 signalisieren, daß es eine fertige Version ist. Ich weiß was du meinst. Es gibt tatsächlich einige Programme die schon seit Jahren 0.x sind. Natürlich ist das genau so übertrieben als wenn man es zu hoch angesetzt hätte. Es sind aber vor allem OpenSource unter Linux die so langsam vorangehen, da man sich wohl nie einigen kann wie die 1 auszusehen hat. Auf der anderen Seite ist es Phantastisch wenn man sieht, daß einige Leute innerhalb eines Monats auf die Version 5 kommen. Nur bedeuten leider bei 99% der anderen Programme die Versionsnummern etwas. _._.x bedeutet, daß Fehler beseitigt wurden, _.x._ bedeutet, daß etwas Neues dazugekommen ist, _.5._ bedeutet, daß die Änderungen sehr groß sind und eigentlich eine neue Version, aber letztendlich doch nicht so groß, daß sie eine neue Vollversion rechtfertigen würde, x._._ bedeutet, daß sich das Programm deutlich von der Vorversion unterscheidet und zum Teil schon ganz anders funktioniert oder mit der alten Version nicht kompatibel ist. Es steht dir frei die erste Version mit 1 anzusetzen und nach Korrektur der Fehler draus die 2 zu machen, aber damit verwirrst du nur die Nutzer. Die 1 sollte bedeuten, daß das Programm eben getestet wurde und fertig ist.

1.Version: 1.0

Bugfix: 1.01

Änderung: 1.05

Großes Update/Bugfix : 1.10

So mach ich es. Guckt doch mal unter den Projektoptionen nach, wie Delphi das vorschlägt. Pro Build 1.0.0.x? Keine Ahnung, ich hab' noch nicht nachgeguckt. Vielleicht sollte man zur absoluten Verwirrung auch ein 1.0.0.0.1 machen? Aber wozu eigentlich? Die Versionsnummer sollte zur Identifikation dienen, keiner Regel folgen: Man könnte jedem Build eine Zufallszahl zuweisen: Explorer 583, Shredder 639, Editor 1?

So:

Hauptversion.Nebenversion.Ausgabe.Compilierung

Nun ja, auch die 0.0.0.x hat etwas zu sagen. Bei mir ist es die Kompilierung, so daß ich zwischen zwei kompilierten Versionen, wo eigentlich nur programmiert wurde, unterscheiden kann. Hab ich dann zwei Versionen, weiß ich welche neuer ist. Alternativ ist, daß du die vierte Zahl nicht nutzt. Wenn man alleine arbeitet ist das nicht wichtig, aber arbeite mal mit paar Leuten und versuche mal zu klären welche Version du nun meinst, wo jeder zwar eine andere Version hat, aber alle die gleiche Versionsnummer. Versuche dann zu klären wer welche Version von welchen Tag hat.

@Popov: Ja, ich stimmte dir zu, dass eine Version 5, 6, 7, etc. keinen Sinn macht. Ich gehe da nach einem einfachen Prinzip vor. Die 1. Version ist die Version 1.0 (eventuell noch eine Beta-Version davor, die dann aber keine Versionsnummer besitzt, lediglich die Bezeichnung "Beta"). Jede Änderung entspricht bei mir 0.01 in der Versionsnummer. Beispiel: Ich habe 10 Fehler gefixt, nachdem Version 1.0 draußen war, dann nenne ich die Version 1.10. Das hat bei Heiliger Damm ganz gut funktioniert. Da bin ich bei Version 1.72, also (ungefähr) 72 Änderungen seit der 1. Version. Mittlerweile plane ich eh Version 2.0* und dann passt das sogar. (Dieses System bietet sogar den Vorteil, bei weniger als 100 Änderungen zu bleiben )

*Eine Steigerung auf Version 2 bedeutet in meinem Fall, dass wirklich was ganz neues hinzukommt und die Version nur noch wenig mit der 1. Version zu tun hat. Über Version 2 bin ich bisher noch nicht gekommen

@Mitmischer 1703: Dein System ist ganz ähnlich wie meins, nur dass du eben größere Sprünge machst.

Popov hat folgendes geschrieben:

so daß ich zwischen zwei kompilierten Versionen, wo eigentlich nur programmiert wurde, unterscheiden kann. Hab ich dann zwei Versionen, weiß ich welche neuer ist.

Das ist bei meinem System ebenfalls ersichtlich und - da stimme ich dir ja zu - ganz nützlich

Hab ich mal irgendwo bei Wiki gelesen und Windows und Delphi unterstützen es ja auch so:

x.x.x.xxxx
1 2 3 4

1.) Programmversion (meistens 1, da bei 2 schon neu programmiert sein müsste)
2.) große Änderungen (Nebenversion)
3.) kleine Änderungen (Fehlerkorrektur)
4.) Buildnummer (Anzahl der Änderungen/daher 4 Stellen)

Da das aber für die meisten Endverbraucher zu verwirrend mit den Builds ist und man nur selten auf 2.0.0.0000 kommt, lässt man das einafch weg, sodass die Versionsnummer unter der man fertige Versionen veröffentlicht nur noch aus 2. und 3. bestehen. Finde ich ein ganz gutes System.

Wie man aber in diesem System jetzt Beta/Alphaversionen unterbringt weiß ich nicht/stand da nicht ! Man könnte solang man noch nicht alle anfangs geplanten Sachen drin sind bei 0.x.x.xxxx bleiben, wobei das wiederrum gegen das System sprechen würde.

Oder fängt bei 1.0.9.xxxx an...

Aber mal ehrlich, das ist doch Sache des Programmieres, auch wenn es manche gibt, die dabei übertreiben!

de.wikipedia.org/wiki/Versionsnummer

Hi,

ich halte das so:

* Die erste Programmversion ist immer die 1.0.0. Die Entscheidung, wann die erste Position hochgezaehlt wird, ist "politisch", sprich: Die trifft der Chef. Meist bedeutet das dann, dass irgendwelche Dateistrukturen inkompatibel geworden sind.
* Kleinere Aenderungen zaehlen die 3. Position hoch: 1.0.1, 1.0.2 etc., dabei wird diese Zahl durchaus auch mal zweistellig: 1.0.53 .
* Groessere Aenderungen zaehlen die 2. Position hoch und setzen die 3. wieder auf 0: 1.1.0 etc., dann kleinere Aenderungen wieder die 3. Stelle: 1.1.1, 1.1.2 etc. Auch diese Position kann zweistellig werden.
* Die 4 Stelle enthaelt die Buildnummer, die beginnt bei 0 und wird bei jedem Build automatisch hochgezaehlt (wobei ich dafuer nicht die Funktion der IDE verwende, aber das ist eine andere Geschichte) und niemals zurueckgesetzt. An dieser Nummer kann man also erkennen, dass es sich jeweils um eine Fortenwicklung handelt. Ich habe schonmal darueber nachgedacht, hier stattdessen die SubVersion-Repositorynummer zu benutzen. Das haette den Vorteil, dass auch bei mehreren Entwicklern, die parallel an einem Projekt arbeiten, die Nummer immer korrekt hochgezaehlt wird.

Als Programmversion werden nur die ersten drei Positionen betrachtet, d.h. die Buildnummer ist nur noch eine zusaetzliche Angabe.

twm

Bei mir läuft das wie Gahero das geschrieben hat, nur hab ich nur 3 Stellen und vergessen meist den zweiten Punkt (x.xx)
Ich finde das System recht übersichtlich...

Und Alpha und Beta-Versionen bekommen immer irgendwelche Zahlen... Meist bei x.y.x, das ist mir aber ziemlich egal, da das sowieso niemand mitkriegt... ok, wenn ich demnächst mit nem größeren Projekt anfange, dann muss ich mir nen System ausdenken...

Ich halte es bis jetzt noch ziemlich einfach, weil ich noch keine wirklich großen Projekte mache. Bis die erste Version da ist, und ich etwas veröffentlichen kann, brauche ich eigentlich keine Versionen. Jeden Tag lege ich einen neuen Ordner an, benenne ihn



wobei XX eine Nummer ist, fixed auf 2 Stellen, mit vorangestellter Null, wenn es notwendig ist. (Die Nummer dient nur zur alphabetischen Sortierung, damit das noch klappt).


Wenn ein Programm dann mal veröffentlicht wurde, dann habe ich folgendes System:

• X: Hauptversion Wird nur bei Layoutänderung etc. inkrementiert.
  
• Y: Nebenversion Wird bei jeder Publizierung inkrementiert, auch bei kleinen Änderungen.
  
• Z: Private Tag-Variable Wenn eine Version über mehrere Tage nicht fertiggestellt wurde, inkrementiert sich dieser Teil.

Wobe man noch wissen sollte, dass ich immer alle Bugs etc. auf einmal behebe, und mir gut überlege, ob ich jetzt eine Version veröffentliche. Nur dann wird die Nebenversion hochgezählt.

Ich denke, irgendwann werde ich auch ein genaueres System verwenden, aber zur Zeit reicht es mir vollkommen aus.

Moderiert von Christian S.: Aufzählung mittels Grafiken durch HTML-Aufzählung ersetzt