Behebung eines Fehlers bei der Arbeit an einem anderen Teil der Codebasis

Das ist mir mindestens einmal passiert. Ich arbeite an einem Teil der Codebasis und finde einen kleinen Fehler in einem anderen Teil. Der Fehler hindert mich daran, das abzuschließen, was ich gerade versuche. Das Beheben des Fehlers kann so einfach wie das Ändern einer einzelnen Anweisung sein.

Was machst du in dieser Situation?

1. Beheben Sie den Fehler und übergeben Sie ihn zusammen mit Ihrer aktuellen Arbeit
2. Speichern Sie Ihre aktuelle Arbeit an einem anderen Ort, beheben Sie den Fehler in einem separaten Commit und setzen Sie Ihre Arbeit fort [1]
3. Setzen Sie fort, was Sie tun sollen, und geben Sie den Code ein (auch wenn dies der Fall ist) bricht den Build ab Einige Tests scheitern), dann den Fehler beheben (und der Build Tests bestehen lassen) in einem separaten Commit

[1] In der Praxis würde dies bedeuten: Klonen Sie das ursprüngliche Repository an einer anderen Stelle, beheben Sie den Fehler, übertragen Sie die Änderungen, übertragen Sie sie auf das Repository, an dem Sie arbeiten, führen Sie die Änderungen zusammen und setzen Sie Ihre Arbeit fort.

Bearbeiten: Ich habe Nummer drei geändert, um zu reflektieren, was ich wirklich gemeint habe.

Ich habe 1 und 2 gemacht und am Ende denke ich, ich bevorzuge # 2. Es bietet mehr Transparenz für die Fehlerbehebung, die für die Qualitätssicherung / Versionshinweise / andere Entwickler wichtig sein kann.

Ich bin auch auf eine Situation gestoßen, in der das, was ich für einen Fehler hielt, nicht der Fall war (nicht zu sagen, dass dies hier der Fall ist), und das "Reparieren" in einem separaten Commit ermöglichte es einem anderen Entwickler, mich zu kontaktieren und zu erklären, was was war Anstelle des "Fixes" verliere ich mich beim normalen Einchecken.

Ich gehe in der Regel für # 2. Dadurch wird das Repository übersichtlicher und die Protokolle verständlicher. Ich hasse es, wenn andere Entwickler, mit denen ich arbeite, 15 verschiedene Fehlerbehebungen, Features und Refactorings in einem Commit durchführen.

Abhängig davon, wie Ihr Team die Fehlerverfolgung durchführt, müssen Sie möglicherweise das Fehler-Repository durchsuchen, um sicherzustellen, dass Sie den Artikel als vollständig markieren, wenn der von Ihnen behobene Fehler vorhanden ist. Oder Sie müssen möglicherweise ein neues Element erstellen und es als vollständig markieren, damit das defekte System und das Code-Repository übereinstimmen.

Ich mache # 2. Mit Tools wie git ist es trivial, es in mehrere Commits aufzuteilen. Wenn Sie Ihr Team nicht davon überzeugen können, auf modernere Tools umzusteigen, bietet Ihnen git-svn einen angemessenen Teil dessen, was Sie zur Lösung dieses Problems verwenden würden. Dieser Blog-Beitrag gibt einen guten Überblick über den Workflow, den Sie lösen möchten: The Thing About Git

Ich wähle die ungeschriebene Option (4): Teilen Sie Ihr Projekt in hochspezialisierte Assemblys / Bibliotheken auf, sodass sich nicht verwandte Fehler immer an einer anderen Stelle in der Versionskontrollstruktur befinden.

Ich entschuldige mich, wenn die oben genannten snarky klingt, aber ich meine es aufrichtig. Ich zucke zusammen, wenn ich ein monolithisches Projekt mit hundert Formularen und Namespaces sehe, die überhaupt nichts miteinander zu tun haben. Früher war ich oft mit demselben Dilemma konfrontiert und fragte mich, ob und wie ich Verpflichtungen auflösen sollte, die sich mit verschiedenen Funktionsbereichen befassten. Erst viel später wurde mir klar, dass all diese unterschiedlichen Funktionsbereiche in einem einzigen verbindlichen Projekt für sich genommen ein großer Konstruktionsfehler war.

