Setzen Sie die Entwicklung in einem Zweig oder im Kofferraum fort? [geschlossen]

Angenommen, Sie entwickeln ein Softwareprodukt mit regelmäßigen Versionen. Was sind die Best Practices in Bezug auf Verzweigung und Zusammenführung? Schneiden Sie regelmäßig freigegebene Zweige für die Öffentlichkeit ab (oder für wen auch immer Ihr Kunde ist) und setzen Sie dann die Entwicklung des Trunks fort oder betrachten Sie den Trunk als stabile Version, markieren Sie ihn regelmäßig als Release und führen Sie Ihre experimentellen Arbeiten in Zweigen durch. Was denken die Leute, wird der Kofferraum als "Gold" oder als "Sandkasten" angesehen?

Ich habe beide Methoden mit einer großen kommerziellen Anwendung ausprobiert.

Die Antwort darauf, welche Methode besser ist, hängt stark von Ihrer genauen Situation ab, aber ich werde schreiben, was meine allgemeinen Erfahrungen bisher gezeigt haben.

Die insgesamt bessere Methode (meiner Erfahrung nach): Der Kofferraum sollte immer stabil sein.

Hier sind einige Richtlinien und Vorteile dieser Methode:

• Codieren Sie jede Aufgabe (oder einen zugehörigen Satz von Aufgaben) in einem eigenen Zweig. Dann haben Sie die Flexibilität, wann Sie diese Aufgaben zusammenführen und eine Freigabe durchführen möchten.
• Die Qualitätssicherung sollte für jeden Zweig durchgeführt werden, bevor er mit dem Trunk zusammengeführt wird.
• Wenn Sie die Qualitätssicherung für jeden einzelnen Zweig durchführen, wissen Sie genau, was den Fehler leichter verursacht hat.
• Diese Lösung lässt sich auf eine beliebige Anzahl von Entwicklern skalieren.
• Diese Methode funktioniert, da die Verzweigung in SVN fast sofort erfolgt.
• Kennzeichnen Sie jede von Ihnen durchgeführte Version.
• Sie können Funktionen entwickeln, die Sie für eine Weile nicht veröffentlichen möchten, und genau entscheiden, wann sie zusammengeführt werden sollen.
• Bei jeder Arbeit, die Sie ausführen, können Sie Ihren Code festschreiben. Wenn Sie nur außerhalb des Trunks arbeiten, werden Sie Ihren Code wahrscheinlich häufig nicht festgeschrieben und daher ungeschützt und ohne automatischen Verlauf.

Wenn Sie versuchen, das Gegenteil zu tun und Ihre gesamte Entwicklung im Kofferraum durchzuführen, treten die folgenden Probleme auf:

• Ständige Build-Probleme für tägliche Builds
• Produktivitätsverlust, wenn ein Entwickler ein Problem für alle anderen Personen im Projekt begeht
• Längere Release-Zyklen, da Sie endlich eine stabile Version erhalten müssen
• Weniger stabile Releases

Sie werden einfach nicht die Flexibilität haben, die Sie benötigen, wenn Sie versuchen, einen Zweig stabil zu halten und den Stamm als Entwicklungs-Sandbox. Der Grund dafür ist, dass Sie nicht aus dem Kofferraum auswählen können, was Sie in diese stabile Version einfügen möchten. Im Kofferraum wäre schon alles zusammengemischt.

Der einzige Fall, den ich besonders sagen würde, um die gesamte Entwicklung im Kofferraum durchzuführen, ist, wenn Sie ein neues Projekt starten. Abhängig von Ihrer Situation kann es auch andere Fälle geben.

Übrigens bieten verteilte Versionskontrollsysteme viel mehr Flexibilität und ich empfehle dringend, entweder auf hg oder git umzusteigen.

Ich habe mit beiden Techniken gearbeitet und ich würde sagen, dass es am besten ist, sich am Stamm zu entwickeln und stabile Punkte als Releases abzweigen.

