Wie oft müssen Änderungen an der Quellcodeverwaltung vorgenommen werden? [geschlossen]

Wie oft sollte ich Änderungen an der Quellcodeverwaltung vornehmen? Nach jedem kleinen Feature oder nur für große Features?

Ich arbeite an einem Projekt und muss eine langfristige Funktion implementieren. Derzeit verpflichte ich mich nach jedem Teil der Arbeit, dh nach jeder implementierten und behobenen Unterfunktion. Ich verpflichte mich sogar, nachdem ich einen neuen Testblock für eine Funktion hinzugefügt habe, nachdem ich einen Fehler entdeckt habe.

Ich bin jedoch besorgt über dieses Muster. An einem produktiven Arbeitstag könnte ich 10 Commits machen. Angesichts der Tatsache, dass ich Subversion verwende, wirken sich diese Commits auf das gesamte Repository aus. Ich frage mich also, ob es tatsächlich eine gute Praxis ist, so viele zu erstellen.

Jedes Mal, wenn ich einen "vollständigen Gedanken" an Code mache, der kompiliert und ausgeführt wird, checke ich ein. Dies dauert normalerweise zwischen 15 und 60 Minuten. Manchmal kann es länger dauern, aber ich versuche immer zu überprüfen, ob ich viele Codeänderungen habe, die ich im Falle eines Fehlers nicht neu schreiben möchte. Normalerweise stelle ich auch sicher, dass mein Code kompiliert wird und ich checke am Ende des Arbeitstages ein, bevor ich nach Hause gehe.

Ich würde mir keine Sorgen machen, "zu viele" Commits / Check-Ins zu machen. Es ist wirklich zum Kotzen, wenn Sie etwas neu schreiben müssen, und es ist schön, für alle Fälle in kleinen Schritten zurücksetzen zu können.

Wenn Sie sagen, dass Sie besorgt sind, dass Ihre "Commits das gesamte Repository betreffen" - beziehen Sie sich auf die Tatsache, dass die Revisionsnummer des gesamten Repositorys zunimmt? Ich weiß nicht, wie viele Bits Subversion zum Speichern verwendet, aber ich bin mir ziemlich sicher, dass Ihnen nicht die Revisionsnummern ausgehen werden! Viele Commits sind kein Problem. Sie können zehnmal so oft wie der Nachbar begehen, und Sie werden Ihren CO2-Fußabdruck überhaupt nicht erhöhen.

Eine einzelne Funktion oder Methode sollte nach ihrer Funktion benannt werden. Wenn der Name zu lang ist, führt sie zu viel aus. Ich versuche, die gleiche Regel auf Check-Ins anzuwenden: Der Check-In-Kommentar sollte genau beschreiben, was die Änderung bewirkt, und wenn der Kommentar zu lang ist, ändere ich wahrscheinlich zu viel auf einmal.

Ich mag diesen kleinen Artikel von Jeff Atwood: Früh einchecken, oft einchecken

Ich persönlich begebe jede logische Gruppe von Code, die fertig / stabil / kompiliert ist, und versuche, den Tag nicht zu verlassen, ohne festzuschreiben, was ich an diesem Tag getan habe.

Wenn Sie größere Änderungen vornehmen und Bedenken haben, andere zu beeinflussen, die am Code arbeiten, können Sie einen neuen Zweig erstellen und nach Abschluss Ihrer Änderungen wieder in den Trunk einbinden.

Ich verpflichte mich jedes Mal, wenn ich mit einer Aufgabe fertig bin. Das dauert normalerweise 30 Minuten bis 1 Stunde.

Wenn Ihr Versionskontrollkommentar länger als ein oder zwei Sätze ist, legen Sie wahrscheinlich nicht oft genug fest.

Ich folge dem Open-Source-Mantra (umschrieben) - begehen Sie früh, begehen Sie oft.

Grundsätzlich, wenn ich denke, dass ich nützliche Funktionen hinzugefügt habe (wie klein sie auch sein mögen), ohne anderen Teammitgliedern Probleme zu bereiten.

Diese Commit-Oft-Strategie ist besonders in Umgebungen mit kontinuierlicher Integration nützlich, da sie Integrationstests gegen andere Entwicklungsbemühungen ermöglicht und Probleme frühzeitig erkennt.

Übertragen Sie keinen Code, der nicht wirklich funktioniert. Verwenden Sie Ihr Repository nicht als Sicherungslösung.

