Ist das tägliche Festschreiben / Einchecken von Code eine gute Praxis?

Ich habe Martin Fowlers Notiz zu Continuous Integration gelesen und er nennt als ein Muss "Jeder verpflichtet sich jeden Tag zur Mainline".

Ich schreibe keinen Code ein, es sei denn, der Abschnitt, an dem ich arbeite, ist vollständig. In der Praxis schreibe ich meinen Code alle drei Tage ein: einen Tag, um die Aufgabe zu untersuchen / zu reproduzieren und einige vorläufige Änderungen vorzunehmen, einen zweiten Tag, um die Änderungen abzuschließen und einen dritten Tag, um die Tests zu schreiben und sie zur Einreichung aufzuräumen. Ich würde mich nicht wohl fühlen, wenn ich den Code früher einreichen würde.

Jetzt rufe ich Änderungen aus dem Repository ab und integriere sie in der Regel zweimal täglich vor Ort, aber das mache ich nur, wenn ich ein kleineres Stück Arbeit herausarbeiten kann.

Frage: Ist das tägliche Festschreiben eine so gute Praxis, dass ich meinen Workflow ändern sollte, um ihn anzupassen, oder ist es nicht so ratsam?

Edit: Ich denke, ich hätte klarstellen müssen, dass ich "Commit" im Sinne von CVS (auch "Push" genannt) meinte, da dies wahrscheinlich das war, was Fowler 2006 gemeint hätte, als er dies schrieb.

^ Die Reihenfolge ist willkürlicher und hängt von der Aufgabe ab. Ich wollte die Zeitspanne und die Aktivitäten veranschaulichen, nicht die genaue Reihenfolge.

Ich bin mit dieser Regel nicht einverstanden und stimme dem zu, was Mason Wheeler gesagt hat. Ich möchte ein paar Ideen hinzufügen.

Ich versuche jedes Mal, ein Commit durchzuführen, wenn ich eine wichtige Änderung vorgenommen habe: Dies kann mehrmals am Tag erfolgen, wenn ich mehrere kleine Fehler behebe, oder einmal pro Woche, wenn ich an einer größeren Software arbeite, die für den Rest von nicht verwendbar ist den Code in irgendeiner sinnvollen Weise, bis er einen konsistenten Zustand erreicht.

Ich interpretiere Commit als Veröffentlichung einer aussagekräftigen Revision , die der Codebasis neue Funktionen hinzufügt. Ich denke, man sollte versuchen, den Code vor dem Festschreiben zu bereinigen, damit andere Entwickler die Bedeutung und den Zweck der Änderung verstehen, wenn sie sich den Revisionsverlauf ansehen. Je weniger Änderungen andere Entwickler im Verlauf sehen, desto besser: Wenn ich mir den Versionsverlauf anschaue, möchte ich Inkremente sehen, die einige sinnvolle Funktionen hinzufügen. Ich bin nicht an jeder kleinen Idee interessiert, die jeder Entwickler hatte, und wollte sie ausprobieren, bevor sie zur Lösung gelangten.

Darüber hinaus halte ich es nicht für eine gute Idee, den SVN-Server (oder ein anderes Versionskontrollsystem) als Backup-Funktion zu verwenden, für die der aktuelle Snapshot des Codes festgeschrieben ist (vorausgesetzt, er wird kompiliert): Sie können einen USB-Stick verwenden oder ein externes USB-Laufwerk oder eine Netzwerkfestplatte, um Ihren aktuellen Code zu spiegeln, damit er nicht verloren geht, wenn Ihr Computer ausfällt. Revisionskontrolle und Datensicherung sind zwei verschiedene Dinge. Das Veröffentlichen einer Revision ist nicht dasselbe wie das Speichern eines Schnappschusses Ihres Codes.