Die Leute oben, die Einwände erheben und sagen, dass Sie haben werden:

• Ständige Build-Probleme für tägliche Builds
• Produktivitätsverlust, wenn ein Entwickler ein Problem für alle anderen Personen im Projekt begeht

haben wahrscheinlich keine kontinuierlichen Integrationstechniken verwendet.

Es ist wahr, dass, wenn Sie tagsüber nicht mehrere Test-Builds durchführen, etwa einmal pro Stunde, sich diesen Problemen aussetzen, die das Entwicklungstempo schnell einschränken.

Wenn Sie tagsüber mehrere Testbuilds durchführen, werden Aktualisierungen der Hauptcodebasis schnell eingeblendet, damit andere sie verwenden können, und Sie werden auch tagsüber benachrichtigt, wenn jemand den Build gebrochen hat, damit er ihn reparieren kann, bevor er nach Hause geht.

Wie bereits erwähnt, ist das Herausfinden eines fehlerhaften Builds, wenn der nächtliche Build zum Ausführen der Regressionstests fehlschlägt, reine Torheit und verlangsamt die Dinge schnell.

Lesen Sie Martin Fowlers Artikel über kontinuierliche Integration . Wir haben unser eigenes System für ein Großprojekt (3.000 kSLOC) in etwa 2.000 Linien von Posix sh gerollt.

Ich tendiere dazu, den "Release Branch" -Ansatz zu verfolgen. Der Kofferraum ist flüchtig. Sobald sich die Release-Zeit nähert, würde ich einen Release-Zweig erstellen, den ich vorsichtiger behandeln würde. Wenn das endlich erledigt ist, würde ich den Status des Repositorys beschriften / markieren, damit ich die "offizielle" veröffentlichte Version kenne.

Ich verstehe, dass es andere Möglichkeiten gibt, dies zu tun - genau so habe ich es in der Vergangenheit getan.

Beide.

Der Kofferraum wird für den Großteil der Entwicklung verwendet. Es wird jedoch erwartet, dass die besten Anstrengungen unternommen werden, um sicherzustellen, dass beim Einchecken in den Kofferraum dieser nicht beschädigt wird. (teilweise verifiziert durch ein automatisiertes Build- und Testsystem)

Releases werden in einem eigenen Verzeichnis verwaltet, wobei nur Fehlerbehebungen vorgenommen werden (und dann in Trunk zusammengeführt werden).

Alle neuen Funktionen, die den Trunk in einem instabilen oder nicht funktionierenden Zustand belassen, werden in einem eigenen Zweig ausgeführt und nach Abschluss in den Trunk eingefügt.

Ich mag und verwende den von Henrik Kniberg in der Versionskontrolle für mehrere agile Teams beschriebenen Ansatz . Henrik hat großartige Arbeit geleistet, um zu erklären, wie man mit der Versionskontrolle in einer agilen Umgebung mit mehreren Teams umgeht (funktioniert auch in traditionellen Umgebungen für ein einzelnes Team), und es macht keinen Sinn, ihn zu paraphrasieren, also werde ich einfach den "Spickzettel" posten (der ist selbsterklärend) unten:

Ich mag es weil:

• Es ist ganz einfach: Sie können es vom Bild bekommen.
• Es funktioniert gut (und skaliert) ohne zu viele Zusammenführungs- und Konfliktprobleme.
• Sie können "funktionierende Software" jederzeit veröffentlichen (im Geiste der Agilität).

Und nur für den Fall, dass es nicht explizit genug war: Die Entwicklung erfolgt in "Arbeitszweigen", der Trunk wird für DONE-Code (freigebbar) verwendet. Überprüfen Sie die Versionskontrolle für mehrere agile Teams auf alle Details.

Eine gute Referenz für einen Entwicklungsprozess, der den Stamm stabil hält und alle Arbeiten in Filialen erledigt, ist das Ultimate Quality Development System von Divmod . Eine kurze Zusammenfassung:

• Jeder geleisteten Arbeit muss ein Ticket zugeordnet sein
• Für jedes Ticket wird eine neue Verzweigung erstellt, in der die Arbeit für dieses Ticket erledigt ist
• Änderungen aus diesem Zweig werden nicht wieder in den Hauptleitungs-Trunk übernommen, ohne von einem anderen Projektmitglied überprüft zu werden

Sie verwenden hierfür SVN, dies kann jedoch problemlos mit jedem der verteilten Versionskontrollsysteme durchgeführt werden.

Ich denke, Ihr zweiter Ansatz (z. B. das Markieren von Releases und das Ausführen von experimentellen Dingen in Zweigen unter Berücksichtigung des Stammstalls) ist der beste Ansatz.

Es sollte klar sein, dass Zweige alle Fehler eines Systems zum Zeitpunkt der Verzweigung erben: Wenn Korrekturen auf einen Trunk angewendet werden, müssen Sie alle Zweige einzeln bearbeiten, wenn Sie Zweige als eine Art von Zweigen verwalten Zyklusabschluss freigeben. Wenn Sie bereits 20 Releases hatten und einen Fehler entdeckt haben, der bis zum ersten zurückreicht, müssen Sie Ihren Fix 20 Mal erneut anwenden.

Zweige sollen die echten Sandkästen sein, obwohl der Stamm auch diese Rolle spielen muss: Tags zeigen an, ob der Code zu diesem Zeitpunkt "Gold" ist und für die Freigabe geeignet ist.

Wir entwickeln uns am Kofferraum, es sei denn, die Änderungen sind zu umfangreich, destabilisierend oder wir nähern uns einer Hauptversion eines unserer Produkte. In diesem Fall erstellen wir eine temporäre Niederlassung. Wir schaffen auch eine permanente Niederlassung für jede einzelne Produktversion. Ich fand das Microsoft-Dokument zur Verzweigungsanleitung sehr hilfreich. Das Tutorial von Eric Sink zum Verzweigen ist ebenfalls interessant und weist darauf hin, dass das, was für Microsoft funktioniert, für einige von uns zu schwer sein kann. In unserem Fall verwenden wir tatsächlich den Ansatz, den Eric seinem Team sagt.

Es hängt von Ihren Situationen ab. Wir verwenden Perforce und haben normalerweise mehrere Entwicklungslinien. Der Stamm wird als "Gold" betrachtet und die gesamte Entwicklung erfolgt auf Zweigen, die wieder zur Hauptlinie zusammengeführt werden, wenn sie stabil genug sind, um integriert zu werden. Dies ermöglicht die Ablehnung von Features, die nicht den Schnitt machen, und kann im Laufe der Zeit eine solide inkrementelle Fähigkeit bieten, die unabhängige Projekte / Features aufnehmen können.

Das Zusammenführen und Aufholen neuer Funktionen im Kofferraum ist mit Integrationskosten verbunden, aber Sie werden trotzdem unter diesen Schmerzen leiden. Wenn sich alle gemeinsam am Stamm entwickeln, kann dies zu einer Wild-West-Situation führen. Durch Verzweigen können Sie die Punkte skalieren und auswählen, an denen Sie die bitteren Integrationspillen einnehmen möchten. Wir sind derzeit auf über hundert Entwickler in einem Dutzend Projekten skaliert, von denen jedes mehrere Releases mit denselben Kernkomponenten verwendet, und es funktioniert ziemlich gut.

Das Schöne daran ist, dass Sie dies rekursiv tun können: Ein Zweig mit großen Merkmalen kann ein eigener Stamm sein, wobei sich andere Zweige lösen, wenn dies der Fall ist. Außerdem erhalten die endgültigen Versionen einen neuen Zweig, in dem Sie stabile Wartungsarbeiten durchführen können.

