Seltsamer Release-Zyklus eines Unternehmens: Go Distributed Source Control?

Entschuldigung für diesen langen Beitrag, aber ich denke, es lohnt sich.

Ich habe gerade mit einem kleinen .NET-Shop angefangen, der ganz anders funktioniert als andere Orte, an denen ich gearbeitet habe. Im Gegensatz zu meinen vorherigen Positionen richtet sich die hier beschriebene Software an mehrere Kunden und nicht jeder Kunde erhält gleichzeitig die neueste Version der Software. Daher gibt es keine "aktuelle Produktionsversion". Wenn ein Kunde ein Update erhält, erhält er auch alle Funktionen, die der Software seit dem letzten Update hinzugefügt wurden. Dies ist möglicherweise schon lange her. Die Software ist in hohem Maße konfigurierbar und Funktionen können ein- und ausgeschaltet werden: sogenannte "Feature-Toggles". Die Release-Zyklen sind hier sehr eng, tatsächlich liegen sie nicht im Zeitplan: Wenn eine Funktion abgeschlossen ist, wird die Software für den jeweiligen Kunden bereitgestellt.

Das Team ist erst letztes Jahr von Visual Source Safe zu Team Foundation Server gewechselt. Das Problem ist, dass sie TFS weiterhin wie VSS verwenden und Checkout-Sperren für einen einzelnen Codezweig erzwingen. Immer wenn eine Fehlerbehebung ins Feld gebracht wird (sogar für einen einzelnen Kunden), erstellen sie einfach alles, was in TFS enthalten ist. Testen Sie, ob der Fehler behoben wurde, und stellen Sie ihn dem Kunden zur Verfügung! (Ich komme aus einem Pharma-und Medizinprodukte-Software-Hintergrund das ist unglaublich!). Das Ergebnis ist, dass halb gebackener Entwicklercode in die Produktion geht, ohne dass er getestet wird. Bugs schlüpfen immer in Release-Builds, aber oft sieht ein Kunde, der gerade einen Build erhalten hat, diese Bugs nicht, wenn er die Funktion, in der sich der Bug befindet, nicht verwendet. Der Director weiß, dass dies ein Problem ist, da das Unternehmen langsam wächst plötzlich mit einigen großen Kunden an Bord und mehr kleineren.

Ich wurde gebeten, mir die Optionen für die Quellcodeverwaltung anzuschauen, um die Bereitstellung von fehlerhaftem oder unvollendetem Code zu verhindern, aber nicht die etwas asynchrone Natur der Teamversionen zu opfern. Ich habe in meiner Karriere VSS, TFS, SVN und Bazaar verwendet, aber TFS ist der Ort, an dem ich am meisten Erfahrung gesammelt habe.

Früher haben die meisten Teams, mit denen ich gearbeitet habe, eine Zwei- oder Drei-Zweig-Lösung von Dev-Test-Prod verwendet, bei der Entwickler einen Monat lang direkt in Dev arbeiten und dann die Änderungen zu Test, dann zu Prod zusammengeführt oder "wenn es fertig ist" befördert werden ein fester Zyklus. Es wurden automatisierte Builds verwendet, entweder mit Tempomat oder Teambuild. In meinem vorherigen Job wurde Bazaar über SVN verwendet: Entwickler arbeiteten in ihren eigenen kleinen Feature-Zweigen und setzten dann ihre Änderungen auf SVN (das mit TeamCity verknüpft war). Das war insofern schön, als es einfach war, Veränderungen zu isolieren und sie mit anderen Völkern zu teilen.

Bei beiden Modellen gab es einen zentralen Entwicklungs- und Prod-Zweig (und manchmal auch einen Testzweig), durch den Code gesendet wurde (und Labels wurden verwendet, um Builds in Prod zu kennzeichnen, aus denen Releases erstellt wurden ... und diese wurden zu Zweigen für Bugfixes gemacht zu Releases und fusionierte zurück zu dev). Dies passt jedoch nicht wirklich zur Arbeitsweise hier: Es gibt keine Reihenfolge, wann verschiedene Features veröffentlicht werden, sie werden gepusht, wenn sie vollständig sind.