Schließlich denke ich, dass es kein Problem sein sollte, von Zeit zu Zeit ein Commit durchzuführen (dh nur wenn man wirklich mit dem aktuellen Stand des Codes zufrieden ist) und Zusammenführungskonflikte zu vermeiden, ist keine gute Rechtfertigung für ein (zu häufiges) Commit. Viele Zusammenführungskonflikte treten auf, wenn verschiedene Personen zur gleichen Zeit an denselben Dateien arbeiten, was eine schlechte Praxis ist (siehe z. B. diesen Artikel , Punkt 7). Zusammenführungskonflikte sollten reduziert werden, indem ein Projekt in Module mit klaren Schnittstellen und so wenig Abhängigkeiten wie möglich aufgeteilt wird und die Arbeit der Entwickler so koordiniert wird, dass sich der Code, an dem sie arbeiten, so wenig wie möglich überlappt.

Nur meine 2 Cent.

BEARBEITEN

Ein weiterer Grund gegen vorzeitige Commits ist, dass eine (sehr) fehlerhafte Version nicht getestet werden kann. Wenn Sie einen Commit für den Trunk durchführen und Ihr Testteam jeden Tag Tests durchführt, ist möglicherweise für einige Stunden (oder einen Tag lang) keine testbare Version verfügbar. Selbst wenn Sie nicht versuchen, den Fehler zu beheben und nur Ihre Änderungen rückgängig zu machen, kann eine Neuerstellung einige Stunden dauern. Wenn beispielsweise fünf Tester in Ihrem Team arbeiten, haben Sie aufgrund von Inaktivität 5 x 2 = 10 Stunden der Teamzeit verschwendet. Es ist mir einmal passiert, also versuche ich wirklich, vorzeitige Commits im Namen von Commit so schnell wie möglich zu vermeiden .

Ich gebe mehrmals am Tag Code ein . Immer wenn ich einen Punkt erreiche, an dem der Code vollständig genug ist, um andere Dinge zu kompilieren und nicht zu beschädigen, geht er hinein.

Sie sollten Ihre Arbeit unterbrechen, damit Sie sicher ein paar Mal am Tag einchecken können .

Die Gründe dafür sind zwei:

1. Nicht eingecheckte Arbeiten können verloren gehen - Ihr Computer kann einen katastrophalen Fehler aufweisen. In diesem Fall verlieren Sie umso mehr Arbeit, je länger Sie warten.
2. Je mehr Arbeit Sie erledigen, ohne einzuchecken, desto mehr Code müssen andere integrieren, wenn Sie sich endgültig für das Backen entscheiden. Dies führt zu einer erhöhten Wahrscheinlichkeit von Konflikten und Zusammenführungsproblemen.

Es ist niemals eine gute Idee, sich sklavisch an eine Methodik oder Praxis zu halten, ohne die Gründe dafür zu verstehen. Das ist der Ursprung der Cargo-Kult-Programmierung.

Deshalb ist "Ich sollte mich jeden Tag verpflichten, weil Martin Fowler es gesagt hat" einfach nur dumm. Und manchmal ist es auch unpraktisch. Wenn Sie an einer komplizierten neuen Funktion arbeiten, lohnt sich das Einchecken möglicherweise erst, wenn Sie bereits einige Tage daran gearbeitet haben.

Dies bedeutet nicht, dass Sie sicherstellen sollten, dass alles perfekt ist, bevor Sie es einchecken. Dies ist eine gute Möglichkeit, Arbeit zu verlieren, wenn etwas schief geht. Das Richtige ist, ein gutes Urteilsvermögen zu entwickeln und anzuwenden. Faustregeln können Ihnen nur so viel helfen.

Oded gab zwei wichtige Gründe an, Code so häufig wie möglich zu schreiben. Ich werde noch ein paar hinzufügen:

1. Während Sie an Ihrem Code arbeiten, benötigen andere möglicherweise einige Funktionen für diesen Code. Sie sollten nicht 6 Tage warten, um es zu bekommen. In diesem Fall erstellen meine Kollegen normalerweise einen Prototyp in meinem Code, schreiben ihn fest, ich füge den Body hinzu und schreibe ihn erneut fest. Und das ist in der Regel in wenigen Stunden erledigt.