Der Versuch, die Wartung des aktuellen Produktionscodes im Einklang mit der Neuentwicklung zu verwalten, ist bestenfalls problematisch. Um diese Probleme zu mindern, sollte der Code nach Abschluss der Testarbeiten in eine Wartungszeile verzweigen und der Code ist zur Auslieferung bereit. Darüber hinaus sollte die Hauptlinie verzweigen, um die Stabilisierung der Freisetzung zu unterstützen, experimentelle Entwicklungsbemühungen einzudämmen oder Entwicklungsbemühungen aufzunehmen, deren Lebenszyklus sich über mehrere Versionen erstreckt.

Ein nicht wartungsbezogener Zweig sollte nur erstellt werden, wenn die Wahrscheinlichkeit (oder Gewissheit) von Kollisionen zwischen dem Code besteht, die auf andere Weise schwierig zu verwalten wären. Wenn die Niederlassung ein logistisches Problem nicht löst, wird eines erstellt.

Die normale Release-Entwicklung erfolgt in der Hauptlinie. Entwickler checken für normale Release-Arbeiten in die Mainline ein und aus. Die Entwicklungsarbeiten für Patches für den aktuellen Produktionscode sollten sich in der Verzweigung für diese Version befinden und dann mit der Hauptlinie zusammengeführt werden, sobald der Patch die Tests bestanden und bereitgestellt wurde. Arbeiten in nicht wartungsbezogenen Niederlassungen sollten von Fall zu Fall koordiniert werden.

Dies hängt von der Größe Ihres Entwicklungsaufwands ab. Mehrere Teams, die parallel arbeiten, können nicht alle effektiv mit demselben Code (Trunk) arbeiten. Wenn nur eine kleine Gruppe von Personen arbeitet und Ihr Hauptanliegen darin besteht, einen Zweig zu schneiden, damit Sie weiterarbeiten können, während Sie zum Zweig zurückkehren, um Fehlerbehebungen am aktuellen Produktionscode vorzunehmen, der funktionieren würde. Dies ist eine triviale Verwendung der Verzweigung und nicht zu belastend.

Wenn Sie viele parallele Entwicklungen haben, möchten Sie für jede der Bemühungen Zweige haben, aber das erfordert auch mehr Disziplin: Stellen Sie sicher, dass Ihre Zweige getestet und bereit sind, wieder zusammengeführt zu werden. Planen von Zusammenführungen, damit zwei Gruppen nicht gleichzeitig versuchen, zusammenzuführen usw.

Einige Zweige befinden sich so lange in der Entwicklung, dass Sie Zusammenführungen vom Stamm zum Zweig zulassen müssen, um die Anzahl der Überraschungen beim endgültigen Zusammenführen mit dem Stamm zu verringern.

Sie müssen experimentieren, wenn Sie eine große Gruppe von Entwicklern haben und ein Gefühl dafür bekommen, was in Ihrer Situation funktioniert. Hier ist eine Seite von Microsoft, die etwas nützlich sein kann: http://msdn.microsoft.com/en-us/library/aa730834(VS.80).aspx

Wir verwenden den Trunk für die Hauptentwicklung und den Zweig für Wartungsarbeiten an Releases. Es funktioniert gut. Aber dann sollten Zweige nur für Fehlerkorrekturen verwendet werden, keine größeren Änderungen, insbesondere auf der Datenbankseite. Wir haben die Regel, dass nur eine Schemaänderung auf dem Haupttrunk und niemals auf dem Zweig stattfinden kann.

Wenn Sie einen Release-Zyklus durcharbeiten, ein großes Feature, werden Sie zu einem Zweig gestrandet. Ansonsten arbeiten wir im Trunk und verzweigen für jede Produktionsversion zum Zeitpunkt unserer Erstellung.

Frühere Produktions-Builds wurden zu diesem Zeitpunkt auf old_production_ verschoben, und die aktuelle Produktversion ist immer nur die Produktion. Unser Build-Server weiß nur, wie der Produktionszweig bereitgestellt wird, und wir starten diesen Build mit einem Force-Trigger.

