Wie stellen Sie verschiedene Versionen Ihrer Bibliothek unter Versionskontrolle? Verwenden Sie Tags? Oder Filialen? Oder eine andere Methode?

Ich habe kürzlich begonnen, meinen Code der Versionskontrolle zu unterstellen (im Labor arbeite ich unter SVN und meine eigenen Codes in github (offensichtlich mit git)). Vor der Verwendung der Versionskontrolle habe ich so etwas gemacht. Ich hatte einen Ordner mit dem Namen der Bibliothek in vielen Ordnern mit der Versionsnummer. Jedes Mal, wenn ich anfangen wollte, an einer neueren Version zu arbeiten, habe ich eine Kopie der letzten Version erstellt, den Namen in die neue Version geändert und mit der Implementierung begonnen.

Dies scheint jedoch überflüssig zu sein, wenn der Ordner unter Versionskontrolle gestellt wird. Abgesehen von Redundanz würde jemand, der die neueste Version erhalten möchte, alle Versionen herunterladen, wenn er nur imports / clones ist.

Jetzt sehe ich viele Möglichkeiten, dies mit der Versionskontrolle zu tun, aber da ich neu darin bin, weiß ich nicht, welche besser zu warten wären.

Methode 1: Verwenden von Tags

Wenn ich Tags richtig verstanden hätte, hätten Sie Ihren Hauptzweig, Sie schreiben fest, was Sie geändert haben, und versehen sie mit einer Version. Wenn Sie dann eine Arbeitskopie davon erhalten möchten, erhalten Sie die mit einem bestimmten Tag. (korrigiere mich wenn ich falsch liege)

Methode 2: Verzweigungsversionen

Bei dieser Methode wäre der Hauptzweig der Entwicklungszweig. Hin und wieder, wenn eine stabile Version erstellt wird (sagen wir v1.2.0mal), erstellen Sie einen Zweig für diese Version und verpflichten sich nie dazu. Wenn Sie auf diese Weise eine bestimmte Version herunterladen möchten, erhalten Sie den Code aus diesem Zweig. Obwohl ich sagte, dass Sie sich nie dazu verpflichten, können Sie möglicherweise Fehlerbehebungen vornehmen und einen Commit für den Zweig einer alten Version durchführen, um die alte Version am Laufen zu halten. Wenn zum Beispiel die aktuelle Version ist v2.0, aber es gibt Leute, die sie verwenden möchten v1.2, können Sie einen anderen Zweig von bekommen v1.2, nämlich v1.2.1und die Fehlerbehebungen festschreiben, oder einfach die gleiche Version behalten wie v1.2und nur die Fehlerbehebungen festschreiben.

Die Zweige würden also so aussehen:

                  v1.2.1  v1.2.2
                 /       /
 v1.0.0   v1.2.0---------     v2.0.0
/        /                   /
-------------------------------------- dev

Auf diese Weise haben Sie Zweige für jedes kleinere Versionsupdate. (Beachten Sie, dass in der obigen Grafik v1.2.1 und v1.2.2 oder nach der Veröffentlichung von v2.0.0 erstellt wurden und daher nicht Teil der Entwicklung zwischen v1.2.0 und v2.0.0 waren. Stellen Sie sich dies als Unterstützung für ältere Versionen vor.)

Methode 3: Verzweigungsentwicklung

Diese Methode ist das Gegenteil der vorherigen. Der Hauptzweig wäre die neueste stabile Version. Wenn Sie an einer neuen Version arbeiten, erstellen Sie einen Zweig (für die Entwicklung), bearbeiten Ihren Code und führen ihn, wenn er stabil ist, mit dem Hauptzweig zusammen.

In diesem Fall sehen die Zweige folgendermaßen aus:

 ________  ____  ________________  _____ dev
/        \/    \/                \/
---------------------------------- latest_version

Wahrscheinlich muss dies in Verbindung mit Tags gemacht werden, oder?

Die Frage!

Wie auch immer, meine Frage ist, welche dieser Methoden erweist sich aufgrund Ihrer Erfahrung als praktikabler? Gibt es eine bekannte beste Methode (die ich möglicherweise nicht selbst herausgefunden habe)? Wie werden diese Dinge gewöhnlich gemacht?

