Überprüfen Sie vor oder nach dem Festschreiben des Codes, was ist besser?

Traditionell haben wir die Codeüberprüfung vor dem Festschreiben durchgeführt. Ich hatte heute einen Streit mit meinem Kollegen, der die Codeüberprüfung nach dem Festschreiben bevorzugte.

Erstens, hier ist ein Hintergrund,

1. Wir haben einige erfahrene Entwickler und neue Mitarbeiter mit nahezu null Programmiererfahrung.
2. Wir möchten schnelle und kurze Iterationen durchführen, um unser Produkt freizugeben.
3. Alle Teammitglieder befinden sich am selben Standort.

Die Vorteile der Codeüberprüfung vor dem Festschreiben, die ich gelernt habe:

1. Mentor neue Mitarbeiter
2. Versuchen Sie, Fehler, Ausfälle und schlechte Designs früh im Entwicklungszyklus zu vermeiden
3. Lerne von anderen
4. Wissenssicherung, wenn jemand beendet wird

Aber ich habe auch einige schlechte Erfahrungen gemacht:

1. Bei geringer Effizienz können einige Änderungen über Tage hinweg überprüft werden
2. Besonders für Neulinge ist es schwierig, Geschwindigkeit und Qualität in Einklang zu bringen
3. Ein Teammitglied fühlte sich misstrauisch

Was die Überprüfung nach dem Festschreiben angeht, weiß ich wenig darüber, aber am meisten beunruhigt mich das Risiko, die Kontrolle zu verlieren, weil keine Überprüfung vorliegt. Irgendwelche Meinungen?

AKTUALISIEREN:

1. Wir verwenden Perforce für VCS
2. Wir codieren und verpflichten uns in denselben Zweigen (Stamm- oder Fehlerbehebungszweige)
3. Um die Effizienz zu verbessern, haben wir versucht, den Code in kleine Änderungen aufzuteilen. Wir haben auch einige Live-Dialogüberprüfungen versucht, aber nicht alle haben die Regel befolgt. Dies ist jedoch ein weiteres Problem.

Wie Simon Whitehead in seinem Kommentar erwähnt , hängt es von Ihrer Verzweigungsstrategie ab.

Wenn die Entwickler einen eigenen privaten Zweig für die Entwicklung haben (was ich in den meisten Situationen sowieso empfehlen würde), würde ich die Codeüberprüfung vor dem Zusammenführen mit dem Trunk oder dem Haupt-Repository durchführen. Auf diese Weise können Entwickler während ihres Entwicklungs- / Testzyklus so oft einchecken, wie sie möchten. Wenn jedoch Zeitcode in den Zweig gelangt, der den bereitgestellten Code enthält, wird dieser überprüft.

Im Allgemeinen klingen Ihre schlechten Erfahrungen mit Codeüberprüfungen eher nach einem Problem mit dem Überprüfungsprozess, für das es Lösungen gibt. Durch Überprüfen des Codes in kleineren, einzelnen Abschnitten können Sie sicherstellen, dass der Vorgang nicht zu lange dauert. Eine gute Zahl ist, dass 150 Codezeilen in einer Stunde überprüft werden können. Für Benutzer, die mit der Programmiersprache, dem in der Entwicklung befindlichen System oder der Kritikalität des Systems nicht vertraut sind, ist die Rate jedoch langsamer (ein Sicherheitskritikal benötigt mehr Zeit). Diese Informationen können hilfreich sein, um die Effizienz zu verbessern und zu entscheiden, wer an Codeüberprüfungen teilnimmt.

Es gibt ein Mantra, das noch niemand zitiert zu haben scheint: Checke früh und oft ein :

Entwickler, die längere Zeit - und damit meine ich mehr als einen Tag - arbeiten, ohne die Quellcodeverwaltung zu überprüfen, bereiten sich auf einige ernsthafte Integrationsprobleme vor. Damon Poole stimmt zu :

Entwickler schieben das Einchecken oft zurück. Sie schieben es zurück, weil sie nicht zu früh auf andere Leute einwirken und nicht dafür verantwortlich gemacht werden möchten, dass sie den Build abgebrochen haben. Dies führt jedoch zu anderen Problemen, z. B. zu einem Arbeitsausfall oder der Unfähigkeit, zu früheren Versionen zurückzukehren.