Mit dieser Anforderung bricht der Ansatz der "kontinuierlichen Integration", wie ich ihn sehe, zusammen. Um ein neues Feature mit kontinuierlicher Integration herauszubringen, muss es über dev-test-prod gepusht werden, und noch nicht abgeschlossene Arbeiten in dev werden erfasst.

Ich denke, um dies zu überwinden, sollten wir ein stark funktionsverzweigtes Modell ohne Dev-Test-Prod-Verzweigungen verwenden. Stattdessen sollte die Quelle als eine Reihe von Funktionsverzweigungen existieren, die nach Abschluss der Entwicklungsarbeiten gesperrt, getestet, repariert und gesperrt werden getestet und dann freigegeben. Andere Feature-Zweige können Änderungen von anderen Zweigen abrufen, wenn sie benötigt werden / möchten, sodass alle Änderungen letztendlich in alle anderen übernommen werden. Das passt sehr gut zu einem reinen Basarmodell, das ich bei meinem letzten Job erlebt habe.

So flexibel das auch klingt, es scheint seltsam, irgendwo keinen Dev-Trunk oder Prod-Zweig zu haben, und ich mache mir Sorgen, dass Zweige sich nicht wieder integrieren lassen oder kleine späte Änderungen vorgenommen werden, über die sich andere Zweige und Entwickler nicht beschweren Zusammenführen von Katastrophen ...

Was denken die Leute darüber?

Eine zweite letzte Frage: Ich bin etwas verwirrt über die genaue Definition der verteilten Quellcodeverwaltung: Einige Leute scheinen zu vermuten, dass es sich nur um kein zentrales Repository wie TFS oder SVN handelt, andere sagen, dass die Verbindung getrennt wird (SVN ist zu 90% getrennt) und TFS hat einen perfekt funktionierenden Offline-Modus) und andere sagen, es geht um Feature Branching und die einfache Zusammenführung zwischen Zweigen ohne Eltern-Kind-Beziehung (TFS hat auch eine unbegründete Zusammenführung!). Vielleicht ist das eine zweite Frage!

Was ist ein DVCS?

Die verteilte in DVCS bedeutet , dass jeder Klon eines Endlagers alle Informationen verfügt , die zu begehen, zu aktualisieren, Zweig, merge oder in diesem Repository für jede Revision suchen, ohne jemals zu berühren einen Server . Das einzige, was Sie offline tun können, svnist die eigentliche Bearbeitung der Dateien - Sie benötigen für fast alle svnBefehle Serverzugriff, einschließlich der Durchführung von einfachen Aktionen wie dem Greifen von Befehlen svn log, sodass diese tatsächlich näher bei 0% als bei 90% liegen!

Jedes autorisierende zentrale Repository , das Sie in einem DVCS-Workflow einrichten, ist nur ein weiterer Klon. Sie müssen nur dann damit interagieren, wenn Sie die Aktualisierungen anderer Personen herunterladen oder Ihre eigenen Änderungen vornehmen, damit andere Personen sie sehen können , so ziemlich alles andere kann offline erledigt werden.

Welches Verzweigungsmodell ist angemessen?

Ich war in der Situation, in der Sie sich gerade befinden. Solche Systeme können ein wirklicher Schmerz sein, aber Sie müssen die pragmatischen Gründe, aus denen sie entstanden sind, verstehen und erkennen, dass sie nicht jenseits der Erlösung liegen . Es wurden viele Tools entwickelt, mit denen diese Komplexität bewältigt werden kann .

Was auch immer Sie tun, zeigen Sie den Leuten nicht das erfolgreiche Git-Verzweigungsmodell , es wird sie nur verwirren und ausschalten. Stattdessen entwickeln Sie Ihr eigenes Modell , das die bestehenden Arbeitsabläufe widerspiegelt , noch löst die Probleme mit Ihrem bestehenden Workflow .

