Ist es jemals in Ordnung, nicht funktionierenden Code zu schreiben?

Ist es eine gute Idee, nur Arbeitscode zu schreiben?

Diese Festschreibung muss das Repository nicht in einem Arbeitszustand belassen, wie folgt:

• ... wir sind in einem frühen Entwicklungsstadium, der Code ist noch nicht stabil.
• ... Sie sind der einzige Entwickler des Projekts. Sie wissen, warum die Dinge nicht funktionieren. Außerdem stoppen Sie die Arbeit von niemandem, indem Sie fehlerhaften Code eingeben.
• ... der Code funktioniert momentan nicht. Wir werden eine große Änderung daran vornehmen. Lassen Sie uns etwas unternehmen, um einen Punkt zu finden, auf den wir zurückgreifen können, wenn es hässlich wird.

• ... die Kette ist lang, kein Problem, wenn in der lokalen Verzweigung fehlerhafter Code vorhanden ist. Dh

  1. lokale Dateien
  2. Bühnenbereich
  3. engagiert sich in lokaler Filiale
  4. Festschreiben im Remote-Zweig für persönliche Funktionen
  5. Mit Remote- developZweig zusammenführen
  6. Mit Remote- masterZweig zusammenführen
  7. Mit Remote- releaseZweig zusammenführen

• ... begebe dich früh, begebe dich oft.

In der oben genannten Frage besagt die Mehrheit der Antworten, dass das Festschreiben von nicht kompilierbarem Code in lokalen Zweigen und Feature-Zweigen kein Problem darstellt. Warum? Was ist der Wert eines unterbrochenen Commits?

Hinzugefügt: Es gibt ein paar hoch bewertete Kommentare, die besagen, dass man auf einer lokalen Brach alles machen kann, was man will. Die technische Seite der Frage interessiert mich jedoch nicht. Ich möchte vielmehr die besten Praktiken lernen - die Gewohnheiten, die Menschen, die viele Jahre in der Branche gearbeitet haben, am produktivsten verfolgen.

Ich bin erstaunt über die Unmenge an tollen Antworten! Sie führen mich zu dem Schluss, dass ich nicht in der Lage bin, Zweige zum Organisieren meines Codes zu verwenden.

Eine der Verzweigungsphilosophien (Abschnitt Entwickeln von Verzweigungsstrategien und Codeline-Richtlinien in erweiterten SCM-Verzweigungsstrategien - lesen Sie auch die bewährten Vorgehensweisen in Perforce ( PDF), gehen Sie jedoch auf einige andere Details ein) ist, dass Sie sich mit inkompatiblen Richtlinien befassen .

Eine Codeline-Richtlinie legt die faire Verwendung und die zulässigen Eincheckvorgänge für die Codeline fest und ist das grundlegende Benutzerhandbuch für Codeline-SCM. Beispielsweise sollte in der Richtlinie einer Entwicklungscodeline angegeben werden, dass sie nicht zur Veröffentlichung bestimmt ist. Ebenso sollte die Richtlinie einer Release-Codeline Änderungen an genehmigten Fehlerkorrekturen einschränken. Die Richtlinie kann auch beschreiben, wie eingecheckte Änderungen dokumentiert werden, welche Überprüfung erforderlich ist, welche Tests erforderlich sind und welche Erwartungen an die Codeline-Stabilität nach dem Einchecken bestehen. Eine Richtlinie ist eine wichtige Komponente für einen dokumentierten, durchsetzbaren Softwareentwicklungsprozess, und eine Codeline ohne Richtlinie ist aus SCM-Sicht außer Kontrolle.

(aus Perforce Best Practices)