2. Der "gemeinsame" Code ist für alle da, um jede Änderung so schnell wie möglich zu sehen. Wenn der Code, an dem Sie arbeiten, völlig unabhängig von der Arbeit anderer ist und Sie nicht warten müssen, wird empfohlen, einen Zweig zu erstellen, an dem Sie arbeiten können. Wenn alles erfolgreich ist, führen Sie ihn zusammen die Hauptlinie.

Ich bin fest davon überzeugt, dass es sich lohnt, jede logische Änderung vorzunehmen, die es wert ist, beibehalten zu werden. Führen Sie häufig Commit-Vorgänge durch, und setzen Sie den Code in einen sauberen Zustand zurück, wenn er nicht aufbewahrt werden sollte. Je länger Sie warten, um Ihren Code zurückzusenden / zu veröffentlichen, desto schwieriger ist die Implementierung und desto mehr Probleme treten auf. Außerdem erhalten Sie viel schnelleres Feedback zu Ihren Beiträgen:

• brechen sie den Build?
• duplizieren Sie die Bemühungen eines anderen Teammitglieds?
• machst du etwas falsch
• oder warten Leute auf Dinge von dir?

Kleine Änderungen sind viel einfacher zu verwalten.

Beachten Sie auch den Unterschied zwischen verschiedenen Versionskontrollsystemen. Einige, wie z. B. Git (verteilt), ermöglichen es Ihnen, Ihren gesamten Verlauf lokal festzuschreiben und zu steuern, und nur dann zu pushen, wenn Sie bereit sind, ihn zu veröffentlichen. Andere, wie SVN (zentralisiert), kombinieren die beiden Schritte und machen kleine Commits sehr ineffizient.

Vergessen Sie nicht, dass es sich bei Ihren Commits im Wesentlichen um Änderungsdokumentationen handelt. Wenn etwas schief geht, werden Sie froh sein, mehr Geschichte zu haben als nicht genug. Ein einziges Engagement für eine Woche Arbeit erscheint mir nutzlos. Ich würde am Ende nur jede einzelne geänderte Codezeile lesen und nicht die Zusammenfassung jedes logischen Blocks.

Ich denke, die meisten Antworten hier verfehlen einen der Hauptpunkte in der Aussage von Martin Fowlers. Dies hängt mit der kontinuierlichen Integration zusammen . Code, der nicht in die Hauptzeile eingecheckt (gepusht / veröffentlicht / zusammengeführt) wurde, wird nicht getestet.

Dies sollte nicht als Aufforderung verstanden werden, den Code, den Sie auf Ihrem lokalen Computer haben, zu bestätigen, wenn es Zeit ist, das Büro zu verlassen. Wie von mehreren anderen hier hervorgehoben, wäre das schlecht, würde den Build brechen und eine instabile Hauptlinie verursachen.

Es ist jedoch eine Ermutigung, Ihre Änderungen in kleinen Schritten vorzunehmen, die problemlos in die Hauptzeile eingecheckt werden können. Dies fördert die Weiterentwicklung des Codes, anstatt alles zu zerreißen und neu zu schreiben.

Was ist nun gut an dieser Arbeitsweise?

1. Das Verzichten auf große Codestücke oder revolutionäre Änderungen verringert die Wahrscheinlichkeit, dass der Build abgebrochen wird.
2. Wenn Ihr Festschreiben den Build bricht, ist es ziemlich trivial, die Probleme zu identifizieren, es zurückzusetzen und dann schnell eine feste Version festzuschreiben.
3. Indem Sie sicherstellen, dass alle Tests bei jeder kleinen Änderung des Codes ausgeführt werden, stellen Sie sicher, dass Sie keine subtilen Fehler oder Regressionen einführen, die entstehen können, wenn der Code außerhalb des kontinuierlichen Integrationsschemas wächst.

Natürlich eignen sich nicht alle Änderungen für diesen Ansatz. Wie andere betonten, ist keine Regel absolut. Richten Sie jedoch für Änderungen, von denen erwartet wird, dass sie für längere Zeit außerhalb der Hauptleitung liegen, eine alternative Hauptleitung mit einem eigenen kontinuierlichen Integrationsschema ein und verfolgen Sie den gleichen Ansatz. Mit den heutigen verteilten VCS ist das ziemlich einfach.