Meine Faustregel lautet "Früh und häufig einchecken", aber mit dem Vorbehalt, dass Sie Zugriff auf die private Versionierung haben. Wenn ein Check-in für andere Benutzer sofort sichtbar ist, besteht die Gefahr, dass unreife Änderungen vorgenommen werden und / oder der Build abgebrochen wird.

Ich würde lieber kleine Fragmente in regelmäßigen Abständen einchecken lassen, als lange Zeiträume ohne eine Vorstellung davon zu haben, was meine Kollegen schreiben. Aus meiner Sicht ist der Code nicht vorhanden , wenn er nicht in die Quellcodeverwaltung eingecheckt wurde . Ich nehme an, dies ist noch eine andere Form von Don't Go Dark . Der Code ist unsichtbar, bis er in irgendeiner Form im Repository vorhanden ist.

... Wenn Sie früh einchecken und häufig einchecken lernen, haben Sie ausreichend Zeit für Feedback, Integration und Überprüfung ...

Ich habe für ein paar Unternehmen gearbeitet, die unterschiedliche Ansätze hatten. Man erlaubte es, solange es das Kompilieren nicht verhinderte. Der andere würde ausflippen, wenn Sie überhaupt irgendwelche Bugs einchecken würden. Ersteres ist sehr bevorzugt. Sie sollten sich in einer Art Umgebung entwickeln, die es Ihnen ermöglicht, mit anderen Menschen an Dingen zusammenzuarbeiten, die noch im Gange sind, mit dem Verständnis, dass alles später getestet wird.

Es gibt auch Jeff Atwoods Aussage: Hab keine Angst, Dinge zu zerbrechen :

Der direkteste Weg, sich als Softwareentwickler zu verbessern, besteht darin, absolut furchtlos zu sein, wenn es darum geht, Ihren Code zu ändern. Entwickler, die Angst vor fehlerhaftem Code haben, sind Entwickler, die niemals zu Profis heranwachsen.

Ich möchte auch hinzufügen, dass für Peer Reviews, wenn jemand möchte, dass Sie etwas ändern, die Historie Ihrer Originalversion in der Quelle ein sehr wertvolles Lernwerkzeug ist.

Ich habe kürzlich begonnen, Pre-Commit-Überprüfungen in einem Projekt durchzuführen, an dem ich beteiligt bin, und ich muss sagen, dass ich positiv überrascht bin, wie unproblematisch es ist.

Der größte Nachteil von Nachprüfungen, den ich sehe, ist, dass sie oft nur von einer Person durchgeführt werden: Jemand prüft den Code auf Richtigkeit, aber der Autor ist normalerweise nicht beteiligt, es sei denn, es liegt ein schwerwiegender Fehler vor. Kleine Probleme, Vorschläge oder Hinweise erreichen den Autor normalerweise überhaupt nicht.

Dies ändert auch das wahrgenommene Ergebnis der Codeüberprüfungen: Es wird als etwas angesehen, das nur zusätzliche Arbeit erzeugt, im Gegensatz zu etwas, bei dem jeder (der Überprüfer und der Autor des Codes) jedes Mal neue Dinge lernen kann.

Codeüberprüfungen vor dem Festschreiben scheinen so natürlich zu sein, dass mir nie aufgefallen ist, dass Überprüfungen absichtlich nach dem Festschreiben durchgeführt werden könnten. Unter dem Gesichtspunkt der kontinuierlichen Integration möchten Sie Ihren Code erst dann festschreiben, wenn er fertig ist, und zwar nicht in einem funktionierenden, aber möglicherweise schlecht geschriebenen Zustand, oder?

Vielleicht liegt es daran, dass die Art und Weise, wie wir es in meinen Teams immer getan haben, ein vom ursprünglichen Entwickler initiierter Live-Dialog ist, nicht jedoch asynchrone, kontrollgesteuerte, dokumentbasierte Überprüfungen.

