Was soll ich tun, wenn ich zwischen den Commits bereits zu lange gewartet habe?

Ich war ungezogen ... Zu viel "Cowboy-Codierung", zu wenig Commitment. Jetzt bin ich hier mit einem enormen Engagement. Ja, ich hätte mich die ganze Zeit verpflichten sollen, aber jetzt ist es zu spät.

Was ist besser?

1. Führen Sie eine sehr große Festschreibung durch, in der alle Dinge aufgelistet sind, die ich geändert habe
2. Versuchen Sie, es in kleinere Commits zu unterteilen, die sich wahrscheinlich nicht kompilieren lassen, da Dateien mehrere Korrekturen, Änderungen, zusätzliche Methodennamen usw. aufweisen.
3. Versuchen Sie, Dateien nur für entsprechende Festschreibungen teilweise umzukehren, und setzen Sie dann die neuen Änderungen zurück.

Hinweis: Ab sofort bin ich der einzige Programmierer, der an diesem Projekt arbeitet. Die einzige Person, die sich diese Commit-Kommentare ansieht, bin ich, zumindest bis wir mehr Programmierer einstellen.

Übrigens: Ich benutze SVN und Subclipse. Ich habe einen neuen Zweig erstellt, bevor ich diese Änderungen vorgenommen habe.

Weitere Informationen : Ich habe eine separate Frage gestellt, die sich darauf bezieht, wie ich überhaupt in diese Situation geraten bin: Wie bereite ich mich auf das Umschreiben des Klebstoffs einer Anwendung vor?

Um zu antworten, müssen Sie sich fragen, wie Sie die Ergebnisse dieser Commits in Zukunft nutzen wollen. Die häufigsten Gründe sind:

• Um zu sehen, welche Version ein Fehler eingeführt wurde.
• Um zu sehen, warum eine bestimmte Codezeile vorhanden ist.
• In einem anderen Zweig zusammenführen.
• Um in der Lage zu sein, eine frühere Version für die Fehlerbehebung eines Problems auszuchecken, wird dies einem Kunden oder Tester in dieser Version angezeigt.
• In der Lage sein, bestimmte Teile von einer Freigabe einzuschließen oder auszuschließen.

Die ersten beiden Gründe lassen sich mit einem großen Check-in genauso gut erklären, vorausgesetzt, Sie können eine Check-in-Nachricht erstellen, die für jede Zeile mit geändertem Code gleichermaßen gilt. Wenn Sie der einzige Programmierer sind, werden kleinere Commits Ihre Zusammenführung nicht einfacher machen. Wenn Sie nicht vorhaben, eine Veröffentlichung oder einen Test mit nur einem Teil Ihrer nicht übermittelten Änderungen durchzuführen, gelten die letzten beiden Gründe nicht.

Es gibt andere Gründe, kleine Commits zu machen, aber diese Gründe sind gegeben, während Sie sich mitten in den Veränderungen befinden und diese Zeit vorbei ist. Diese Gründe machen es einfacher, einen Fehler oder eine experimentelle Änderung zu korrigieren und mit Kollegen synchron zu bleiben, ohne dass es zu großen Zusammenführungen kommt.

Nach meinem Verständnis Ihrer Situation, wie Sie sie beschrieben haben, scheint es wenig oder gar keinen Nutzen zu haben, Ihr Commit zu diesem Zeitpunkt aufzuteilen.

Ich denke, was auch immer Sie tun, versuchen Sie zu vermeiden, Code einzuchecken, von dem Sie wissen, dass er nicht kompiliert werden kann.

Wenn Sie der Meinung sind, dass Ihre dritte Option durchführbar ist, ist dies möglicherweise eine gute Möglichkeit, sofern Sie sicherstellen können, dass Ihre Folge von Festschreibungen kein nicht kompilierbares System erzeugt. Ansonsten machen Sie einfach das eine große Commit. Es ist hässlich, aber es ist einfach, schnell und erledigt es. Gehen Sie vorwärts, legen Sie öfter fest .

Der wichtigste Grund für häufige, kleine und aussagekräftige Commits ist das Verständnis der Geschichte des Codes. Insbesondere ist es sehr schwer zu verstehen, wie sich Code verändert hat, wenn es schwierig ist, verständliche Unterschiede zu generieren.

Option 1 verschleiert den Verlauf der von Ihnen vorgenommenen Änderungen, führt jedoch ansonsten nicht zu Problemen.

Option 2 verschleiert den Verlauf der von Ihnen vorgenommenen Änderungen, möglicherweise etwas weniger als Option 1, kann jedoch andere Probleme für Sie oder andere verursachen, wenn sie annehmen oder auf andere Weise den Schluss ziehen, dass die Commits unterschiedlich sind, z. B. unabhängig voneinander in anderen Zweigen zusammengeführt werden können. Dies ist weniger ideal, es sei denn, es gibt einen starken praktischen Grund, warum dies Option 1 vorgezogen wird.

