Wie umgestalten, wenn alle Ihre Entwicklung auf Filialen ist?

In meinem Unternehmen erfolgt die gesamte Entwicklung (Fehlerkorrekturen und neue Funktionen) in separaten Filialen. Wenn es fertig ist, senden wir es an die Qualitätssicherung, die es auf diesem Zweig testet, und wenn sie uns grünes Licht geben, verschmelzen wir es mit unserem Hauptzweig. Dies kann zwischen einem Tag und einem Jahr dauern.

Wenn wir versuchen, ein Refactoring in eine Zweigstelle zu drücken, wissen wir nicht, wie lange es "aus" sein wird, sodass es zu vielen Konflikten kommen kann, wenn es wieder in eine Zweigstelle eingefügt wird.

Nehmen wir zum Beispiel an, ich möchte eine Funktion umbenennen, weil die Funktion, an der ich arbeite, stark von dieser Funktion Gebrauch macht, und ich habe festgestellt, dass ihr Name nicht wirklich zu ihrem Zweck passt (auch dies ist nur ein Beispiel). Also gehe ich herum und finde jede Verwendung dieser Funktion und benenne sie alle in ihren neuen Namen um, und alles funktioniert einwandfrei, also sende ich es an die Qualitätssicherung.

In der Zwischenzeit ist eine neue Entwicklung im Gange, und meine umbenannte Funktion existiert in keinem der Zweige, die vom Hauptzweig abgezweigt werden. Wenn meine Ausgabe wieder zusammengeführt wird, brechen sie alle zusammen.

Gibt es eine Möglichkeit, damit umzugehen?

Es ist nicht so, dass das Management jemals ein Refactor-Only-Problem genehmigen wird, daher muss es mit anderen Arbeiten zusammengedrückt werden. Es kann nicht direkt auf main entwickelt werden, da alle Änderungen die Qualitätssicherung durchlaufen müssen und niemand der Trottel sein möchte, der die main unterbrochen hat, damit er ein wenig überflüssiges Refactoring durchführen kann.

Es gibt verschiedene Probleme, die sich vermischen und das Refactoring in dieser Umgebung zu einer Herausforderung machen. Darin gemischt sind einige nicht-technische Probleme ("aber das ist ein Managementproblem und ein Kampf, den ich noch nicht gewonnen habe").

Das erste Problem ist der lang laufende Zweig. Diese Zweige haben Schwierigkeiten, Änderungen außerhalb der Sicht des Entwicklers zu verfolgen. Um das zu erwähnen:

• Wenn der Code vollständig ist, versuchen Sie es noch einmal (lassen Sie den Kundensupport ihn sich ansehen, wenn er dies wünscht), führen Sie ihn jedoch schnell in die Entwicklung ein, damit andere Änderungen, die davon abhängen, erkannt werden und Änderungen, die Konflikte verursachen, frühzeitig erkannt werden in dem Prozess.
• Wenn ein Brach während des Refactorings aus irgendeinem Grund eine lange Lebensdauer hat, ist es in der Regel eine gute Praxis, aus dem Stable in den Zweig einzugliedern, um Änderungen und Refactoring zu übernehmen. Dies minimiert häufig Konflikte und Überraschungen beim Zusammenführen vom Feature-Zweig in den stabilen Zweig.
• Alle Integrationstests müssen für Releases durchgeführt werden - nicht für Features . In dieser Umgebung können Funktionen vollständig in das System integriert sein oder nicht. Es ist zwar möglich, die Funktion isoliert auf Fehler zu überprüfen, es werden jedoch keine Probleme bei der Veröffentlichung festgestellt.
• Vom Zeitpunkt der Code-Vervollständigung bis zur Zusammenführung (nennen wir es Entwicklung - Verzweigung von Master / Stable / Release hat seine eigenen Probleme, die neuesten Entwicklungsänderungen nicht zu übernehmen) sollte nicht zu lang sein. Je länger Sie warten, desto mehr Wissen geht verloren und desto schwerer kann der Code in andere Codezeilen integriert werden.

