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

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.

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.

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.

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/

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).