Angenommen, Sie haben die Zweige 'release' (oder 'master'), aus denen ein Release besteht, und 'trunk' (oder 'dev'), in denen Entwickler den Arbeitscode einchecken. Dies sind die Richtlinien der Niederlassungen. Da der 'Arbeitscode' Teil der 'dev'-Verzweigungsrichtlinie ist, sollte niemals gebrochener Code in die dev-Verzweigung geschrieben werden. Oft gibt es Dinge wie CI-Server, die an diese Zweige angeschlossen sind, und das Einchecken von fehlerhaftem Code in dev könnte die Zweige aller durcheinander bringen und den Build auflösen.

Es gibt jedoch Zeiten, in denen es angebracht ist, Teilcode einzuchecken, der nicht funktioniert. In diesen Fällen sollte verzweigt werden - eine inkompatible Richtlinie mit trunk. In diesem neuen Zweig kann man die Richtlinie festlegen ('fehlerhafter Code ist in Ordnung') und dann den Code festschreiben.

Es gibt eine einfache Regel, die festlegt, ob eine Codeline verzweigt werden soll: Sie sollte verzweigt werden, wenn die Benutzer andere Eincheckrichtlinien benötigen. Beispielsweise benötigt eine Produktversionsgruppe möglicherweise eine Eincheckrichtlinie, die strenge Tests erzwingt, während ein Entwicklungsteam möglicherweise eine Richtlinie benötigt, die häufiges Einchecken von teilweise getesteten Änderungen ermöglicht. Diese Abweichung der Richtlinien erfordert eine Codeline-Verzweigung. Wenn eine Entwicklungsgruppe keine andere sehen möchte

(aus Perforce Best Practices)

Stellen Sie fest, dass dies von einem zentralen, serverbasierten SCM mit einer starken Unternehmensphilosophie ausgeht. Die Grundidee ist immer noch gut. An diese wird oft implizit gedacht - Sie checken nicht getesteten Entwicklungscode in den Release-Zweig ein. Das ist eine Politik.

Nehmen wir also an, dieser Zweig könnte fehlerhaften Code enthalten und sich abspeichern.

Eine der von Linus Torvalds vorgeschlagenen Philosophien ist, dass kreatives Programmieren wie eine Reihe von Experimenten sein sollte. Sie haben eine Idee und folgen ihr. Es klappt nicht immer, aber du hast es zumindest versucht. Sie möchten Entwickler dazu ermutigen, kreative Ideen auszuprobieren. Um dies zu tun, muss es günstig sein, dieses Experiment auszuprobieren und kostengünstig wiederherzustellen. Dies ist die wahre Stärke von Git Commits, die so billig sind (schnell und einfach). Es öffnet dieses kreative Paradigma, das Entwicklern die Möglichkeit gibt, Dinge auszuprobieren, die sie sonst möglicherweise nicht hätten. Dies ist die Befreiung von Git.

Ja, solange es sich nicht um einen Release-Zweig handelt.

In persönlichen Zweigen geht alles und kann dann verworfen werden, wenn das Experiment nicht funktioniert hat. Das ist einer der Hauptvorteile von DVCS: Freiheit

Der Wert von defektem Code: Zusammenarbeit und Experimentieren

Ja, es ist in Ordnung und ich mache viel.

Der Zweck des Festschreibens von nicht kompilierbarem Code (zumindest in Zweigen) besteht darin, dass Ihr Code manchmal in Bearbeitung ist, die bisher geleistete Arbeit jedoch es wert ist, gespeichert und / oder mit anderen geteilt zu werden

Meine Praktiken sind:

• schreiben Sie zuerst Tests
• WIP-Commits (Work-in-Progress) sind gut
• häufig (mehrere innerhalb eines Tages) und früh (speichern Sie "Arbeitsschritte")
• Drücken Sie nach jedem Commit (falls Ihre Festplatte abstürzt oder der Bus Sie trifft).
• Immer zuerst in Filialen arbeiten
• wenn möglich nur im arbeitscode zum master zusammenführen
• Interaktives Rebase in Git, um Wips vor dem Master Merge zu zerquetschen

