Beenden von Entwicklern, die sich auf DVCS für den falschen Zweig entschieden haben

Das Problem

Ich arbeite an einem Software-Projekt mit ungefähr 10 Entwicklern. Wir teilen den Quellcode über Mercurial. Wir haben eine Entwicklungs- und Produktionsniederlassung pro Release. Im Verlauf des Projekts wurde wiederholt Quellcode aus einem Zweig (v1) in Patch- und Wartungszweige für frühere Softwareversionen (v2) verschoben.

Dies hat zur Folge, dass entweder die Zeit für das Zurücksetzen des falschen Commits aufgewendet wurde oder dass falscher (möglicherweise nicht von QAd stammender) Code in den falschen Zweig gelangt und dort bereitgestellt wird, wenn wir nicht feststellen, dass der Code in den falschen Zweig gelangt ist.

Unsere Branche und Merge Design / Methode

               v1-test   v1-patch1   v1-patch2
               ^---------^-----------^                v1-prod
              /         / \           \
-----------------------/   \           \              v1-dev
              \             \           \
               --------------------------\            v2-dev
                             \       \    \ 
                              ^-------^-------------  v2-prod
                              v2-test v2-patch1      

Daher werden wir an einem Release-Entwicklungszweig arbeiten, bis er als bereit erachtet wird. Verzweigen Sie ihn für einen einzelnen Test- / UAT- / Produktionszweig, in dem alle Releases und Wartungen durchgeführt werden. Tags werden verwendet, um Releases dieses Zweigs zu erstellen. Während v1 getestet wird, wurde eine Verzweigung für v2 erstellt, und die Entwickler werden mit der Arbeit an neuen Funktionen beginnen.

Was dazu neigt, ist, dass ein Entwickler aufgrund der Verzweigung von v2-dev zu v1-dev oder v1-prod Arbeit leistet, oder schlimmer noch, sie führen v2-dev zu v1-prod zusammen (oder ähnliche solche Fehler).

Wir raten den meisten Entwicklern, nicht auf die -prod- Zweige zuzugreifen , der Code schleicht sich jedoch immer noch ein. Eine Gruppe von erfahreneren Entwicklern kümmert sich um den -prod-Zweig.

Es sollte beachtet werden, dass v2 zwar gerade mit der Entwicklung begonnen hat, es jedoch noch einige ziemlich umfangreiche Patches in v1 geben kann, um Probleme zu beheben. Dh v1 bekommt vielleicht nicht nur den einen oder anderen kleinen Patch.

Was wir bisher versucht haben

• Mit einem separaten Zweig mit Gatekeepern. Ein -prod-Zweig sollte Warnungen über seinen Namen auslösen, und die meisten Entwickler müssen sich niemals in diesem Zweig befinden. Dies hat das Problem nicht wirklich verringert.
• Sensibilisierung der Entwickler für dieses Problem, um sie wachsamer zu machen. Auch dies war nicht sehr erfolgreich.

Mögliche Gründe, die ich für Entwickler sehe, die sich für den falschen Zweig entscheiden

• Zweigentwurf zu komplex
• Parallele aktive Entwicklung in mehreren Branchen. (Das Projekt zeigt Symptome der Verwendung des Lawinenmodells .)
• Entwickler verstehen das DVCS nicht gut genug

Fragen, die ich gelesen habe, waren etwas relevant

Ich habe diese Frage gelesen , weil ich mich nicht auf den falschen Zweig festgelegt habe, und ich bin der Meinung, dass die Antworten zu visuellen Hinweisen hilfreich sein können. Ich bin jedoch nicht ganz davon überzeugt, dass die Probleme, die wir haben, keine Symptome eines grundlegenderen Problems sind.

Mit den visuellen Hinweisen können wir sie problemlos in die Befehlszeile integrieren, jedoch verwendet etwa die Hälfte des Teams Eclipse. Ich bin nicht sicher, wie visuelle Hinweise eingefügt werden sollen.

Frage

Mit welchen Methoden, in Form von Software, Projektmanagement oder Governance, können wir die Anzahl der Commits für den falschen Zweig reduzieren (im Idealfall stoppen), was unsere Zeit in Anspruch nimmt oder unseren implementierten Code verschmutzt?

Ein spezieller Kommentar zu den Gründen, von denen ich glaube, dass sie dazu beitragen, wie oben dargelegt, wäre willkommen, aber dies sollte Ihre Antwort nicht einschränken.

Das Problem ist, dass Sie ändern, was die Bedeutung einer Verzweigung im Laufe des Prozesses ist.

Zunächst ist die v1 devBranche für die Entwicklung. Alle neuen Funktionen gehen dorthin. Irgendwann in der Zukunft wird es eine Wartungsfiliale für die v1 releaseFiliale. Das ist der Kern des Problems.