Die meisten Repositorys unterstützen heutzutage ein zweiphasiges Commit oder ein Shelveset (privater Zweig, Pull-Anforderung, Patch-Übermittlung oder wie auch immer Sie es nennen möchten), mit dem Sie die Arbeit prüfen / überprüfen können, bevor Sie sie in die Hauptleitung ziehen. Ich würde sagen, dass Sie mit diesen Tools immer Überprüfungen vor dem Festschreiben durchführen können.

Sie können auch die Paarkodierung (ältere Paare mit jüngeren) in Betracht ziehen, um eine integrierte Codeüberprüfung bereitzustellen. Betrachten Sie es als eine Qualitätsprüfung am Fließband statt nach dem Abrollen des Autos.

Tue beides :

• Pre Commit - Führen Sie diese Art von Überprüfungen durch, wenn es sich um etwas sehr Wichtiges handelt, z. B. um ein wiederverwendbares Codestück oder eine wichtige Designentscheidung
• post commit - Führen Sie diese Art von Überprüfungen durch, wenn Sie eine Meinung zu einem Code erhalten möchten, der möglicherweise verbessert wird

Jede formelle Überprüfung sollte an Quelldateien vorgenommen werden, die der Konfigurationskontrolle unterliegen, und in den Überprüfungsaufzeichnungen sollte eindeutig angegeben werden, dass die Datei überarbeitet wurde.

Dies vermeidet Argumente vom Typ "Sie haben nicht die neueste Datei" und stellt sicher, dass jeder die gleiche Kopie des Quellcodes überprüft.

Dies bedeutet auch, dass der Verlauf mit dieser Tatsache kommentiert werden kann, falls Korrekturen nach der Überprüfung erforderlich sind.

Für die Codeüberprüfung selbst stimme ich für "während" des Commits.

Ein System wie gerrit oder clover (glaube ich) kann eine Änderung inszenieren und den Prüfer dann zur Versionskontrolle verpflichten (push in git), wenn es gut ist. Das ist das Beste aus beiden Welten.

Wenn das nicht praktikabel ist, halte ich After Commit für den besten Kompromiss. Wenn das Design gut ist, sollten nur die meisten Nachwuchsentwickler Dinge haben, die schlecht genug sind, damit sie nicht jemals begangen werden. (Machen Sie eine Pre-Commit-Überprüfung für sie).

Dies führt zu einer Entwurfsprüfung - während Sie dies zur Zeit der Codeüberprüfung (oder zum Zeitpunkt der Kundenbereitstellung) tun können, sollten Entwurfsprobleme früher erkannt werden - bevor der Code tatsächlich geschrieben wird.

Bei Peer Review besteht nur ein minimales Risiko, die Kontrolle zu verlieren. Zwei Personen kennen sich ständig mit demselben Code aus. Sie müssen gelegentlich wechseln, also müssen sie die ganze Zeit aufmerksam sein, um den Code im Auge zu behalten.

Es ist sinnvoll, einen geschickten Entwickler und einen Neuling zusammen zu haben. Auf den ersten Blick scheint dies ineffizient zu sein, ist es aber nicht. In der Tat gibt es weniger Fehler, und es dauert weniger Zeit, um diese zu beheben. Außerdem werden die Neulinge viel schneller lernen.

Was dazu beiträgt, ein schlechtes Design zu verhindern, sollte dies vor dem Codieren erfolgen. Wenn es wesentliche Änderungen / Verbesserungen / Neuentwicklungen gibt, sollten diese vor Beginn der Codierung überprüft werden. Wenn das Design vollständig entwickelt ist, bleibt nicht mehr viel zu tun. Das Überprüfen des Codes wird einfacher und nimmt weniger Zeit in Anspruch.

Ich stimme zu, dass es nicht unbedingt erforderlich ist, den Code vor dem Festschreiben zu überprüfen, wenn der Code von einem erfahrenen Entwickler erstellt wurde, der seine Fähigkeiten bereits unter Beweis gestellt hat. Wenn es jedoch einen Neuling gibt, sollte der Code vor dem Festschreiben überprüft werden: Der Prüfer sollte sich neben den Entwickler setzen und jede von ihm vorgenommene Änderung oder Verbesserung erläutern.