Das Hauptproblem und vielleicht das, das Sie gerade ansprechen, ist, wenn Sie eine Funktion haben, die im Grunde funktioniert und vom Unternehmen dringend benötigt wird (und daher in "Master" sein muss), aber einige Tests nicht bestanden haben. Eine Möglichkeit besteht darin, einen ausstehenden Test durchzuführen, mit dem Sie vorerst vorankommen können. Dies ist jedoch mit einer gewissen Gefahr verbunden, da der Test möglicherweise nie repariert werden kann und in anderen Bereichen möglicherweise ein Muster festgelegt wird, bei dem gebrochene Tests einfach "ausstehend" sind, anstatt sie zu reparieren.

Eine andere Option wäre die vorübergehende Verwendung und Bereitstellung des Zweigs. Dies kann in bestimmten Situationen hilfreich sein, wird jedoch im Allgemeinen nicht empfohlen und ist nicht nachhaltig.

Vielleicht ist die beste Option, einen professionelleren Ansatz für die Softwareentwicklung zu wählen und wirklich Funktionstests für jeden festgeschriebenen Code zu erfordern. Dies ist häufig der "harte" Teil der Softwareentwicklung, nicht die Codierung, die sich viele Menschen vorstellen. Ein besserer Ansatz erfordert wahrscheinlich bessere anfängliche Schätzungen, eine bessere Ressourcenzuweisung, Prioritätensetzung usw. sowie während der agilen Entwicklung genügend Zeit und Disziplin, um Probleme sowohl zum Zeitpunkt des Auftretens als auch während der Sitzungen mit dem Grooming Pointing zu beheben.

Konzentrieren Sie sich auf das, was "erledigt" bedeutet - es bedeutet, dass der Code UND die Tests geschrieben wurden, überarbeitet wurden und funktionieren. Wenn Sie Kommentare wie "Meistens erledigt, müssen Sie nur Tests schreiben / korrigieren / umgestalten" hören, dann ist dies NICHT der Fall. Es ist einer der häufigsten Fehler von Junior-Programmierern, zu behaupten, dass eine Funktion ohne technische Vollständigkeit ausgeführt wird.

Der Wert eines Commits, ob fehlerhaft oder nicht, besteht darin, dass der Code an einen Server übergeben wird. In professionellen Umgebungen ist dieser Server sicher, redundant und führt Sicherungen aus. Wenn ich den ganzen Tag arbeite, bedeutet das Festschreiben, dass mein Code überlebt, was auch immer mit meinem lokalen Computer passiert. Festplatten sterben. Laptops gehen verloren oder werden gestohlen. Sicherungen des Repository-Servers sind auch dann verfügbar, wenn das Gebäude abbrennt.

Denken Sie so darüber nach. Als Entwickler ist es eine der störendsten Aufgaben, andere Entwickler in Ihrem Team daran zu hindern, an ihren Aufgaben zu arbeiten.

Die Philosophie, nur Arbeitscode zu schreiben, kommt von Entwicklungsteams, die an demselben einzelnen Trunk im Repository arbeiten. Es mag jetzt wahnsinnig erscheinen, aber vor 10 Jahren war dies die normale Arbeitsweise. Eine Verzweigung wurde angezeigt, wenn Sie eine stabile Version erstellen wollten, aber der Gedanke, dass ein Entwickler in einer Verzweigung arbeitet, um eine neue Funktion zu implementieren, war fast unbekannt.

Wenn Ihre Umgebung bedeutet, dass Ihre Festschreibungen andere Entwickler nicht sofort betreffen, führen Sie häufig Festschreibungen durch. Es gibt Ihnen mehr Sicherheit in Ihrem Code, was das Zurücksetzen eines Codefehlers erleichtert, und viele Quellcodeverwaltungssysteme bieten Ihnen einen gewissen Codeschutz für festgeschriebenen Code (wenn auch nicht für alle).