Sichern Sie stattdessen Ihren unvollständigen Code automatisch lokal. Time Machine kümmert sich um mich und es gibt viele kostenlose Programme für andere Plattformen.

Die Faustregel, die ich verwende, ist das Einchecken, wenn die Gruppe der Dateien, die eingecheckt werden, durch einen einzelnen Eincheckkommentar abgedeckt werden kann.

Dies dient im Allgemeinen dazu, sicherzustellen, dass Check-Ins atomar sind und dass die Kommentare von anderen Entwicklern leicht verdaut werden können.

Dies gilt insbesondere dann, wenn sich Ihre Änderungen auf eine Konfigurationsdatei (z. B. eine Spring-Kontextdatei oder eine Struts-Konfigurationsdatei) auswirken, die einen anwendungsweiten Bereich hat. Wenn Sie vor dem Einchecken mehrere 'Gruppen' von Änderungen vornehmen, überschneiden sich deren Auswirkungen in der Konfigurationsdatei, wodurch die beiden Gruppen miteinander verschmolzen werden.

Ich denke nicht, dass Sie sich so viele Sorgen machen sollten, wie oft. Wichtig ist hier, was, wann und warum. Zu sagen, dass Sie alle 3 Stunden oder alle 24 Stunden eine Verpflichtung eingehen müssen, macht wirklich keinen Sinn. Festschreiben, wenn Sie etwas festschreiben müssen, nicht, wenn Sie dies nicht tun.

Hier ist ein Auszug aus meinen empfohlenen Best Practices für die Versionskontrolle :

[...] Wenn Sie viele Änderungen gleichzeitig an einem Projekt vornehmen, teilen Sie diese in logische Teile auf und übernehmen Sie sie in mehreren Sitzungen. Dies macht es viel einfacher, den Verlauf einzelner Änderungen zu verfolgen, was Ihnen viel Zeit spart, wenn Sie später versuchen, Fehler zu finden und zu beheben. Wenn Sie beispielsweise Feature A, B und C implementieren und Fehler 1, 2 und 3 beheben, sollte dies zu insgesamt mindestens sechs Commits führen, eines für jedes Feature und eines für jeden Fehler. Wenn Sie an einem großen Feature arbeiten oder ein umfangreiches Refactoring durchführen, sollten Sie Ihre Arbeit in noch kleinere Teile aufteilen und nach Abschluss jedes Teils ein Commit durchführen. Wenn Sie unabhängige Änderungen an mehreren logischen Modulen implementieren, schreiben Sie Änderungen für jedes Modul separat fest, auch wenn sie Teil einer größeren Änderung sind.

Im Idealfall sollten Sie Ihr Büro niemals mit nicht festgeschriebenen Änderungen auf Ihrer Festplatte verlassen. Wenn Sie an Projekten arbeiten, bei denen Änderungen Auswirkungen auf andere Personen haben, sollten Sie einen Zweig verwenden, um Ihre Änderungen zu implementieren und sie nach Abschluss wieder in den Trunk einzufügen. Stellen Sie beim Festschreiben von Änderungen an Bibliotheken oder Projekten, von denen andere Projekte - und damit auch andere Personen - abhängig sind, sicher, dass Sie deren Builds nicht durch Festschreiben von Code beschädigen, der nicht kompiliert werden kann. Code, der nicht kompiliert werden kann, ist jedoch keine Entschuldigung, um ein Festschreiben zu vermeiden. Verwenden Sie stattdessen Zweige. [...]

Ihr aktuelles Muster macht Sinn. Denken Sie daran , wie Sie nutzen diese Quelle Kontrolle: Was ist, wenn Sie Rollbacks haben, oder wenn Sie wollen ein Diff tun? Die von Ihnen beschriebenen Chunks scheinen in diesen Fällen genau das richtige Differential zu sein: Der Diff zeigt Ihnen genau, was sich bei der Implementierung von Bug # (im Checkin-Protokoll angegeben) geändert hat oder was genau der neue Code für die Implementierung einer Funktion war. Der Rollback berührt in ähnlicher Weise jeweils nur eine Sache.

Ich verpflichte mich auch gerne, nachdem ich einen Teil meiner Arbeit beendet habe, der oft mehrmals am Tag stattfindet. Ich denke, es ist einfacher zu sehen, was bei kleinen Commits passiert als bei großen. Wenn Sie sich über zu viele Commits Sorgen machen, können Sie einen Zweig erstellen und ihn wieder mit dem Trunk zusammenführen, wenn die gesamte Funktion abgeschlossen ist.