Bewertungen profitieren sowohl von Pre- als auch von Post-Commits.

Commit vor Überprüfung

• Verleiht den Rezensenten das Vertrauen, dass sie die neueste Version des Autors überprüfen.
• Hilft sicherzustellen, dass jeder den gleichen Code überprüft.
• Gibt eine Referenz zum Vergleich an, sobald die Überarbeitungen der Überprüfungselemente abgeschlossen sind.

Keine laufenden Commits während der Überprüfung

Ich habe Atlassian-Tools verwendet und festgestellt, dass während der Überprüfung Commits ausgeführt werden. Dies ist für Rezensenten verwirrend, daher empfehle ich dagegen.

Revisionen veröffentlichen

Nachdem die Prüfer ihr Feedback mündlich oder schriftlich abgegeben haben, sollte der Moderator sicherstellen, dass der Autor die gewünschten Änderungen vornimmt. Manchmal sind sich die Prüfer oder der Autor nicht einig, ob ein Prüfling als Fehler, Vorschlag oder Untersuchung zu bezeichnen ist. Um Meinungsverschiedenheiten beizulegen und sicherzustellen, dass die Untersuchungsgegenstände ordnungsgemäß gelöscht werden, ist das Überprüfungsteam auf das Urteil des Moderators angewiesen.

Meine Erfahrung mit rund 100 Code-Inspektionen zeigt, dass Überprüfungsergebnisse für die meisten Arten von Logik- und anderen Programmierfehlern in der Regel eindeutig sind, wenn Überprüfer auf einen eindeutigen Codierungsstandard verweisen können. Gelegentlich kommt es zu einer Debatte über das Nit-Picking, oder ein Punkt des Stils kann zu einer Auseinandersetzung verkommen. Wenn Sie dem Moderator jedoch Entscheidungsbefugnis geben, kommt es nicht zum Stillstand.

Nachprüfungsverpflichtung

• Bietet dem Moderator und anderen Überprüfern einen Datenpunkt zum Vergleich mit dem Commit vor der Überprüfung.
• Bietet Metriken, anhand derer sowohl der Wert als auch der Erfolg der Überprüfung bei der Beseitigung von Fehlern und der Verbesserung des Codes beurteilt werden können.

Es hängt von der Zusammensetzung Ihres Teams ab. Für ein relativ erfahrenes Team, das sich gut mit kleinen, häufigen Commits auskennt, ist eine Überprüfung nach dem Commit, um ein zweites Paar Augen für den Code zu haben, in Ordnung. Bei umfangreicheren, komplexeren Commits und / oder weniger erfahrenen Entwicklern erscheint es vorsichtiger, vorab Überprüfungen durchzuführen, um Probleme zu beheben, bevor sie eingehen.

In diesem Sinne wird durch einen guten CI-Prozess und / oder kontrollierte Eincheckvorgänge die Notwendigkeit von Überprüfungen vor dem Festschreiben verringert (und möglicherweise nach dem Festschreiben für viele von ihnen).

Ich und meine Kollegen haben in letzter Zeit einige wissenschaftliche Untersuchungen zu diesem Thema durchgeführt, daher möchte ich einige unserer Erkenntnisse hinzufügen, obwohl dies eine ziemlich alte Frage ist. Wir haben ein Simulationsmodell eines agilen Kanban-Entwicklungsprozesses / -Teams erstellt und die Überprüfung vor und nach dem Festschreiben für eine Vielzahl unterschiedlicher Situationen verglichen (unterschiedliche Anzahl von Teammitgliedern, unterschiedliche Qualifikationsstufen, ...). Wir haben die Ergebnisse nach 3 Jahren (simulierter) Entwicklungszeit untersucht und nach Unterschieden in Bezug auf Effizienz (fertige Story Points), Qualität (von Kunden gefundene Bugs) und Zykluszeit (Zeit vom Start bis zur Auslieferung einer User Story) gesucht. . Unsere Erkenntnisse lauten wie folgt:

• Die Unterschiede in Bezug auf Effizienz und Qualität sind in vielen Fällen vernachlässigbar. Wenn dies nicht der Fall ist, hat die Überprüfung nach dem Festschreiben einige Vorteile in Bezug auf die Qualität (andere Entwickler fungieren in gewisser Weise als "Beta-Tester"). Aus Gründen der Effizienz bietet Post-Commit einige Vorteile in kleinen Teams und Pre-Commit einige Vorteile in großen oder ungeübten Teams.
• Die Überprüfung vor dem Festschreiben kann zu längeren Zykluszeiten führen, wenn der Start abhängiger Aufgaben durch die Überprüfung verzögert wird.

Daraus haben wir folgende heuristische Regeln abgeleitet:

• Wenn Sie einen etablierten Codeüberprüfungsprozess haben, sollten Sie sich nicht die Mühe machen, diesen zu ändern
  • es sei denn, Sie haben Probleme mit der Zykluszeit => Zu Beitrag wechseln
  • Oder Fehler stören Ihre Entwickler zu oft => Wechseln Sie zu Pre
• Wenn Sie noch keine Bewertungen haben
  • Verwenden Sie pre commit, wenn einer dieser Vorteile für Sie zutrifft
    • Pre-Commit-Review ermöglicht es Außenstehenden ohne Commit-Rechte, an Open Source-Projekten mitzuwirken
    • Wenn die Überprüfung werkzeugbasiert ist, erzwingt die Überprüfung vor dem Festschreiben eine gewisse Überprüfungsdisziplin in Teams mit ansonsten nachlässiger Prozesseinhaltung
    • Die Überprüfung vor dem Festschreiben verhindert auf einfache Weise, dass nicht überprüfte Änderungen übermittelt werden, was für eine kontinuierliche Bereitstellung / sehr kurze Veröffentlichungszyklen von Vorteil ist
  • Verwenden Sie pre commit, wenn Ihr Team groß ist und Sie die Probleme in der Zykluszeit bewältigen oder umgehen können
  • Andernfalls (z. B. kleines, qualifiziertes Industrieteam) verwenden Sie Post-Commit
• Suchen Sie nach Kombinationen, die Ihnen die Vorteile beider Welten bieten (wir haben diese formal nicht untersucht).

Das vollständige Research Paper finden Sie hier: http://dx.doi.org/10.1145/2904354.2904362 oder auf meiner Website: http://tobias-baum.de

Meiner Meinung nach funktioniert Code-Peer-Review am besten nach dem Festschreiben.

Ich würde empfehlen, Ihre Verzweigungsstrategie anzupassen. Die Verwendung eines Entwicklerzweigs oder eines Feature-Zweigs bietet eine Reihe von Vorteilen, von denen nicht zuletzt die Überprüfung des Codes nach dem Festschreiben erleichtert wird.

Ein Tool wie Crucible glättet und automatisiert den Überprüfungsprozess. Sie können ein oder mehrere festgeschriebene Änderungssätze auswählen, die in die Überprüfung einbezogen werden sollen. Crucible zeigt an, welche Dateien in den ausgewählten Änderungssätzen berührt wurden, verfolgt, welche Dateien jeder Prüfer bereits gelesen hat (und zeigt insgesamt einen Prozentwert an), und lässt die Prüfer problemlos Kommentare abgeben.

http://www.atlassian.com/software/crucible/overview

Einige andere Vorteile von Benutzer- / Feature-Zweigen:

• Entwickler erhalten die Vorteile der Versionskontrolle (Sichern von Änderungen, Wiederherstellen aus dem Verlauf, Diff-Änderungen), ohne sich Gedanken darüber machen zu müssen, dass das System für alle anderen beschädigt wird.
• Änderungen, die zu Fehlern führen oder nicht rechtzeitig abgeschlossen werden, können zurückgesetzt, neu priorisiert oder bei Bedarf zurückgestellt werden.

Für unerfahrene Entwickler ist eine regelmäßige Konsultation eines Mentors und / oder Paarprogrammierers eine gute Idee, aber ich würde dies nicht als "Code Review" betrachten.