Option 3 ist am besten, da alle anderen Faktoren gleich sind. Wenn dies jedoch, wie Sie an anderer Stelle beschrieben haben, "extrem" viel Zeit in Anspruch nehmen oder andere erhebliche Kosten verursachen würde, müssen Sie diese Kosten mit den erwarteten Vorteilen von abwägen sauberere Commits erstellen.

Anhand der von Ihnen angegebenen Informationen würde ich mich für Option 1 entscheiden. Vielleicht sollten Sie Erinnerungen einrichten, die Sie auffordern, Ihre Änderungen zu übernehmen?

Prototyping und Umschreiben

Eine weitere Überlegung, die Sie berücksichtigen sollten, insbesondere angesichts Ihres Hinweises, dass Sie der einzige Programmierer sind, und meiner Vermutung, dass Sie an einer relativ neuen Codebasis arbeiten, ist, dass es wahrscheinlich gut ist, unterschiedliche Gewohnheiten zu entwickeln, um Änderungen für Sie vorzunehmen Prototyping von neuem Code statt Beibehalten oder Erweitern von vorhandenem Code. Es gibt wahrscheinlich keine besonders scharfe Trennung zwischen den beiden, aber ich denke, es ist immer noch eine nützliche Unterscheidung.

Wenn Sie einen neuen Code als Prototyp erstellen, müssen Sie die Änderungen immer dann festschreiben, wenn Sie sie speichern möchten, mit ziemlicher Sicherheit in einem Zweig, aber möglicherweise in einem separaten Projekt. Oder vielleicht sogar nur außerhalb der Versionskontrolle arbeiten. Sie können sich stattdessen darauf konzentrieren, Beweise für die Machbarkeit verschiedener Hypothesen oder Entwürfe zu sammeln, die Sie in Betracht ziehen. Ich schreibe oft kleine Prototypen mit verschiedenen Tools, z. B. LINQPad anstelle von Visual Studio für C # -Code.

Wenn Sie eine bestimmte Hypothese oder ein bestimmtes Design validiert haben, schreiben Sie es in Ihrem Hauptprojekt um, idealerweise in einem Zweig, und treffen Sie die kleinen, aussagekräftigen Festlegungen, die das Verständnis anderer (einschließlich Ihrer zukünftigen) in Bezug auf die Art der Änderungen am besten unterstützen du machst.

Obwohl die einzig vernünftige Antwort darin besteht, niemals den Kofferraum zu knacken , ist dies manchmal nicht möglich. Zum Beispiel kann svn das Festschreiben unterbrechen, wenn Sie zu viel festschreiben (möglicherweise eine Option oder eine Funktion, bei der ich mir nicht sicher bin). In solchen besonderen Fällen einfach in Stücken einchecken. Da Sie ein einzelner Programmierer sind, wird es niemanden stören.

Daher würde ich Option 1 wählen. Wenn dies nicht möglich ist, Option 2.

Option 3 erfordert viel Aufwand und ist es einfach nicht wert.

Versuchen Sie, es in kleinere Commits zu unterteilen, die sich wahrscheinlich nicht kompilieren lassen, da Dateien mehrere Korrekturen, Änderungen, zusätzliche Methodennamen usw. aufweisen.

Wenn ich mich in einer ähnlichen Situation befunden habe, habe ich die folgende Technik angewendet:

1. Fügen Sie nur den Code hinzu, der für eine bestimmte Funktion relevant ist: git add --patch
2. Verstecken Sie alle anderen Änderungen: git stash save --keep-index
3. Führe Tests aus / versuche zu kompilieren
4. Änderungen festschreiben, wenn alles in Ordnung ist, wenn nicht mit 1 fortfahren

Ich bin nicht mit SVN vertraut, daher weiß ich nicht, ob dies auf Ihre spezielle Situation zutrifft, aber die Grundlage sollte dieselbe sein - isolieren Sie kleine Teile des Codes und testen Sie sie einzeln.

Wie wäre es mit Option 4: Sichern Sie den aktuellen Status Ihres Repos an einem temporären Ort, stellen Sie den ursprünglichen Status Ihres Repos wieder her, erstellen Sie eine Liste aller vorgenommenen Änderungen (Sie können sich die temporäre Sicherung weiterhin ansehen), und führen Sie dann eine manuelle Neuimplementierung durch (und kompilieren Sie sie und teste!) sie als separate Commits.

Dies sollte einfacher sein, da Sie den Code bereits geschrieben haben. Sie müssen lediglich herausfinden, welche Teile Sie aus Ihrer temporären Sicherung kopieren und einfügen müssen.

Wenn Sie jede Änderung sauber erneut implementiert haben und damit sichergestellt haben, dass die Commits in sich geschlossen, klein und kompiliert sind, können Sie die temporäre Sicherung löschen, und alles wird fast genau so sein (mit Ausnahme der Uhrzeit / des Datums der Commits) wäre es gewesen, wenn Sie es von Anfang an richtig gemacht hätten.

Du bist der einzige Programmierer; Machen Sie einfach einen einzigen massiven Check-in, in dem die wichtigen Teile Ihres Tuns aufgeführt sind.

Werden Sie wahrscheinlich "Teile" von dem zurücksetzen, was Sie getan haben? Wenn nicht, fahren Sie unbedingt mit Option 1 fort.