Argumente für das tägliche Einchecken:

• Der Code wird gespeichert und gegen Festplattenfehler gesichert
• Aktivitäten können in Commit-Notizen aufgezeichnet werden ( was habe ich am Donnerstag getan ...? )
• Die Integration in die vorhandene Codebasis erfolgt früher und in kleineren Abschnitten, wodurch hoffentlich Konflikte oder Zusammenführungsprobleme früher erkannt werden
• Ihr Team hat einen Überblick darüber, woran Sie gearbeitet haben
• Ihre Kollegen können schneller an Ihren Schnittstellen arbeiten und haben so mehr Zeit, sich in Ihren 'großen, komplexen Code' zu integrieren.
• Ihr Code wird früher in der Praxis getestet oder zumindest häufiger verwendet, als Sie es geben. Dies führt zu einer früheren Identifizierung von Fehlern oder Auslassungen.

Argumente gegen das tägliche Einchecken:

• Müssen nicht oder wollen nicht
• Ich habe meinen Code noch nicht "aufgeräumt", es ist ein Durcheinander
• Ich habe keine Zeit

Ich glaube nicht, dass es einen guten Grund gibt, weniger als täglich einzuchecken, abgesehen von Faulheit oder Desorganisation. Nichts Schlimmeres als zu sehen, dass der in der Entwicklungsumgebung ausgeführte Code nicht mit dem Code im Entwicklungszweig übereinstimmt, weil jemand "noch nicht fertig ist" und daher nicht eingecheckt hat.

Da ich mich gerne irre, teile mir bitte alle berechtigten Argumente gegen den täglichen Check-in mit.

Wenn Sie "Festschreiben" als "In Hauptlinie einbinden" meinen, sollten Sie dies definitiv nicht jeden Tag bei einem Softwareprojekt tun, das für die Kunden freigegeben wird. Sie sollten vorgenommene und getestete Änderungen zusammenführen, damit die Hauptlinie immer funktioniert und freigegeben werden kann, und nicht in einem fehlerhaften Zustand mit halbfertigen Features.

Der Luxus der Arbeit mit der heutigen verteilten Versionskontrolle besteht jedoch darin, dass Sie sowohl die Hauptleitung stabil halten als auch git/hg/whatever commitjedes Mal, wenn Sie das Gefühl haben, den Zustand der Dinge bewahren zu wollen, dies gleichzeitig tun können . Ich mache das alle paar Stunden und definitiv am Ende eines jeden Tages.

Mit DVCS können Sie Ihre Arbeit veröffentlichen, mit anderen in Ihrem Team zusammenarbeiten und sie über Änderungen in der Hauptbranche auf dem Laufenden halten. Sie können all dies tun, ohne die Stabilität des Codes zu beeinträchtigen, auf den Ihre Kunden und / oder andere Teams angewiesen sind.

In Zeiten, in denen Subversion die neueste Technologie war und es keine Möglichkeit gab, Feature-Zweige ohne große Schmerzen zu teilen und zusammenzuführen, war eine Hauptlinie, in der sich mehrere verschiedene Features gleichzeitig befanden, möglicherweise der beste Ansatz. Diese Überlegenheit ist jedoch erst ab 2010 spürbar.

In Team Foundation Server können Sie "Zurückstellen", was nicht mit dem Einchecken identisch ist, sondern nur eine Sicherungskopie Ihres Codes erstellt, damit Sie die Änderungen nicht verloren haben, wenn Ihr Computer abstürzt.

Ich habe auch Softwarehäuser gesehen, die eine "Entwicklerlinie" und eine "Hauptlinie" haben. Entwickler können jederzeit in die Entwickler-Zeile einchecken und nur der Teamleiter hat Zugriff auf die Hauptzeile, sodass sie für das Kopieren von Code von Entwickler zu Hauptzeile verantwortlich sind, wenn diese produktionsbereit ist.