Ein weiteres Problem, das sich in dieses Problem mischt, ist das, auf das ich mit den obigen Punkten angespielt habe, die sich im Laufe der Zeit ändernde Rolle der Branche. Es beginnt als Entwicklungszweig, in dem sich Entwickler engagieren, und wird dann zu einem Testbereich (welche Tests werden hier durchgeführt, die für die gesamte Anwendung von Bedeutung sein können?), Der dann zu Stable zusammengeführt (und vermutlich veröffentlicht wird - oder?) Wird erneut getestet?).

Mit einer kürzeren Start-zu-Ende-Zeit des Features ist es für das Refactoring einfacher, von anderen Filialen abgeholt zu werden.

Ermutigen Sie Entwickler, die gesamte Umgebung zu nutzen. Nur das Auswählen von Änderungen kann zu ... sagen wir interessanten Entwicklerumgebungen führen. Während das Kirschpflücken seine Verwendung hat, kann es beunruhigend sein, Änderungen in einen Zweig zu ziehen.

Refactoring wird im Idealfall ständig durchgeführt, oder, wenn nicht immer, immer dann, wenn es zu einem gewissen Grad an Ausfallzeiten kommt. Verzweigen Sie, führen Sie ein einfaches Refactoring durch, führen Sie die Unit-Tests durch, um sicherzustellen, dass alles noch funktioniert (die Unit wurde getestet, richtig? Richtig? ), Und führen Sie sie dann wieder zu Stable zusammen. Geben Sie die Informationen an andere Entwickler weiter, um die von Ihnen überarbeiteten Änderungen in ihre eigenen Zweige zu übernehmen.

Für Entwickler ist es wichtig, die Qualität des Codes zu besitzen. Während die Richtung der Features von außen kommt und die Zeitzuweisungen oft nicht unsere eigene sind, ist Codequalität etwas, auf das man stolz sein und sich Zeit nehmen muss.

Bei der Suche nach Zeit für den Umgang mit technischen Schulden können die folgenden Fragen hilfreich sein:

• Soll die technische Verschuldung als ein Feature oder eine Aufgabe (oder ein Bug) geplant werden?
• Wie kann ich das Management vom Umgang mit technischen Schulden überzeugen?
  • Schauen Sie sich auch die damit verknüpften Fragen an - sie werden oft in anderen Fragen zitiert, die für das Lesen von Nutzen sein können.

Möglicherweise möchten Sie sich auch Tools wie Sonar ansehen, mit denen Sie die Bereiche des Codes identifizieren können, die für das Refactoring die meiste Arbeit erfordern. Das Plugin für technische Schulden kann verwendet werden, um auf die Ansammlung von Schulden im Laufe der Zeit in der Codebasis hinzuweisen.

Oft muss darauf hingewiesen werden, dass der ROI für den Umgang mit technischen Schulden eine schnellere Bearbeitungszeit für Features und Fehlerbehebungen des Entwicklungsteams darstellt.

Normalerweise entwickle ich eine überarbeitete Version "parallel" zur aktuellen, dh in derselben Codebasis, ohne sie jedoch aus der Kernanwendung zu referenzieren. Und wenn eine neue Lösung fertig ist und getestet wurde, beginne ich mit dem eigentlichen Refactoring.

Beispiel 1. Angenommen, ich habe Thing, sei es entweder Funktion, Schnittstelle, Modul oder was auch immer. Und ich möchte es umgestalten. Ich erstelle Thing2 in derselben Codebasis, es ist eine überarbeitete Version von Thing. Wenn es fertig ist und getestet wurde, überarbeite ich alles, was auf Thing verweist, um es durch Thing2 zu ersetzen. Normalerweise dauert dieser Schritt relativ wenig Zeit.

Wenn das eigentliche Refactoring zu lange dauert, um ohne Verschraubungsteam synchron zu bleiben, nehme ich alle relevanten Features und refactore sie auch parallel.