Es ist nicht so, dass die Entwickler schlampig sind, sondern dass die Berechtigungen und Rollen des Zweigs schlampig sind und sich ändern können.

Sie müssen lediglich festlegen, als welche Rolle die einzelnen Zweige fungieren, und diese Rolle beibehalten. Wenn sich die Rolle ändert, verzweigen Sie.

Beispielsweise:

 developer
  commits    |   |  |   |    |     |   |     |
             v   v  v   v    v     v   v     v
 dev  +--+---------------------+------------------->
         |           ^    ^    |           ^    ^
         |           |    |    |           |    |
 v1      +----+------+----+    |           |    |
           prod  patches       |           |    |
                               |           |    |
                               |           |    |
 v2                            +-----+-----+----+
                                  prod  patches

In diesem Modell verpflichten sich Entwickler immer zur Entwicklung. Wenn Sie einen Patch erstellen, checken Sie den Patch in den Zweig dieser Version ein (oder noch besser, verzweigen Sie den Zweig der Version für einen Patch und führen Sie ihn dann wieder in den Zweig der Version ein).

Ein Artikel, den Sie lesen sollten (und der wahrscheinlich eine Untertreibung für "sollte" ist), ist Advanced SCM Branching Strategies von Stephen Vance.

^{In diesem Artikel definiere ich zunächst die Verzweigung im allgemeinen Sinne. Ich diskutiere dann verschiedene Strategien für die Verzweigung, angefangen bei den offensichtlichen bis hin zu mehreren, die besser für größere Entwicklungsanstrengungen geeignet sind. Unterwegs diskutiere ich die Vor- und Nachteile jeder Strategie und benutze sie, um die Änderungen zu motivieren, aus denen sich die komplexeren Strategien zusammensetzen ...}

In diesem Artikel identifiziert er fünf Rollen, die Zweige haben können. Manchmal kann ein Zweig zwei Rollen ausfüllen, und Rollen erfordern nicht unbedingt einen neuen Zweig , solange sich die Rollenrichtlinien nicht im mittleren Zweig ändern (gelegentlich wird "Zweig bei inkompatibler Richtlinie" erwähnt).

Diese Rollen sind:

1. Hauptleitung. Hier werden Zweige hergestellt. Immer von der Hauptlinie abzweigen erleichtert das Zusammenführen, da die beiden Zweige einen gemeinsamen Vorfahren haben, der nicht Zweig für Zweig auf Zweig ist.
2. Entwicklung. Hier checken Entwickler Code ein. Möglicherweise gibt es mehrere Entwicklungszweige, um Änderungen mit hohem Risiko von routinemäßigen und alltäglichen zu isolieren.
3. Instandhaltung. Fehlerkorrekturen in einer vorhandenen Produktionsumgebung.
4. Akkumulation. Wenn Sie zwei Zweige zusammenführen, möchten Sie möglicherweise nicht riskieren, die Hauptleitung zu destabilisieren. Verzweigen Sie also die Hauptleitung, verbinden Sie die Zweige mit dem Akkumulator und verbinden Sie sie wieder mit der Hauptleitung, sobald die Dinge erledigt sind.
5. Verpackung. Das Verpacken einer Freigabe erfolgt in den Verpackungszweigen. Dies wird häufig zum Release und dient dazu, den Release-Aufwand von der Entwicklung zu isolieren. Siehe Wie gehe ich mit unerwünschten Commits um, die lang andauernde Release-Builds zum Erliegen bringen? Ein Beispiel dafür, wo die Verpackung im Widerspruch zur Entwicklung steht.

In Ihrem Beispiel haben Sie eine kaskadierende Hauptlinie (dies ist ein Problem - es erschwert das Zusammenführen - was passiert, wenn Sie einen Fix für v1 in v2 und v3 zusammenführen möchten?), Einen Entwicklungszweig, der zu einem Wartungszweig wird ( Änderung der Politik, das ist ein Problem).

Ok, Sie sagen, das ist großartig, aber dies wurde aus Versehen geschrieben, es handelt sich um ein zentrales VCS - ich verwende DVCS.

Schauen wir uns das Git-Flow-Modell an und sehen, wie es angewendet wird.

Der Master-Zweig (blau) ist der Freigabezweig - zum Markieren. Es ist nicht die Hauptlinie. Die Hauptlinie ist eigentlich der Entwicklungszweig (gelb). Die Freigabezweige (grün) sind die Verpackungsrolle. Die Entwicklung mit geringem Risiko erfolgt in der Hauptlinie, die Entwicklung mit hohem Risiko in den Feature-Zweigen (pink). In diesem Modell erfolgt die Akkumulation im Entwicklungszweig. Wartung gilt als "Hotfixes", die rot sind.