Wir folgen dem Ansatz trunk = aktueller Entwicklungsstrom, branch = release (s). Bei der Freigabe an den Kunden verzweigen wir den Kofferraum und halten den Kofferraum einfach vorwärts. Sie müssen entscheiden, wie viele Releases Sie unterstützen möchten. Je mehr Sie unterstützen, desto mehr Zusammenführungen werden Sie bei Fehlerkorrekturen durchführen. Wir versuchen, unsere Kunden auf nicht mehr als 2 Releases hinter dem Kofferraum zu halten. (ZB Dev = 1.3, unterstützte Releases 1.2 und 1.1).

Der Kofferraum ist in der Regel die Hauptentwicklungslinie.

Releases werden abgezweigt und häufig werden experimentelle oder größere Arbeiten an Zweigen durchgeführt, die dann wieder in den Trunk integriert werden, wenn sie für die Integration in die Hauptentwicklungslinie bereit sind.

Der Trunk sollte im Allgemeinen Ihre Hauptentwicklungsquelle sein. Andernfalls verbringen Sie viel Zeit mit dem Zusammenführen neuer Funktionen. Ich habe gesehen, dass es anders gemacht wurde und es führt normalerweise zu vielen Integrationsproblemen in letzter Minute.

Wir kennzeichnen unsere Releases, damit wir schnell auf Produktionsnotfälle reagieren können, ohne die aktive Entwicklung zu verteilen.

Für mich hängt es von der Software ab, die ich verwende.

Unter CVS würde ich nur in "Trunk" arbeiten und niemals taggen / verzweigen, weil es wirklich schmerzhaft war, etwas anderes zu tun.

In SVN würde ich meine "neuesten" Sachen im Kofferraum machen, aber wenn es Zeit war, einen Server-Push zu machen, werde ich entsprechend markiert.

Ich habe kürzlich zu Git gewechselt. Jetzt finde ich, dass ich nie im Kofferraum arbeite. Stattdessen verwende ich einen benannten Sandbox-Zweig mit dem Namen "new-featurename" und füge ihn dann zu einem festen Zweig mit der aktuellen Produktion zusammen. Jetzt, wo ich darüber nachdenke, sollte ich wirklich "release-VERSIONNUMBER" -Zweige erstellen, bevor ich wieder zur "aktuellen Produktion" übergehe, damit ich zu älteren stabilen Versionen zurückkehren kann ...

Es hängt wirklich davon ab, wie gut Ihre Organisation / Ihr Team Versionen verwaltet und welches SCM Sie verwenden.

• Wenn sich die nächsten Schritte (in der nächsten Version) leicht planen lassen, ist es besser, wenn Sie sich im Kofferraum entwickeln. Das Verwalten von Filialen erfordert mehr Zeit und Ressourcen. Aber wenn der nächste nicht einfach geplant werden kann (was in größeren Organisationen immer der Fall ist), würden Sie wahrscheinlich eher Commits für die Kirschernte (Hunderte / Tausende) als Zweige (mehrere oder zehn) erhalten.
• Mit Git oder Mercurial ist das Verwalten von Zweigen viel einfacher als mit Lebensläufen und Subversion. Ich würde mich für die stabile Trunk / Topic Branch-Methodik entscheiden. Dies ist, was das git.git-Team verwendet. Lesen Sie: http://www.kernel.org/pub/software/scm/git/docs/gitworkflows.html
• Bei Subversion habe ich zuerst die Entwicklungslogik angewendet. Es gab einige Arbeiten, wenn es um das Erscheinungsdatum ging, da ich jedes Mal Commits auswählen musste (meine Firma ist nicht gut in der Planung). Jetzt bin ich eine Art Experte für Subversion und weiß ziemlich gut, wie man Zweige in Subversion verwaltet. Daher bewege ich mich in Richtung der Methode der stabilen Stamm- / Themenzweige. Es funktioniert viel besser als zuvor. Jetzt versuche ich, wie das Team von git.git funktioniert, obwohl wir wahrscheinlich bei Subversion bleiben werden.