Stellen Sie nun sicher, dass Ihre Zusammenführungen mit Zweigen, die mit anderen Entwicklern geteilt wurden, funktionieren und dass jeder Code, den Sie auf diese Ebene hochstufen, kompiliert, alle Komponententests und andere teambasierte Sicherheitsprüfungen besteht kaufe weiter das Bier in der Kneipe ...

Bevor Sie sich dogmatisch mit der Versionskontrolle befassen, sollten Sie sich überlegen, warum Sie mit der Versionskontrolle arbeiten.

Wenn Sie sich zur Versionskontrolle verpflichten, wird der Status Ihres Codes zum späteren Nachschlagen eingefroren - alles andere fällt hiervon ab. Wenn man sich Unterschiede ansieht und Patches erstellt, sieht man nur, wie sich der Code zwischen den Snapshots geändert hat. Zweige und Tags sind nur Möglichkeiten zum Organisieren von Snapshots. Wenn Sie Code für andere Entwickler freigeben, können sie sich nur einen bestimmten Schnappschuss ansehen.

Wann sollten Sie sich verpflichten? Wenn es eine vernünftige Chance gibt, werden Sie sich in Zukunft den Status Ihres Codes (oder die Commit-Nachricht, die eine Änderung erklärt) ansehen.

Git gibt Ihnen viel Flexibilität bei der Organisation Ihrer Schnappschüsse. Es gibt kein zentrales Repository, sodass Sie Ihren Code mit anderen Entwicklern teilen können, ohne Ihren Status in das Hauptrepository zu verschieben. Sie können auf einfache Weise Zweige erstellen, zusammenführen und löschen, um die Details einer Reihe von Zuständen von der Erzählung des Hauptcodes zu isolieren. Sie können lokal ein Commit ausführen, um die Rückgängigmachung Ihrer aktuellen Entwicklung zu erleichtern. Anschließend können Sie alles in einem einzigen Commit zusammenfassen, bevor Sie es für andere sichtbar machen. Sie können bestimmte Revisionen mit Tags versehen, um sie später leichter zu finden.

KUSS . Was für einen einzelnen Entwickler in den frühen Phasen der Entwicklung eines kleinen Projekts am besten funktioniert, unterscheidet sich grundlegend von dem, was Sie tun müssen, wenn hundert Entwickler an einem jahrzehntealten, geschäftskritischen System arbeiten. In jedem Softwareentwicklungsprozess sollten Sie vermeiden, unnötige Artefakte zu erstellen , nur weil Sie von einem anderen Benutzer dazu aufgefordert wurden.

Zweige erstellen / freigeben

Sie sollten niemals absichtlich fehlerhaften Code in einen Build-Zweig schreiben. Jeder Zweig, der sich in ständiger Integration befindet oder aus dem Releases oder tägliche Builds erstellt werden, sollte sich immer in einem potenziell freigebbaren Zustand befinden.

Andere Zweige: Save State Oft

Für private oder Feature-Zweige sind die Ziele oft unterschiedlich. Ein häufiges Einchecken des Codes (unabhängig davon, ob er funktioniert oder nicht) kann wünschenswert sein. Im Allgemeinen möchten Sie festlegen, wann immer Sie den aktuellen Status wiederherstellen müssen.

Betrachten Sie diese Beispiele, bei denen der gespeicherte Status einen erheblichen Vorteil bietet:

• Sie können ein Commit ausführen, bevor Sie ein globales Suchen und Ersetzen ausführen, damit Sie Ihren Baum in einem einzigen Vorgang zurücksetzen können, wenn etwas schief geht.
• Möglicherweise führen Sie eine Reihe von vorläufigen Commits durch, während Sie einen komplexen Code umgestalten, sodass Sie ihn halbieren oder zurückspulen können, wenn Sie am Ende einen Fehler in diesem Prozess machen.
• Sie können ein Commit ausführen, eine neue Verzweigung starten oder ein Tag erstellen, wenn Sie etwas Experimentelles ausprobieren möchten, während Sie jederzeit in den Status des aktuellen Arbeitsbaums zurückkehren können.