Die Rollenrichtlinien stimmen zwar nicht genau überein (jedes Produkt hat einen leicht unterschiedlichen Lebenszyklus), sie stimmen jedoch überein.

Dies sollte Ihre Verzweigungsrichtlinie vereinfachen und für alle Beteiligten einfacher machen.

Während Sie versucht haben, einen separaten -prod-Zweig mit Gatekeepern zu verwenden, hört es sich so an, als würde das eine Repository verwendet, um die eigentlichen Produktionsbuilds durchzuführen. Wenn die Produktions-Builds nur aus einem Produktions-Repository erstellt würden, das nur von seinem Gatekeeper beschrieben werden kann, könnten die Entwickler nicht darauf zugreifen. Dies belastet den Gatekeeper, der erst nach Überprüfung auf das Produktions-Repo drängen würde. Natürlich können die Leute bei Bedarf immer noch aus dem Produktions-Repo ziehen.

Wenn Menschen Erfahrung sammeln, sollten sie durch die Rolle des Gatekeepers gedreht werden, um das tiefere Verständnis oder die Sorge zu erlangen, die ihnen zu fehlen scheinen.

Und in der Regel wenden Sie Occam's Razor an: Die gesamte Repo-Struktur sollte so einfach wie möglich zu bedienen sein.

Siehe auch Seans Kommentar.

Es ist möglich, dass die Entwickler DVCS einfach nicht gut genug bekommen, aber ich denke, es ist viel wahrscheinlicher, dass Sie einfach zu viel los sind, und die Entwickler können nicht verfolgen, was sie von Moment zu Moment tun. Sie vergessen, in welcher Branche sie arbeiten sollen, und ihre Veränderungen landen am falschen Ort.

Ich würde vorschlagen, dass Sie ein Problem damit haben, dass alle in all diesen Branchen regelmäßig arbeiten.

Der Vorschlag von @ andy256, ein separates Repository für prod bereitzustellen, würde sicherlich helfen, aber Sie müssen möglicherweise überlegen, die Arbeit anders zu verteilen oder die Dinge so zu arrangieren, dass kein Entwickler in einer bestimmten Woche an mehr als einem Zweig arbeitet.

Anscheinend haben Sie einen meiner großen Käferbären identifiziert. Die meisten Tools zur Versionskontrolle sind genau diese Tools zur Versionskontrolle. Sie ermöglichen es einer Reihe von Entwicklern, am selben Quellverzeichnis zu arbeiten, Änderungen vorzunehmen und Konflikte zu behandeln. Es gab ein paar Ecken und Kanten auf dem Weg, aber CVS, Subversion, Git, Mercural usw. liefern alle dies.

Dann haben Sie den nächsten Schritt, bei dem Sie den Code für die Freigabe stabilisieren müssen, und Sie führen die Verzweigung ein. Hier versagen die Tools den Entwicklern. Die Tools sind in der Lage, die Verzweigung vorzunehmen und sogar die Änderungssätze zu identifizieren, die in den Verzweigungen nach der Verzweigung aufgetreten sind, aber das ist nicht das Problem, mit dem Sie jetzt konfrontiert sind.

Die Tools können nur schlecht auswählen, welche Änderungen in andere Zweige kopiert werden müssen und wann dies erforderlich ist. Git-flow versucht, dieses Problem zu lösen, indem eine Verzweigungsstrategie erstellt wird, bei der beim Zusammenführen von Verzweigungen ALLE Änderungen zusammengeführt werden. Anschließend muss der Programmierer mit Bedacht entscheiden, wann und welche Verzweigungen zusammengeführt werden.

Auf einem einzigen Repository, in dem alle Entwickler an einem Projekt mit einem einzigen Release-Thread arbeiten, löst git flow das Problem, aber für viele Unternehmen ist das Leben nicht so einfach.

In der komplexen Umgebung sind mehrere Teams für verschiedene Aspekte der Gesamtlösung verantwortlich und führen interne Releases für andere Teams durch. Git-Flow ist einfach nicht in der Lage, diese Art von Problem zu lösen.

Ich habe diese Arbeit nur gesehen, wenn jedes Team dafür verantwortlich ist, seine Releases zu definieren und zu steuern, wann sich seine Abhängigkeiten ändern. Nur weil Team A Version 1.3 veröffentlicht hat, verwendet Team B die Version 1.3 von Team A erst, wenn Team B dies wählt.

Tatsächlich definiert ein Entwicklerteam die zu verschiebenden Änderungsgruppen, und die Entwickler, die die Änderungen erhalten, definieren, wann sie die Änderungsgruppe erhalten.

Das einzige Tool für die Quellcodeverwaltung, von dem ich gesehen habe, dass es das wirklich liefert, ist Genauigkeit - und selbst dann werden die meisten Entwickler darüber meckern, weil die GUI für sie zu verwirrend ist und sich nicht wie Subversion verhält ...