Tags und Zweige sind nicht gegenseitig, Sie können (und IMO sollten es normalerweise tun) beide verwenden. Tags markieren Meilensteine ​​in der Entwicklung. Zum Beispiel öffnen Sie eine Niederlassung für die Version 1.2 des Produkts, und Sie markieren v1.2 Beta, RC1, RC2, Final(und dann, wenn nötig, SP1etc.) mit Umbauten am selben Zweig.

Ich persönlich bevorzuge Methode 2 als Standardansatz (obwohl ich versuche, mehrere Ebenen von Zweigen zu vermeiden, um das Leben so einfach wie möglich zu halten). Methode 1 funktioniert im wirklichen Leben einfach nicht - Tags reichen nicht aus, Sie benötigen Verzweigungen. Und Methode 3 ist insofern unflexibel, als sie immer nur eine einzige stabile Version hat. Sie können also (sofern Sie sie nicht mit Methode 2 kombinieren) nicht mehrere (neueste und ältere) Versionen gleichzeitig verwalten. Dies ist für fast alle Projekte im realen Leben erforderlich. Während Sie an Version 2 arbeiten, sollten Sie dennoch in der Lage sein, Patches / Upgrades für v1.9 und häufig auch frühere Versionen zu veröffentlichen. Viel hängt natürlich von der Art der Anwendung ab. Wir entwickeln eine Web-App, sodass es zu jedem Zeitpunkt nur eine Produktionsversion gibt. Trotzdem jonglieren wir häufig mit 3 verschiedenen Versionen (eine in der Produktion, Eine ist in UAT und bereitet sich auf die Bereitstellung vor. Eine ist die neueste Version im Trunk. Es kann für eine Desktop- / Client-App sehr viel komplexer werden, wenn mehrere ältere Versionen gleichzeitig verwendet und gewartet werden.

Ich hatte einen Ordner mit dem Namen der Bibliothek in vielen Ordnern mit der Versionsnummer.

Wie Sie bemerken, ist dies effektiv ein falscher Ansatz, da Sie bereits die Versionskontrolle haben, um ... die Versionen zu kontrollieren.

Nun scheinen verschiedene Techniken, die Sie aufzählen, alle gleich gut zu sein. Sie können einen sehr ausführlichen Artikel lesen Source Control Done Right , die Informationen über Tags und Zweige enthält.

Die drei Methoden schließen sich nicht gegenseitig aus, und Sie sollten die drei Methoden kombinieren, um Ihre Versionskontrolle optimal zu nutzen.

Ich für meinen Teil würde standardmäßig eine Kombination aus Methode 1 und 3 verwenden, d. H. In einem Feature oder Entwicklungszweig entwickeln, bis ein Feature produktionsbereit ist, und dann wieder in trunk zusammenführen. Auf diese Weise repräsentiert trunk immer den aktuellen Stand der stabilen, zu verwendenden Entwicklung und kann durch svn: external-Projekte sicher verknüpft werden. Wenn Sie eine Version veröffentlichen, markieren Sie sie.

Ich würde nur bei Bedarf verzweigen, wenn ältere Versionen Ihrer Bibliothek einen Fehler haben , der behoben werden muss. Sie können diesen Zweig einfach aus dem Tag der fehlerhaften Version erstellen. Indem Sie nicht unnötig verzweigen, halten Sie die Anzahl der Zweige niedrig und haben einen schnellen Überblick über die zu pflegenden Blutungsränder (Stamm und alle Zweige).

Ich würde Methode 2 verwenden . Ich habe dies verwendet und festgestellt, dass es eine effektive Möglichkeit ist, mehrere Versionen zu verwalten und zu warten, während die aktuelle Entwicklung weiterhin fortgesetzt werden kann. Sie können Tags auch in Verbindung mit dieser Methode verwenden, wenn Sie sie benötigen.

Weitere Informationen zur Verwendung der Verzweigung zur Verwaltung mehrerer Release-Versionen finden Sie in meiner Antwort hier .