Das Festschreiben einer fehlerhaften Codebasis ist in Ordnung, solange es lokal ist.

Warum?

• Es ist wichtig, Commit als sicheren Punkt in Ihrer Entwicklung zu verwenden
• Es zeigt Ihnen ein Denkmuster, das Sie bei der Entwicklung des Produkts verwendet haben.
• Die Zusammenarbeit wird nicht unterbrochen .

Wenn es jedoch ein Team von Programmierern gibt, ist die Philosophie des Programmierhauses von größter Bedeutung und ersetzt das Verhalten einzelner Commits. Einige Programmierhäuser beschließen, den gesamten Fortschritt zu protokollieren, während andere nur Code festschreiben, der eine Funktion löst. In diesem Fall ist der Wert ( Kosten aus Sicht der Softwareverwaltung) eines unterbrochenen Commits fatal:

1. Die Zeit, die für die Weiterentwicklung der Funktionen aufgewendet wurde, wird nun für die Behebung von Fehlern verwendet ...
2. der Entwicklungsschnitt ist nicht erreicht ...
3. Produkt wird nicht pünktlich geliefert

Zu diesen drei Faktoren können weitere Punkte hinzugefügt werden, die ihre Auswirkungen exponentiell in eine Unternehmensschmelze einfließen lassen.

Ich denke nicht, dass es in Ordnung ist, fehlerhaften Code zu schreiben.

Was passiert wenn

• Ein dringender Hotfix ist erforderlich. Die Codebasis ist in einem fehlerhaften Zustand. Sie sind gezwungen, ein Rollback durchzuführen, zu reparieren und bereitzustellen.

• Jemand anderes beginnt im selben Zweig zu arbeiten, ohne zu wissen, dass Sie fehlerhaften Code geschrieben haben. Sie jagen vielleicht einem "roten Hering" nach und glauben, dass ihre Veränderungen etwas kaputt gemacht haben.

• Sie beschließen, das Unternehmen zu verlassen, in den Urlaub zu fahren oder aus irgendeinem Grund nicht zur Arbeit zu kommen. Ihre Kollegen müssen tief graben, um herauszufinden, was kaputt ist und warum es in einem kaputten Zustand begangen wurde.

• Jemand setzt Ihren "kaputten Code" ein? Dies kann ein "Spielende" sein, wenn Sie mit persönlichen Daten oder einem Zahlungsanbieter arbeiten.

Antworte auf @WarrenT

Ich stimme Ihnen zu, dass in einer idealen Welt, in der jeder in einem Feature-Zweig arbeitet, das Festschreiben von nicht funktionierendem Code möglicherweise funktioniert. Ich habe an großen Projekten gearbeitet und selbst dann gab es Fälle, in denen mehrere Personen in einem einzelnen Feature-Zweig arbeiten mussten. Ich habe auch gesehen, wie Leute Code, der nicht funktioniert, in den Hauptzweig geschrieben haben, weil die Veröffentlichung Wochen entfernt war und sie planten, ihn am nächsten Tag zu reparieren. All diese Dinge sind Kandidaten für eine Katastrophe, und ich bin der festen Überzeugung, dass sie um jeden Preis vermieden werden sollten.

Einige Fragen, mit denen Sie feststellen können, ob das Festschreiben von nicht funktionierendem Code in Ordnung ist:

1. Bist du überarbeitet?
2. Brechen Ihre Teamkollegen ständig den Build?
3. Ist Ihre Code-Basis ein Chaos und kann anscheinend nicht schlimmer werden?

Wenn Sie zu einem der oben genannten Punkte Ja sagen, ist es in Ordnung, nicht funktionierenden Code zu schreiben.

Denken Sie daran, das Problem so schnell wie möglich zu beheben, alle zutreffenden Komponententests durchzuführen und sich für den Abbruch des Builds zu entschuldigen.