Beispiel 2. Ich habe ein neues Rendering-Backend, dh eine überarbeitete Version des alten. Es ist jedoch nicht mit dem alten Rendering-Frontend kompatibel. Daher muss ich das Frontend überarbeiten. Und nochmal: in derselben Codebasis. Wenn alles erledigt ist, ändere ich nur die Klasse der Frontend-Instanz. Idealerweise dauert es einen kurzen Commit.

Ja, rekursiv kann man zu dem Schluss kommen, dass alles parallel erfolgen muss. Dies geschieht jedoch normalerweise, wenn die Codebasis zu stark gekoppelt ist oder sich zu schnell ändert.

Wenn neuer Code integriert ist und ordnungsgemäß funktioniert, können alte Features aus der Codebasis entfernt und neue Features umbenannt werden, um alte Namen zu erhalten.

Im Allgemeinen sollten neue Funktionen parallel vorbereitet und schrittweise verwendet werden.

John Carmack verwendet diesen (oder zumindest ähnlichen) Ansatz, vielleicht erklärt sein Blog-Post es besser: (Link)

Auf der technischen Seite mag es schwierig erscheinen, wenn es tatsächlich auf der Anforderungsseite liegt.

Wo sich die Entwicklung an unterschiedlichen Anforderungen in unterschiedlichen Branchen orientiert, ist die eigentliche Schwierigkeit. Die Manager und Architekten des Teams sollten Entscheidungen treffen, die die Koexistenz der verschiedenen Geschäftsanforderungen ermöglichen.

Der ZBB-Prozess und Co-Dev gehen "Kompromisse" ein, wenn sie nach dem Treffen der richtigen Entscheidungen mit relevanten Eingaben von allen Entwicklern gemacht werden. Dann sollten Afterwords Ihnen ermöglichen, das zu implementieren, was Sie brauchen, ohne darüber nachdenken zu müssen - wie werde ich meinen Code zusammenführen.

_{ZBB steht für Zero-based Budgeting . Mit Co-Dev meine ich wenige Leute, die parallel programmieren.}

Das Problem scheint mir, dass Sie zu lange an Zweigen arbeiten. Die Kosten für Konflikte steigen exponentiell mit der Dauer, in der sich jeder in einem Zweig aufhält. Bei sehr langen Konflikten haben Sie daher nur geringe Chancen, ein Refactoring durchzuführen.

Ihr Problem ist das Zweigmodell, das Sie verwenden. Sie können sich auf einem Zweig entwickeln, und wenn der Zweig vollständig und für die Qualitätssicherung bereit ist, wird er zu einem Zwischenstamm zusammengeführt, der manchmal als Integration oder Test bezeichnet wird. Wenn Sie das nächste Feature entwickeln, können Sie stattdessen von diesem Zwischenstamm abzweigen.

Mit diesem Modell können Sie mehrere Features in verschiedenen Zweigen parallel entwickeln, sie alle in dem Integrationszweig zusammenführen, um sie an die Qualitätssicherung zu senden. Außerdem können Sie einen einzelnen Stamm von Releases verwalten (Sie führen die erhaltene Qualitätssicherung der Codebasis zum Hauptstamm zusammen, wenn sie ihn zertifizieren) )

Sie gehen davon aus, dass Ihre an QA gelieferten Änderungen ohne größere Änderungen übernommen werden. Wenn der QA-Code Anweisungen zum Entfernen der Hälfte der Änderungen enthält, müssen Sie den Vorgang rückgängig machen. Andernfalls wird er ausgeführt Ihre Entwicklung verläuft viel reibungsloser. Im Grunde genommen nehmen Sie Zweige für neue Funktionen von dem, was Ihr Hauptcode sein wird (dh Trunk nach dem Zusammenführen in Code, der an QA übergeben wird), anstatt von dem, was er heute ist (dh aktueller Trunk) und entwickeln sich daher nicht mehr gegenüber der Codebasis der vorherigen Version .