Sollten Sie die Codequalität verbessern, während Sie an einem Feature-Zweig arbeiten?

11

Ich mag diesen Artikel über das Verlassen des Codes / Campingplatzes in einem schöneren Zustand als Sie ihn gefunden haben - es scheint ein praktischer Ansatz in der realen Welt zu sein, die Sauberkeit des Codes im Auge zu behalten.

Ich mag Feature-Zweige auch sehr , um Features isoliert zu entwickeln, sodass Sie sie leicht nicht zusammenführen können, wenn Sie sie nicht mögen.

Sollte ich das Problem beheben, wenn ich an einem Feature-Zweig arbeite und hässlichen Code finde?

Es fühlt sich so an, als ob es eine Reihe von Nachteilen gibt, um das Problem zu beheben:

  • Wenn ich den Zweig wieder zusammenführe, ist das Diff chaotisch, überfüllt mit variablen Umbenennungen oder Funktionsextraktionen
  • Wenn die Funktion abgebrochen wird, müssen Sie entweder das Bereinigungs-Commit auswählen (was möglicherweise funktioniert oder nicht, je nachdem, wie sich der Code in der Nähe geändert hat, wodurch eine unordentliche Zusammenführung erfolgt), es erneut ausführen oder es einfach abbrechen.

Auf der anderen Seite, wenn ich es nicht mache, während ich in der Datei bin, dann werde ich es natürlich in ein paar Tagen vergessen, wenn ich den Zweig zusammenführe.

Ich wurde gewarnt, dass dies meinungsbasiert war (ich denke nur, dass der Titel dies beinhaltet should), aber ich habe das Gefühl, dass es eine Antwort gibt (sicherlich verwenden die Leute beide Ansätze, also müssen sie eine Antwort haben). Auch Fragen zu development methodologiessind thematisch und ich denke, sie erfordern ein gewisses Maß an Meinung.

T. Kiley
quelle
@gnat Eine nützliche Lektüre, danke. Ich denke nicht, dass es ein ziemlicher Betrug ist, da es sich um Zweige handelt, die eine lange Bearbeitungszeit haben. Ich frage speziell, wie man den guten Camper-Ansatz für das Refactoring mit Feature Branch Dev in Einklang bringt.
T. Kiley
Dies hängt von der Entwicklungsphase des Projekts ab. Wenn das Projekt einer angemessenen Anzahl von Tests unterzogen wurde und vor Ort durchgeführt wird, ist es meines Erachtens sehr riskant, Änderungen vorzunehmen, die nicht Teil dessen sind, was repariert werden sollte. Viele Leute haben Fehler eingefügt, die Dinge ändern, die nichts hätten beeinflussen sollen. Wenn sich das Projekt in der Entwicklungsphase befindet, ist es umso besser, je sauberer der Code zu starten ist. Daher würde ich wahrscheinlich die gesamte Datei bei Bedarf bereinigen.
Dunk

Antworten:

8

Sie sollten Code in einem Feature-Zweig nur dann "reparieren", wenn Sie diesen Code ohnehin als Teil des Features ändern.

Z.B. Ich arbeite an der Funktion "Kaninchen drucken" und finde den Druckercode

Public class Printer(string type)
{
    If(type=="bunnies")
    {
        //print a bunny
    }
.....
}

Ich ändere es in:

Public class Printer(string type)
{
     PrintFunctionDictionary[type].Print();
}

Warum:

  • Ich arbeite am Code,
  • Ich muss es ändern, um Funktionalität hinzuzufügen,
  • Die hinzugefügte Funktionalität schlägt eine überarbeitete Methode zur Lösung des Problems vor.

Ich treffe nicht zufällig einen anderen Teil der Codebasis und mache es besser, als dies würde:

  • Kollision mit Leuten, die an anderen Funktionen arbeiten.
  • Verwenden Sie die Zeit, die für die Entwicklung der Funktion vorgesehen werden soll.
  • Fügen Sie einem Zweig beliebigen Code hinzu, der, wenn die Funktion nicht abgeschlossen ist, möglicherweise nicht mit dem Hauptprodukt zusammengeführt wird. Wenn ich die Funktion zurücksetze, verliere ich ebenfalls mein Refactoring.
Ewan
quelle
1
Ich stimme zu, dass dies eine gute Sache ist, und in einer idealen Welt würde dies immer funktionieren. Im Code der realen Welt sind die Situationen jedoch häufig komplexer. Wenn Sie an einem Feature arbeiten, können Sie normalerweise Teile des Codes finden, die es wert sein könnten, unabhängig vom Feature überarbeitet zu werden. Dieser Code kann die Implementierung des Features beeinträchtigen, ist jedoch nicht auf die Methoden oder Klassen beschränkt, die in direktem Zusammenhang mit dem Feature stehen. Und eine Veränderung stört andere nicht unbedingt.
Doc Brown
1
Nun, Sie können immer einen separaten Refactoring-Zweig durchführen. Aus meiner Sicht handelt es sich bei Feature-Zweigen hauptsächlich um eine Projektmanagement-Sache, mit der Sie fortfahren können: "Feature X wurde nicht fertiggestellt, aber wir können es mit allen anderen veröffentlichen" und "Feature X wird freigegeben", sodass wir nicht erwarten, dass sich Feature Y ändert. Indem Sie einem Feature Refactoring hinzufügen, brechen Sie möglicherweise diese Vorteile
Ewan
5