Zu den Ressourcen, die Sie in Betracht ziehen sollten, gehören beispielsweise Git- Submodule, mit denen verschiedene Kundenversionen unterschiedliche Kombinationen von Kundenkonfigurationen, Anwendungsmodulen und Bibliotheken angeben können. Eine weitere Option wäre die Verwendung eines Patch-Management-Systems zum Anwenden von kundenspezifischen / produktspezifischen Patch-Warteschlangen.

Beide Optionen bieten eine viel größere Flexibilität, Transparenz und Sicherheit als Ihr aktueller Workflow und sind möglicherweise einfacher zu verwenden als eine noch komplexere Strategie nur für Zweige. Ich wünschte, ich hätte Zugriff auf diese Tools, als ich in Ihrer Situation war.

Weitere Informationen zu diesen Optionen finden Sie unter Meine Antworten zur Strategie zur Verwendung der Versionskontrolle auf einem modularen System . So verwenden Sie das Subversion-Repository in Git Repository? und Quell- / Versionskontrolle für Anwendungen, die von mehreren Unternehmen verwendet werden .

Letztendlich ist dies wirklich etwas, das Sie mit dem Rest des Teams entwickeln müssen. Wenn Sie die Vision haben, etwas vorzuschlagen, das besser funktioniert als das, was Sie bereits haben, und das Buy-in Ihrer Mitentwickler erhalten können, werden Sie es viel einfacher haben.

Das Wichtigste ist, Ihren Kollegen zu zeigen, wie das, was Sie vorschlagen , ihnen das Leben erleichtert . Sobald sie überzeugt sind, haben Sie eine viel bessere Chance, dass das Management ihre Investition in TFS verwirft und ein Modell einsetzt, das besser zu Ihren Arbeitsmethoden passt.

Erstens ist DVCS ein roter Faden für die Probleme, die Sie haben - das verwendete Tool zur Versionskontrolle ist nicht die Wurzel der Probleme, die gelöst werden müssen. Es kann sein, dass es Aspekte von DVCS-Lösungen gibt, die "besser" sind als TFS, aber es ist nicht das, was an dieser Stelle behoben werden muss.

Sie haben festgestellt, dass Sie eine funktionsfähige Verzweigungsstruktur benötigen, die zu Ihrer Organisation passt. Ich denke, Sie werden feststellen, dass Sie immer noch einen Trunk haben. Wenn eine Funktion abgeschlossen ist, wird sie wieder mit dem Trunk zusammengeführt und geschlossen. Es gibt auch einige nette Gedanken darüber, wie Sie allgemeine Abhängigkeiten implementieren.

Sie müssen auch die kontinuierliche Integration zum Laufen bringen (kein Grund, nicht für jeden aktiven Zweig einen automatischen Build zu haben, um Ihnen die Gewissheit zu geben, dass Sie diesen Zweig erstellen können und die relevanten Tests bestehen). Ich fühle mich unwohl, wenn ein Commit (oder zumindest ein "Push") keinen Build für mich auslöst.

Und Sie müssen mit automatisierten Tests auf allen Ebenen beginnen, insbesondere aber mit Komponententests und Integrationstests, um die Wahrscheinlichkeit zu verringern, dass neue Fehler in die Wildnis gelangen. Letzteres ist riesig und etwas, mit dem ich immer noch zu kämpfen habe, aber es ist klar, dass es den größten Wert hat, wenn man einmal weiß, dass man Dinge bauen kann.

Sie müssen dies kombinieren, um sicherzustellen, dass Ihre Bereitstellungspakete von Ihrem Build-Server stammen und dass die Bereitstellung so weit wie möglich automatisiert ist (Sie sollten in der Lage sein, mit minimalem Aufwand und minimalem Stress vom Build-Server-Artefakt zum live bereitgestellten Code überzugehen).

Hmm, ich bin davon ausgegangen, dass es ein gut geordnetes Setup für die Fehlerverfolgung gibt ... Sie brauchen das auch, um sicher zu sein, dass es ordnungsgemäß verwendet wird. Idealerweise möchten Sie, dass Ihre Live-Anwendungen Fehler automatisch an dieses System (oder zur Triage) zurückmelden.