Es gibt mehrere Gründe, Code in ein Versionskontrollsystem einzuchecken. Und ALLE von ihnen, wenn Sie der einzige Entwickler sind, drehen sich um die Sicherheit - wenn Sie nämlich Fehler machen, die Maschine ausfällt oder was auch immer, können Sie immer zu diesem letzten Kontrollpunkt zurückkehren.

Es ist unwahrscheinlich, dass ein Programmierer, der später in das Projekt eintritt, auf eine Version zurücksetzen möchte, die nicht kompiliert werden kann. Also, meiner Meinung nach, Option 2 ist Wahnsinn.

Option 3 klingt nach einer solchen Zeitverschwendung, dass ich, wenn ich Ihr Chef wäre und Sie Stunden damit verschwenden sehen würde, ein kleines Gespräch mit Ihnen darüber führen würde, was Ihre Zeit wert ist.

Um zu iterieren: Indem Sie Ihren Code einchecken, werden Sie Ihren Hintern im Falle eines Fehlers auf Ihrem Computer abdecken / retten. Alles andere in einem Ein-Mann-Team ist Schaufensterdekoration.

Meine Regel lautet: Kein Einchecken ohne ernsthafte Codeüberprüfung. Wenn ich alleine bin, muss ich den Code selbst überprüfen , aber er wird überprüft. Sie scheinen eine Menge von Codeänderungen zu haben, die nicht von jemand anderem überprüft werden konnten, daher können Sie diese nicht selbst überprüfen (das Überprüfen Ihres eigenen Codes ist schwieriger und erfordert mehr Disziplin, da Sie automatisch die falsche Annahme treffen, dass Ihr eigener Code korrekt ist ).

Die absolut unzerbrechliche Regel aller lautet: Checken Sie niemals Code ein, der noch nicht einmal erstellt wurde, und vermeiden Sie ernsthaft das Einchecken von Code, der nicht funktioniert.

Lösung: Kopieren Sie den geänderten Code und kehren Sie zum ursprünglichen Punkt zurück. Führen Sie jeweils eine Änderung in den Originalcode ein, überprüfen Sie ihn, testen Sie ihn und checken Sie ihn ein. Mit der von Ihnen beschriebenen Programmiermethode werden Sie auf diese Weise sicher einige schwerwiegende Fehler finden.

Es ist auch eine gute Möglichkeit, sich in gute Programmiergewohnheiten einzuarbeiten.

Ich denke, Sie machen sich viel zu viele Sorgen. Wenn Sie der einzige Programmierer sind und kein Datenblatt haben, gegen das Sie arbeiten können, liegt es ganz bei Ihnen, was Sie tun. Ich gehe davon aus, dass Sie niemand dafür bestrafen wird, dass Sie eine große Festschreibung getätigt haben. Die einzigen Probleme, auf die Sie stoßen, sind technische Probleme, z. Da Sie in diesem Moment die alleinige Kontrolle über das Repo haben, sollte das auch kein großes Problem sein.

Es ist eine Grenze zwischen Pragmatismus und Dogmatismus zu ziehen. Was Sie getan haben, wäre keine gute Idee in einem Team und sollte in Zukunft wahrscheinlich nicht wiederholt werden, aber in Ihrer Situation würde ich nur das große Commit einreichen.

Das Problem liegt nicht in langen Verzögerungen zwischen Commits, sondern darin, dass Sie den Code zu lange im nicht kompilierbaren Zustand halten. Was ist Ihre Definition von "lang"? Für einige Leute sind 5 Minuten für den Übergangszustand zu viel, aber einige können ihren Code tagelang polieren, ohne überhaupt zu versuchen, den Compiler auszuführen.

Tatsächlich spielt es keine Rolle - wichtig ist, dass Sie die Kontrolle über Ihren Code verloren haben und Ihr Code nicht mehr verwaltet werden kann. Das ist normal, es bedeutet nur, dass Sie technologische Schulden haben und es Zeit ist, über das Refactoring nachzudenken. Sie sind also frustriert? Ihr Code lässt sich nicht kompilieren, Sie haben noch nicht einmal Unit-Tests? Wie können Sie in diesem Fall über ein Refactoring nachdenken? Keine Bange. Beenden Sie Ihre "Cowboy-Codierung" und beginnen Sie mit der Reinigung. Versuchen Sie im Idealfall, einige Tests zu schreiben. Sie haben keine Zeit dafür? Ok, fange mit kleinen Verbesserungen an.

Einige Änderungen erfordern keine Tests. Ändern Sie den Variablennamen, um ihn besser zu verwenden, verschieben Sie sich wiederholenden Code in eine separate Funktion usw. Sie erhalten eine bessere Vorstellung von Ihrem Code. Danach können Sie größere Änderungen vornehmen. Versuchen Sie nach Möglichkeit erneut, Tests zu schreiben. Machen Sie Ihren Code überschaubar.

Danach werden Sie feststellen, dass die nächste Änderung nicht "zu lange" dauert (was auch immer dies bedeutet).