Hier ist das SVN-Design, das ich bevorzuge:

• Wurzel
  • Entwicklung
    • Geäst
      • feature1
      • feature2
      • ...
    • Kofferraum
  • Beta
    • Stichworte
    • Kofferraum
  • Freisetzung
    • Stichworte
    • Kofferraum

Alle Arbeiten werden von der Entwicklung / dem Trunk aus ausgeführt, mit Ausnahme der Hauptfunktionen, für die ein eigener Zweig erforderlich ist. Nachdem die Arbeit gegen Entwicklung / Trunk getestet wurde, führen wir getestete Probleme in Beta / Trunk zusammen. Bei Bedarf wird der Code gegen den Beta-Server getestet. Wenn wir bereit sind, einige Änderungen einzuführen, führen wir einfach die entsprechenden Revisionen in Release / Trunk zusammen und stellen sie bereit.

Tags können im Beta-Zweig oder im Release-Zweig erstellt werden, damit wir die spezifische Version sowohl für die Beta als auch für die Version verfolgen können.

Dieses Design ermöglicht viel Flexibilität. Es macht es uns auch einfach, Revisionen in Beta / Trunk zu belassen, während andere zu Release / Trunk zusammengeführt werden, wenn einige Revisionen die Tests in Beta nicht bestanden haben.

Die Methode, die wir verwenden, ist der Perforce-Ansatz, der in Laura Wingerds großartigem Buch ausführlich behandelt wird:

http://oreilly.com/catalog/9780596101855/index.html

Während sich das Buch auf Perforce konzentriert (Wingerd ist ein Perforce-Produktmanager), können die Konzepte auf jedes oder alle VCS angewendet werden.

Der Perforce-Ansatz (und die Plattform) haben uns sehr gute Dienste geleistet. Es wird in vielen Firmen verwendet (Google, Intuit und, wie ich gehört habe, Microsoft Windows selbst).

Das Buch ist es wert, gelesen zu werden.

Lesen Sie dies: http://oreilly.com/catalog/practicalperforce/chapter/ch07.pdf

Es gibt IMHO keine einheitliche Antwort auf die Frage nach der Subversion-Konvention.

Es hängt wirklich von der Dynamik des Projekts und des Unternehmens ab, das es verwendet. In einer sehr schnelllebigen Umgebung, in der eine Veröffentlichung möglicherweise alle paar Tage erfolgt und Sie versuchen, religiös zu kennzeichnen und zu verzweigen, erhalten Sie ein nicht verwaltbares Repository. In einer solchen Umgebung würde der Branch-bei-Bedarf-Ansatz eine viel wartbarere Umgebung schaffen.

Außerdem ist es meiner Erfahrung nach aus rein administrativer Sicht äußerst einfach, bei Bedarf zwischen SVN-Methoden zu wechseln.

Die beiden Ansätze, von denen ich weiß, dass sie am besten funktionieren, sind der Zweig bei Bedarf und der Zweig bei jeder Aufgabe. Dies ist natürlich das genaue Gegenteil voneinander. Wie gesagt - es geht nur um die Projektdynamik.

@ Brian R. Bondy: Bitte beachten Sie, dass dies keine Lösung ist, sobald Ihr Team eine bestimmte Anzahl von Personen / Aufgaben erreicht hat, die parallel im Projekt behandelt werden.

Sobald eine QS-Abteilung an der Qa beteiligt ist, ist der Aufwand für die Bereitstellung einer Installation pro laufender Niederlassung einfach zu hoch. Denken Sie an SOA / Clients / Server / WebServices / Datenbanken, die alle pro Zweig bereitgestellt werden müssen .

Dieser Lösung fehlt auch die Integrationsphase.