Hier ist ein verwandter Blog-Beitrag: Coding Horror: Früh einchecken, oft einchecken

Versuchen Sie, wie andere angegeben haben, einen logischen Block festzuschreiben, der "vollständig" genug ist, dass er anderen Entwicklern nicht im Weg steht (z. B. werden automatisierte Tests erstellt und bestanden).

Jedes Entwicklerteam / Unternehmen muss definieren, was für jede Niederlassung "vollständig genug" ist. Beispielsweise können Sie Feature-Zweige haben, für deren Erstellung nur der Code erforderlich ist, einen Trunk, für den auch Code zum Bestehen automatisierter Tests erforderlich ist, und Beschriftungen, die angeben, dass etwas die Qualitätssicherungstests bestanden hat ... oder ähnliches.

Ich sage nicht, dass dies ein gutes Muster ist; Ich möchte nur darauf hinweisen, dass die Vorgehensweise von den Richtlinien Ihres Teams / Unternehmens abhängt.

In dem Moment, in dem du darüber nachdenkst.

(solange das, was Sie einchecken, sicher ist)

Hängt von Ihrem Quellcodesystem und dem ab, was Sie sonst noch haben. Wenn Sie Git verwenden, legen Sie fest, wann immer Sie einen Schritt beenden. Ich verwende SVN und möchte mich verpflichten, wenn ich eine ganze Funktion abgeschlossen habe, also alle ein bis fünf Stunden. Wenn ich CVS verwenden würde, würde ich dasselbe tun.

Ich stimme mehreren Antworten zu: Checken Sie keinen Code ein, der nicht kompiliert werden kann. Verwenden Sie einen persönlichen Zweig oder ein Repository, wenn Ihr Unternehmen eine "Sicherung" des Codes oder seiner Änderungen hat. Checken Sie ein, wenn die logischen Einheiten vollständig sind.

Eine andere Sache, die ich hinzufügen möchte, ist, dass je nach Ihrer Umgebung die Check-in-Rate mit der Zeit variieren kann. Zum Beispiel ist ein frühes Einchecken in ein Projekt, nachdem jedes Funktionselement einer Komponente abgeschlossen ist, sowohl für die Sicherheit als auch für den Revisionsverlauf sinnvoll (ich denke an Fälle, in denen frühere Bits überarbeitet werden, während spätere entwickelt werden). Andererseits wird später im Projekt eine vollständig vollständige Funktionalität wichtiger, insbesondere während der Integrationsentwicklung / -prüfung. Eine halbe Integration oder eine halbe Korrektur hilft niemandem.

Was das Einchecken nach jeder Fehlerbehebung betrifft: Es sei denn, die Korrektur ist trivial, absolut! Nichts ist schmerzhafter, als festzustellen, dass ein Check-in drei Korrekturen enthielt und eine davon zurückgesetzt werden muss. Meistens scheint es, dass der Entwickler in dieser Situation drei Fehler in einem Bereich behoben hat und das Abwickeln, welche Änderung zu welcher Fehlerbehebung führt, ein Albtraum ist.

Ich checke auch gerne regelmäßig ein. Das ist jedes Mal, wenn ich einen Schritt in Richtung meines Ziels vollendet habe.

Dies ist normalerweise alle paar Stunden .

Meine Schwierigkeit besteht darin, jemanden zu finden, der bereit und in der Lage ist , so viele Codeüberprüfungen durchzuführen .

Unsere Unternehmensrichtlinie lautet, dass wir eine Codeüberprüfung durchführen müssen, bevor wir etwas einchecken können. Dies ist sinnvoll, aber es gibt nicht immer jemanden in der Abteilung, der Zeit hat, sofort eine Codeüberprüfung durchzuführen. Mögliche Lösungen:

1. Mehr Arbeit pro Check-in; weniger Checkins == weniger Bewertungen.
2. Ändern Sie die Richtlinie zum Einchecken des Unternehmens. Wenn ich gerade ein Refactoring durchgeführt habe und die Unit-Tests alle grün laufen, kann ich vielleicht die Regel lockern?
3. Bewahren Sie die Änderung auf, bis jemand die Überprüfung durchführen und weiterarbeiten kann. Dies kann problematisch sein, wenn der Prüfer Ihren Code nicht mag und Sie ihn neu gestalten müssen. Das Jonglieren verschiedener Phasen einer Aufgabe durch "Zurückstellen" von Änderungen kann chaotisch werden.