Ich finde immer noch häufig völlig unabhängige Fehler, während ich an einer bestimmten Funktion arbeite. Ich arbeite möglicherweise an der Benutzeroberfläche, finde einen Fehler in einer Geschäftslogik und muss ihn beheben, bevor ich weitermachen kann. Der Unterschied besteht darin, dass sich die Geschäftslogik immer in einer anderen Baugruppe / einem anderen Projekt als der Benutzeroberfläche befindet. Alles, was ich tun muss, ist, eine geringfügige Änderung an der BL vorzunehmen und mit einer geringfügigen Festschreibung fortzufahren und dann weiterzuarbeiten.

Eine wirklich gute Projektorganisation macht es nicht nur möglich, sondern auch ganz einfach, diese Probleme zu lösen, ohne eine Änderung zu vergraben, den Build zu brechen oder sich in einem irritierenden Zweig / Zusammenschluss zu verfangen (selbst wenn Sie ein DVCS verwenden, ist dies nicht ganz schmerzlos ).

Wenn Ihnen diese Option fehlt - dh Sie sind ein Junior-Entwickler ohne Mitspracherecht in der Projektorganisation -, würde ich einfach mit der Nummer 1 fortfahren und entsprechende Notizen im Protokoll machen, damit andere Leute wissen, warum Sie das getan haben, was Sie getan haben. Wenn Sie eine wesentliche Änderung vorgenommen haben, legen Sie auch einen Fehlerbericht in Ihrem Fehlerverfolgungssystem ab, um einen Einblick in das zu erhalten, was Sie behoben haben und warum.

Ich versuche # 2 zu machen. Wenn es sich wirklich um ein separates Problem handelt, ist die Wahrscheinlichkeit groß, dass es sich um eine Datei handelt, die sich von der von Ihnen bearbeiteten Datei unterscheidet. Sie sollten in der Lage sein, die Datei als separates Commit einzuchecken, auch wenn sie in demselben Repository erstellt wurde, an dem Sie gerade arbeiten. Aus allen bereits genannten Gründen ist es nur sinnvoll, Commits so unabhängig wie möglich zu haben, um die Änderung nachzuverfolgen und rückgängig zu machen, wenn sie falsch ist.

Normalerweise behebe ich den Fehler einfach und setze dann meine Arbeit fort. Wenn es Zeit für ein Commit ist, unter der Annahme, dass sich die Fehlerbehebung in einer separaten Datei befindet, führe ich zwei gleichzeitige Commits durch - das erste ist ein partielles Commit, das nur die Fehlerbehebung enthält, und das zweite ist alles andere.

Kurze Antwort: # 2. Sie möchten wirklich, dass dieser Bugfix (mit seinem Hinweis in Ihrem Tracker!) In Ihrem Versionsverlauf als separate Entität markiert wird.

Längere Antwort:

• Über den Bug stolpern
• Schreiben Sie einen oder mehrere Tests, um den Fehler zu demonstrieren
• Machen Sie den Testdurchlauf
• Übernehmen Sie nur diese Änderung und ihre Tests ( git add --interactiveoder darcs record -iwie auch immer Ihr VCS dies tut) (*)
• Komm zurück zu dem, was ich tat.

(*) In CVS (nein, wirklich) habe ich manchmal einen sauberen Baum ausgecheckt sowie eine Kopie, an der ich arbeite. Dann benutze ich eine Zusammenführung - in meinem Fall winmerge - um nur den Bugfix in den sauberen Baum zu ziehen, damit ich ihn separat festschreiben kann. (Die andere Option besteht darin, die geänderten Dateien umzubenennen cvs updateund zusammenzuführen. Wenn Sie die Änderung übernommen haben, entfernen Sie die Datei und benennen Sie die verschobenen Dateien wieder in ihre ursprünglichen Namen um.)