Wenn Sie möchten, dass Ihre Refactorings "unabhängig" von Ihrem aktuellen Feature-Zweig leben, nehmen Sie die Änderungen dort nicht vor. Führen Sie stattdessen das Refactoring im Hauptentwicklungszweig durch (oder einen "Refactoring-Zweig", wenn es in Ihrem Team üblich ist, Änderungen nicht direkt auf den Entwicklungszweig anzuwenden). So kann jeder in Ihrem Team (einschließlich Sie) die Änderungen in den aktiven Feature-Zweigen zusammenführen, an denen er arbeitet. Achten Sie jedoch darauf, keine globalen Refactorings in der gesamten "Hälfte der Codebasis" anzuwenden, ohne zuvor Ihre Kollegen um Erlaubnis zu bitten. Sie sind möglicherweise nicht so glücklich, wenn Ihre Refactorings ihre aktuelle Arbeit zu stark beeinträchtigen.

Die Ausnahme ist hier, wenn die von Ihnen vorgenommenen Verbesserungen lokal für die Teile der Codebasis sind, die Sie genau in diesem Feature-Zweig berühren, und es keinen Sinn macht, ihnen einen anderen Lebenszyklus als Ihrem "neuen Feature" zuzuweisen.

Doc Brown
quelle
3

Der Zweck von branchTypen besteht darin, die Absicht zu geben, mit ihnen umzugehen. Wenn Sie eine GitFlow Art der Verzweigung folgend sind, dann haben Sie wahrscheinlich Typen mögen feature, hotfix, release, etc .. Im Fall eines Zweiges, seine Absicht ist es, eine Zusammenführung in einer anderen Zweig zu verkapseln (dh develop) , dass zeigt den Entwickler verantwortlich für Zusammenführen, was diese Funktion ist. Wenn der Code, den Sie bereinigen, nicht Teil dieser Funktion ist, ändern Sie ihn nicht.

Suchen Sie stattdessen den niedrigstmöglichen Zweig, in dem sich der hässliche Code befindet (wahrscheinlich develop), und verzweigen Sie von dort aus. Ändern Sie den Code und schlagen Sie vor, ihn als Feature zusammenzuführen. Wenn Sie diesen Code für Ihre Arbeit benötigen und insbesondere Zusammenführungskonflikte vermeiden möchten, führen Sie diesen Zweig in IHREN Zweig ein.

Hier ist eine ziemlich gute Erklärung für verschiedene Strategien: https://www.atlassian.com/git/tutorials/comparing-workflows/

TomSchober
quelle
0

Wenn ich an einem Feature-Zweig arbeite und hässlichen Code finde, sollte ich ihn beheben?

Es ist wahrscheinlich in Ordnung, "hässlichen Code" auf Anhieb zu reparieren, abhängig vom Tempo des Projekts, der "Hässlichkeit" des Codes usw., aber versuchen Sie, dies nicht im Feature-Zweig selbst zu tun.

  • Wenn Ihr Feature-Zweig vollständig lokal ist, speichern oder speichern Sie einfach nicht gespeicherte Änderungen, überprüfen Sie den Entwicklungszweig, nehmen Sie die Änderung vor, kehren Sie dann zu Ihrem Feature-Zweig zurück und starten Sie die Entwicklung erneut.
  • Wenn Sie die Entwicklung nicht wiederherstellen können (z. B. wenn sich Ihr Feature-Zweig auf einem öffentlichen Server befindet), können Sie diese Festschreibungsentwicklung dennoch auswählen, wenn Sie sie benötigen oder später Konflikte vermeiden möchten.
  • Wenn Sie eine Datei bearbeiten und wirklich müssen jetzt das Update zu dem hässlichen Code begehen und wirklich nicht zu entwickeln wechseln, können Sie das Update machen, verwenden , git add -pum das Update zu machen, begeht diese Änderung nur , und bevor Sie fusionieren / Push (in der Tat, vorzugsweise nach Ihrem nächsten Commit), verwenden Sie die interaktive Rebase, um dieses Commit an den frühestmöglichen Punkt in Ihrer Branche zu verschieben, oder wählen Sie es je nach Verlauf möglicherweise sogar aus.

Ich würde dies auch mit allem anderen tun, das den Entwicklungszweig "repariert" (wobei "Korrekturen" Änderungen sind, die Sie oder ein anderer Entwickler möglicherweise sofort vornehmen, um sicherzustellen, dass der Code den Standards entspricht). Das hilft...

  • Damit Ihre Korrekturen und Ihre Funktion in verschiedenen Gruppen festgeschrieben werden, ist das Protokoll besser lesbar.
  • die Entwicklung so nah wie möglich an der jederzeitigen Freigabe zu halten und
  • um Doppelarbeit zu vermeiden (mehrere Personen beheben das gleiche Problem auf subtil unterschiedliche Weise in verschiedenen Branchen).
user52889
quelle