Versuchen Sie nicht, alle Ihre Probleme auf einmal zu lösen - Build und Test scheinen mir die Orte zu sein, auf die Sie sich zuerst konzentrieren sollten.

Die zweite Frage ist einfacher und kürzer, also werde ich versuchen, sie zu beantworten

DVCS ist ein System, in dem keine "maßgebliche" Codequelle (außer "nach Vereinbarung", sofern verwendet) und kein P2P-Datenaustausch ohne zusätzliche Ebenen möglich ist (persönliche, nicht kanonische Definition).

Zum Thema die erste Frage

Ich fürchte, das Unternehmen muss den Workflow rekonstruieren und den Stil überdenken, um "irgendwie verwalteten und vorhersehbaren Code" zu erhalten. Ich kann nicht über TFS sagen (außer persönlicher Meinung und Gefühl, dass es ein schwaches System im Version Control-Teil ist / das Zusammenführen ohne Grundlage ist böse /), aber für jedes VCS in Ihrer Situation ("Produkt" setzt sich aus unabhängigen "Modulen" zusammen). Jeder "Kunde" bekommt andere "Produkte" - ist diese Annahme richtig?) Ich bevorzuge die getrennte Entwicklung von Modulen in getrennte Zweige, habe Produkt als "Supermodul" (auch Zweig?), da jedes Modul an eine bestimmte Überarbeitung von Modulen gebunden ist. branch, module-development verwendet das branch-per-task-Paradigma (und module-branch bestehen nur aus mergesets).

Auf diese Weise können Sie immer wissen, welche "Sammlung" (dh Satz von Modulen und deren entsprechende Überarbeitungen) jedes "Produkt" bildet, und haben die Möglichkeit, CI (für fertige und zusammengeführte Aufgabenzweige), Komponententests und Builds durchzuführen

Ad Hauptfrage: Ich glaube, worüber Sie sprechen, ist genau das, worum es bei dem erfolgreichen Verzweigungsmodell von Git (und dem Hilfswerkzeug Git Flow , um es zu unterstützen) geht. Verfügen Sie über einen Master-Zweig, der immer einsatzbereit ist, und bearbeiten Sie alle Feature-Zweige.

Sie können auch das von git selbst verwendete Verfahren anwenden, das vom gleichen Grundprinzip abgeleitet ist. In der Git-Core-Entwicklung werden alle Arbeiten an Feature-Zweigen ausgeführt. Die Feature-Zweige werden an den Integrator gesendet, der ein Skript ausführt, um alle zu einem Zweig mit dem Namen zusammenzuführen pu(vorgeschlagene Aktualisierungen). Verschiedene Leute nehmen diesen Zweig und arbeiten damit, um ihn zu testen.

Anstelle von Integrator kann Continuous Integration Server diese Zusammenführung zu Beginn eines Builds durchführen. Auf diese Weise können Sie festlegen, welche Zweige ausgewählt werden sollen, wenn ein Teammitglied Änderungen als Feature-Zweig in das zentrale Repository überträgt.

In git dem Funktionszweig als weiter zu next, masteroder maintje nachdem , welche loslassen es Targeting an (maint ist für Bugfixing aktuelle Release - Master für Strom in Vorbereitung Release und als nächste für eine danach), aber Sie werden nicht so viele haben.

Während die Funktionen in pu("Kochen" in der Terminologie des Git-Betreuers) enthalten sind, werden sie zurückgespult und der puZweig wird jedes Mal verworfen und neu erstellt. Dies erleichtert die Überprüfung, ist jedoch ungeeignet, um sich auf andere Arbeiten zu stützen. Wenn der Feature-Zweig in einer der Hauptzeilen zusammengeführt wird, wird er für das Zurückspulen geschlossen und weitere Korrekturen werden als neue Commits ausgeführt.

Ich persönlich würde es am gitbesten empfehlen . Anfangs ist es etwas schwieriger zu lernen, weil es organisch wächst, aber am Ende scheint es am flexibelsten zu sein. Aber jedes der drei verteilten Systeme, Git, Quecksilber und Basar, wird Ihnen gute Dienste leisten (und Sie können sie oft sogar mischen, z. B. kann Quecksilber zum / vom Git-Repository ziehen und schieben, und ich glaube, kann Basar).