Zu beachten ist jedoch, dass ich normalerweise nur Fehler finde, die entweder mit dem zusammenhängen, an dem ich arbeite, oder die sich in enger lexikalischer Nähe befinden. Ich wäre überrascht, wenn es normal wäre, dass Leute Fehler in nicht verwandten Teilen der Codebasis finden. Warum lesen Sie nicht verwandten Code, wenn Sie den Fehler beheben? (Ja, das ist genau das Gegenteil von dem, was Aaronnaught sagt!)

Ich behebe den Fehler und führe separate Commits durch , eines für jedes Fix / Feature.

In den meisten Fällen befinden sich die Änderungen nicht in derselben Datei, sodass es einfach ist, die Commits zu trennen. Wenn sich die Änderungen in derselben Datei befinden, verwende ich TortoiseHg (ein mecurial GUI-Frontend), um genau die Unterschiede auszuwählen, die ich festschreiben möchte (ich denke, dass dies in der Befehlszeile mit der Erweiterung Record möglich ist , aber es ist weniger praktisch ).

Einige Benutzer verwenden die Mercurial-Warteschlangen , um die kleineren Korrekturen zu isolieren, während sie an einer Funktion arbeiten. Die kleineren Fixes werden im MQ gestapelt. Wenn die Funktion abgeschlossen und festgeschrieben ist, wird auch der Inhalt der Warteschlange festgeschrieben (ein Änderungssatz für jeden Eintrag in der Warteschlange).

Normalerweise mache ich # 2. Speichern meiner aktuellen Arbeit an einem anderen Ort: Dies funktioniert normalerweise einwandfrei, indem ein Patch erstellt wird. Einige IDEs (IntelliJ) ermöglichen auch das Zurückstellen von Änderungen, und zwar genau so: Speichern Sie die aktuelle Arbeit an einem anderen Ort.

Was ich tue, hängt davon ab, ob sich der Fehler wirklich in einem anderen Bereich befindet. Wenn dies der Fall ist, ist das Einchecken unabhängig von meinen halb durchgeführten Änderungen. Ich nehme die Änderung vor, erstelle diesen anderen Teil, um sicherzugehen, dass ich keinen unbedeutenden Fehler gemacht habe, teste ihn (möglicherweise indem ich alles tue, was mich davon abgehalten hat) und überprüfe ihn, indem ich erkläre, was passiert ist. Oft erstelle ich ein Arbeitselement dafür und weise das WI nach dem Einchecken / Auflösen einem Tester zu. Dann gehe ich zurück zu dem, was ich tat.

Wenn die Dateien, die ich zur Hälfte geändert habe, nur mühsam bearbeitet werden, kann ich diesen Teil nicht unabhängig erstellen und testen. In diesem Fall mache ich eine andere WI dafür und wenn ich meine Änderungen einchecke, löse ich beide WIs mit dem gleichen Einchecken, was normalerweise gegen meine Prinzipien verstößt, aber in diesem Fall gut zutrifft.

In beiden Fällen wird der Bugfix von mir getestet, mit einer Spur eingecheckt, damit die Leute verstehen, warum ich diesen Code an diesem Tag nach dem Zufallsprinzip geändert habe, und einer anderen Person wird ein WI zugewiesen, um zu bestätigen, dass er jetzt korrekt ist.

Wir machen # 1. Nr. 2 hört sich gut an, aber ich kann nicht sagen, dass wir Probleme mit Nr. 1 hatten, die Nr. 2 beheben würde.

Ein weiterer Faktor in meinem Unternehmen ist, dass wir Web-Apps erstellen und das Testen fast ausschließlich über die Web-Oberfläche erfolgt - was die Leute eher als Funktionstests als als Komponententests bezeichnen. Wir haben alle Tests bestanden, bevor wir eingecheckt haben. Das Aufteilen von Commits in kleinere Bits würde bedeuten, dass die Tests für jedes Bit einmal ausgeführt werden, und das würde mehr Zeit in Anspruch nehmen. Ich hätte gerne eine viel schnellere Testsuite, mit der wir kleinere Aufgaben erledigen könnten, aber wir haben sie einfach nicht.