Ich möchte Änderungen alle 30-60 Minuten vornehmen, solange sie sauber kompiliert werden und es keine Regressionen bei Komponententests gibt.

Nun, Sie könnten einen eigenen Zweig haben, für den Sie sich so oft engagieren können, wie Sie möchten, und wenn Sie mit Ihrer Funktion fertig sind, können Sie sie mit dem Haupt-Trunk zusammenführen.

In Bezug auf die Häufigkeit von Commits sehe ich das so, wie viel Schmerz es für mich wäre, wenn meine Festplatte abstürzen würde und ich nichts begangen hätte - das Quantum davon ist für mich ungefähr 2 Stunden Arbeit.

Natürlich begebe ich nie etwas, das nicht kompiliert werden kann.

Mindestens einmal am Tag.

Ich habe kein bestimmtes Zeitlimit pro Commit. Ich neige dazu, Commits durchzuführen, sobald ein Test bestanden wurde, und ich bin mit dem Code zufrieden. Ich würde keinen Code festschreiben, der nicht kompiliert wird oder sich auf andere Weise in einem Zustand befindet, zu dem ich im Falle eines Fehlers nicht gerne zurückkehren würde

Sie müssen den Kompromiss zwischen Sicherheit und Wiederherstellbarkeit einerseits und einfachem Änderungsmanagement für das gesamte Projekt andererseits in Einklang bringen.

Das beste Schema, das ich verwendet habe, hatte zwei Antworten auf diese Frage.

Wir haben zwei völlig separate Repositorys verwendet: eines war das projektweite Repository und das andere war unser eigenes persönliches Repository (wir haben zu diesem Zeitpunkt rcs verwendet).

Wir haben sehr regelmäßig in unser persönliches Repository eingecheckt, fast jedes Mal, wenn Sie Ihre geöffneten Dateien gespeichert haben. Als solches war das persönliche Repository im Grunde ein großer, weitreichender Rückgängig-Puffer.

Sobald wir einen Codeabschnitt hatten, der kompiliert, in Ordnung getestet und als für den allgemeinen Gebrauch bereit akzeptiert wurde, wurde er in das Projekt-Repository eingecheckt.

Leider war dieses System auf die Verwendung verschiedener VCS-Technologien angewiesen, um funktionsfähig zu sein. Ich habe keine zufriedenstellende Methode gefunden, um dieselben Ergebnisse zu erzielen, wenn zwei VCS desselben Typs verwendet werden (z. B. zwei Subversion-Repositorys).

Ich habe jedoch akzeptable Ergebnisse erzielt, indem ich "persönliche" Entwicklungszweige in einem Subversion-Repository erstellt habe - regelmäßig in den Zweig eingecheckt und nach Abschluss in den Trunk zusammengeführt.

Wenn Sie an einem Zweig arbeiten, der nicht freigegeben wird, ist ein Commit immer sicher.

Wenn Sie es jedoch mit anderen Entwicklern teilen, ist das Festschreiben von nicht funktionierendem Code wahrscheinlich etwas ärgerlich (insbesondere, wenn es sich an einem wichtigen Ort befindet). Normalerweise schreibe ich nur Code fest, der effektiv "funktioniert" - nicht, dass er vollständig getestet wurde, sondern dass ich festgestellt habe, dass er tatsächlich kompiliert wird und nicht sofort fehlschlägt.

Wenn Sie einen integrierten Bug-Tracker verwenden, kann es hilfreich sein, separate Commits durchzuführen, wenn Sie zwei Fehler behoben haben, damit das Commit-Protokoll die richtigen Fehler beheben kann. Andererseits behebt manchmal eine Codeänderung zwei Fehler, sodass Sie nur auswählen müssen, gegen welchen Sie sie stellen möchten (es sei denn, Ihr System lässt zu, dass ein Commit mehreren Fehlern zugeordnet wird).

Ich glaube immer noch an den Satz "oft begehen, früh begehen". Ich bevorzuge dezentrales VCS wie Mercurial, und es ist kein Problem, mehrere Dinge festzuschreiben und später nach oben zu bringen.

Dies ist wirklich eine häufig gestellte Frage, aber die eigentliche Frage lautet: Können Sie unfertigen Code festschreiben?

Wann immer Sie einen Code fertigstellen, der funktioniert und niemanden vermasselt, wenn er ihn in einem Update erhält.

Und bitte stellen Sie sicher, dass Sie richtig kommentieren.