Zweite Frage: Mir wurde beigebracht, dass "verteilt" im Allgemeinen bedeutet, dass Sie Objekte bewegen können und sie ihre Identität behalten. Genau das macht die verteilte Versionskontrolle: Sie klonen das Repository und es enthält die gleichen Commits und ermöglicht es, mit ihnen die gleichen Dinge zu tun. Die Einfachheit der Verzweigung und der getrennte Betrieb sind die Hauptmerkmale auf Benutzerebene, die sich aus dem Prinzip des Verschiebens von Commits und dem gerichteten Diagrammlayout ergeben, das dies ermöglicht.

Leider gibt es keine bekannte Lösung für Fehler im Code :)

Sie möchten also nur verhindern, dass nicht abgeschlossene Checkins in der Hauptversion erfasst werden, und die einzige Antwort darauf ist Branch-Work-Merge für jeden Entwickler. Ich habe dies in einer früheren Firma mit Clearcase gemacht, es hat ziemlich gut funktioniert (obwohl wir ein Dutzend Clearcase-Administratoren haben mussten).

Nun gehe ich auch davon aus, dass Sie Fehlerbehebungen an der Version des Produkts durchführen, die jeder Kunde derzeit hat. Sie haben also ein Zusammenführungsproblem, das Fehlerbehebungen von Version A bis zu Version Z bringt. Es gibt keine einfache Möglichkeit, damit umzugehen Sie müssen jedoch für jede ausgelieferte Version einen Zweig haben. Der beste Weg, um damit umzugehen, besteht darin, Feature-Zweige nur auf der neuesten Version zu belassen und Kunden dazu zu bringen, ein Upgrade durchzuführen, um die neuen Funktionen zu erhalten, und gleichzeitig Bugfixes direkt auf dem Release-Zweig durchzuführen und sie aufwärts mit allen anderen Release-Zweigen zusammenzuführen wenn fertig.

Nicht allzu schön, aber es kann bemerkenswert gut funktionieren. Sie halten den Code gut organisiert und getrennt. Es ist auch für die anderen Entwickler leicht zu verstehen - kleine Fehlerbehebungen direkt im "Code", mehr als ein paar Zeilen werden in einem dedizierten Zweig erledigt, wo sie so lange brauchen können, wie sie möchten, um es fertig zu stellen. (Sie müssen die Zusammenführungsprobleme lösen und ihnen versichern, dass es in Ordnung ist, wenn 2 Entwickler gleichzeitig an 2 Funktionen arbeiten !!)

Nach einer Weile können Sie Feature-Zweige auch in den Release-Zweigen einführen, in denen Fehler behoben und dann zusammengeführt werden. Dies ist jedoch in der Regel aufwändiger als erforderlich. Wenn Sie jedoch ältere Releases um Funktionen erweitern möchten, müssen Sie diesen Ansatz befolgen: Verzweigen Sie in einen Release-Zweig, fügen Sie den Code wieder in dieses Release ein und führen Sie die Änderung auch für die späteren Releases nach oben zusammen. Das wird Ihr Testteam sehr unglücklich machen, da die Veröffentlichung stark verzögert wird, da mehrere Versionen wiederholt getestet werden müssen, und das Entwicklerteam unglücklich sein wird, da sie eine Menge zusammenführen müssen, bevor sie mit neuem Code beginnen können (in meiner aktuellen Firma) Dies geschieht hauptsächlich aufgrund des Arbeitsaufwands, der immer so schnell wie möglich erledigt werden muss.

DVCS:

Grundsätzlich ist ein DVCS, bei dem jeder seine eigene Kopie des Server-Repos hat. Es hat einige Vorteile (insbesondere in verteilten Teams mit begrenzter Kommunikation), aber auch einige Nachteile. Schauen Sie sich diese an, bevor Sie zu einem DVCS wechseln. Wenn Sie ein Windows-Shop sind, werden Sie wahrscheinlich feststellen, dass Mercurial das beste DVCS für Sie ist.