Beide. (So'ne Art.)

Sie sollten Ihren eigenen Code zusammenfassend überprüfen, bevor Sie ihn festschreiben. In Git finde ich den Staging-Bereich großartig. Nachdem ich meine Änderungen vorgenommen habe, starte ich git diff --cached, um alles zu sehen, was bereitgestellt wird. Ich nutze dies als Gelegenheit, um sicherzustellen, dass keine Dateien eingecheckt werden, die nicht dazu gehören (Build-Artefakte, Protokolle usw.), und um sicherzustellen, dass kein Debug-Code darin enthalten ist oder kein wichtiger Code kommentiert wurde aus. (Wenn ich etwas tue, von dem ich weiß, dass ich es nicht einchecken möchte, hinterlasse ich normalerweise einen Kommentar in Großbuchstaben, damit ich ihn während der Inszenierung wiedererkenne.)

Allerdings sollte Ihre Peer-Code-Überprüfung in der Regel nach dem Festschreiben durchgeführt werden, vorausgesetzt, Sie arbeiten an einem Zweig der Themen. Dies ist der einfachste Weg, um sicherzustellen, dass alle anderen das Richtige überprüfen, und wenn es größere Probleme gibt, ist es keine große Sache, sie in Ihrem Zweig zu beheben oder sie zu löschen und von vorne zu beginnen. Wenn Sie Codeüberprüfungen asynchron durchführen (z. B. mithilfe von Google Code oder Atlassian Crucible), können Sie problemlos zwischen Zweigen wechseln und an etwas anderem arbeiten, ohne die verschiedenen Patches / Unterschiede, die derzeit einige Tage lang überprüft werden, separat nachverfolgen zu müssen.

Wenn Sie nicht an einem Zweig arbeiten, sollten Sie dies tun . Es reduziert Stress und Ärger und macht die Release-Planung viel stressfreier und komplizierter.

Bearbeiten: Ich sollte auch hinzufügen, dass Sie nach dem Testen eine Codeüberprüfung durchführen sollten, was ein weiteres Argument dafür ist, zuerst Code zu schreiben. Sie möchten nicht, dass Ihre Testgruppe mit Dutzenden von Patches / Unterschieden aller Programmierer herumfummelt und dann Fehler meldet, nur weil sie den falschen Patch am falschen Ort angewendet haben.

100% gepaarte Programmierung (egal wie erfahren Sie sind) mit vielen kleinen Commits und einem CI-System, das auf JEDEM Commit aufbaut (mit automatisierten Tests einschließlich Einheiten, Integration und Funktionalität, wo immer dies möglich ist). Überprüfungen nach dem Festschreiben auf große oder riskante Änderungen. Wenn Sie eine Art "Gated" / "Pre-Commit" -Überprüfung benötigen, funktioniert Gerrit.

Der Vorteil der Codeüberprüfung beim Einchecken (Buddy-Check) besteht in der sofortigen Rückmeldung, bevor große Code-Teile fertiggestellt wurden.

Der Nachteil der Codeüberprüfung beim Einchecken besteht darin, dass Personen vom Einchecken abgehalten werden können, bis lange Code-Abschnitte abgeschlossen sind. In diesem Fall wird der Vorteil vollständig zunichte gemacht.

Erschwerend kommt hinzu, dass nicht jeder Entwickler gleich ist. Einfache Lösungen funktionieren nicht für alle Programmierer . Einfache Lösungen sind:

• Mandated Pair Programming, mit dem Sie häufig einchecken können, da der Buddy direkt neben Ihnen ist. Dies ignoriert, dass die Paarprogrammierung nicht immer für alle funktioniert. Richtig gemacht, kann die Paarprogrammierung auch sehr anstrengend sein, so dass nicht unbedingt den ganzen Tag etwas zu tun ist.

• Entwicklerzweige, Code wird erst überprüft und im Hauptzweig überprüft, wenn der Vorgang abgeschlossen ist. Einige Entwickler neigen dazu, im Geheimen zu arbeiten. Nach einer Woche finden sie Code, der möglicherweise die Überprüfung aufgrund grundlegender Probleme, die früher hätten entdeckt werden können, nicht besteht.

• Überprüfung bei jedem Check-in, was regelmäßige Überprüfungen garantiert. Einige Entwickler sind vergesslich und verlassen sich auf sehr häufige Eincheckvorgänge, was bedeutet, dass andere alle 15 Minuten Codeüberprüfungen durchführen müssen.

• Überprüfung zu einem nicht festgelegten Zeitpunkt nach dem Check-in. Überprüfungen werden weiter hinausgeschoben, wenn eine Fristüberschreitung eintritt. Code, der von bereits festgeschriebenem, aber noch nicht geprüftem Code abhängt, wird festgeschrieben. Überprüfungen kennzeichnen Probleme, und die Probleme werden in den Rückstand aufgenommen, um "später" behoben zu werden. Ok, ich habe gelogen: Dies ist keine einfache Lösung, es ist überhaupt keine Lösung. Die Überprüfung erfolgt zu einem bestimmten Zeitpunkt nach dem Einchecken, ist jedoch weniger einfach, da Sie entscheiden müssen, wie viel Uhr diese Zeit ist

In der Praxis machen Sie diese Arbeit noch einfacher und gleichzeitig komplexer. Sie legen einfache Richtlinien fest und lassen jedes Entwicklungsteam als Team herausfinden, was es tun muss, um diese Richtlinien zu befolgen. Ein Beispiel für solche Richtlinien ist:

• Die Arbeit gliedert sich in Aufgaben, die weniger als einen Tag dauern sollten.
• Eine Aufgabe ist nicht abgeschlossen, wenn der Code (falls vorhanden) nicht eingecheckt wurde.
• Eine Aufgabe ist nicht abgeschlossen, wenn der Code (falls vorhanden) nicht überprüft wurde.

Viele alternative Formen solcher Richtlinien sind möglich. Konzentrieren Sie sich auf das, was Sie wirklich wollen (Peer-Review-Code, beobachtbarer Arbeitsfortschritt, Verantwortlichkeit) und lassen Sie das Team herausfinden, wie es Ihnen geben kann, was es will.

Wir machen tatsächlich einen Hybrid auf LedgerSMB. Committer schreiben Änderungen fest, die anschließend überprüft werden. Nicht-Versender übermitteln Änderungen an Versender, die zuvor überprüft werden sollen. Dies bedeutet in der Regel zwei Überprüfungsebenen. Zuerst lassen Sie sich von einem Mentor überprüfen und betreuen. Dann lässt der Mentor den Code ein zweites Mal überprüfen, nachdem er ihn abgemeldet hat und Feedback zirkuliert. Neue Committer verbringen in der Regel viel Zeit damit, die Commits anderer zu überprüfen.

Es funktioniert ziemlich gut Die Sache ist jedoch, dass ein Review danach in der Regel kürzer ist als ein Review davor. Sie möchten also sicherstellen, dass ein Review danach für diejenigen reserviert ist, die sich bewährt haben. Aber wenn Sie eine zweistufige Überprüfung für die neuen Leute haben, bedeutet dies, dass Probleme wahrscheinlicher aufgefangen werden und Diskussionen geführt haben.

Festschreiben wo? Es gibt einen Zweig, den ich geschaffen habe, um etwas zu arbeiten. Ich verpflichte mich zu diesem Zweig, wann immer ich Lust dazu habe. Es geht niemanden etwas an. Dann wird dieser Zweig irgendwann in einen Entwicklungszweig integriert. Und irgendwo dazwischen liegt eine Codeüberprüfung.

Der Rezensent überprüft offensichtlich, nachdem ich mich zu meiner Filiale verpflichtet habe. Er sitzt nicht an meinem Schreibtisch und kann es nicht überprüfen, bevor ich mich zu meiner Filiale begebe. Und er prüft vor dem Zusammenschluss und verpflichtet sich zur Entwicklungsabteilung.

Führen Sie einfach überhaupt keine Code-Überprüfungen durch. Entweder glauben Sie, dass Ihre Entwickler in der Lage sind, guten Code zu schreiben, oder Sie sollten sie loswerden. Fehler in der Logik sollten von Ihren automatisierten Tests abgefangen werden. Fehler sollten mit fusselfreien und statischen Analysewerkzeugen aufgefangen werden.

Es ist einfach verschwenderisch, wenn Menschen an automatischen Prozessen beteiligt sind.