Wann sind Codeüberprüfungen bei der kontinuierlichen Integration durchzuführen?

Wir versuchen, auf eine kontinuierliche Integrationsumgebung umzusteigen, sind uns jedoch nicht sicher, wann Codeüberprüfungen durchgeführt werden sollen. Nach dem, was ich über die kontinuierliche Integration gelesen habe, sollten wir versuchen, Code mehrmals am Tag einzuchecken. Ich gehe mal davon aus, dass dies sogar für Features bedeutet, die noch nicht vollständig sind.

Die Frage ist also, wann wir die Codeüberprüfungen durchführen.

Wir können es nicht tun, bevor wir den Code eingecheckt haben, da dies den Prozess verlangsamen würde, bei dem wir keine täglichen Checkins durchführen können, geschweige denn mehrere Checkins pro Tag.

Wenn der Code, den wir einchecken, nur kompiliert, aber nicht vollständig ist, ist eine Codeüberprüfung sinnlos, da die meisten Codeüberprüfungen am besten durchgeführt werden, wenn die Funktion abgeschlossen ist. Bedeutet dies, dass wir Codeüberprüfungen durchführen sollten, wenn eine Funktion abgeschlossen ist, der nicht überprüfte Code jedoch in das Repository gelangt?

IMO, Sie sollten den Code überprüfen, bevor er in der Hauptzeile veröffentlicht wird, damit die Hauptzeile immer nur den Code mit der höchsten Qualität enthält.

OTOH, ein guter Punkt könnte lauten: "Warum sollten Sie nachprüfen, ob die CI-Testautomatisierung noch nicht ausgeführt wurde?". Daher ist es möglicherweise am besten, den Entwicklern eine private Zweigstelle zu geben, die der CI-Server für sie erstellt und testet . Auf diese Weise wird zunächst ein Commit und ein Push-Vorgang ausgeführt. Sobald der Vorgang abgeschlossen ist, wird er überprüft und anschließend zur Hauptzeile zusammengeführt (wo er erneut über den CI-Server ausgeführt wird).

Sie sollten auf jeden Fall nicht vollständigen Code überprüfen, um sicherzustellen, dass ein Gerüst für zukünftige Features vorhanden ist, oder zumindest, dass nichts hinzugefügt wird, das die Implementierung dieser zukünftigen Features verhindern würde.

Beachten Sie auch, dass Codeüberprüfungen nicht langsam oder synchron sein müssen - ein Tool wie gerrit oder reviewboard oder ähnliches kann sie asynchron und ziemlich schmerzlos machen.

(Vollständige Offenlegung: Ich habe für SmartBear gearbeitet, Hersteller von Code Collaborator, einem Tool zur Codeüberprüfung.)

Paarprogrammierung einrichten?

Der gesamte Code wird während der Eingabe überprüft, ohne den Prozess zu erweitern oder einen weiteren Schritt einzuführen.

Hier ist der Auszug aus dem Continuous Delivery-Autor:

Jez Humble schreibt als:

Ich schreibe gerade einen Blogbeitrag zu diesem Thema. Die kurze Antwort lautet:

• Der beste Weg, um den Code zu überprüfen, ist die Paarprogrammierung
• Es ist keine gute Idee, die Zusammenführung mit der Hauptleitung zu verknüpfen, indem Sie beispielsweise eine separate Zweigstelle für einen formellen Überprüfungsprozess erstellen. Dies verhindert eine kontinuierliche Integration (der beste Weg, um das Risiko von schlechten Änderungen zu verringern, was Sie wirklich anstreben).
• Ich denke, Gerrit ist ein nettes Tool, aber es sollte nach dem Einchecken verwendet werden (tatsächlich ist es so gestaltet). Ein Teil der Aufgabe der leitenden Entwickler besteht darin, alle Eincheckvorgänge zu überprüfen. Sie könnten beispielsweise einen Feed abonnieren.

Zusammenfassend: Code Review ist gut. So gut, wir sollten es kontinuierlich tun, durch Pair Programming und Reviewing Commits. Wenn ein älterer Entwickler ein schlechtes Commit findet, sollte er sich mit der Person paaren, die es begangen hat, um das Problem zu beheben.

Das Zusammenführen mit dem Hauptteil einer formalen Überprüfung ist schlecht, und das Erstellen von Verzweigungen zu diesem Zweck ist besonders schlecht, aus dem gleichen Grund, aus dem Verzweigungen mit Features schlecht sind.

Vielen Dank,

Jez.

Der ursprüngliche Link lautet: https://groups.google.com/forum/#!msg/continuousdelivery/LIJ1nva9Oas/y3sAaMtibGAJ

Ich weiß nicht, ob es der beste Weg ist, es zu tun ... aber ich werde erklären, wie wir es tun. Ein oder mehrere Entwickler arbeiten an einer bestimmten Verzweigung und schreiben ihren Code so oft wie möglich fest, um keine Zeit für das Zusammenführen zu verschwenden, die sonst nicht passiert wäre. Erst wenn der Code fertig ist, wird er in den Kopf geschrieben. Nun, das ist für die Commits und Branch / Head-Sache.

Für die Codeüberprüfung verwenden wir Sonar als unser kontinuierliches Integrationstool (und Maven / Jenkins für die Interaktion mit Sonar), um uns jeden Morgen frische Testergebnisse, Codeabdeckung und automatische Codeüberprüfung bereitzustellen (Builds werden jeden Abend durchgeführt) Entwickler können jeden Morgen maximal eine Stunde damit verbringen, ihre Probleme / Code-Gerüche zu beheben. Jeder Entwickler übernimmt die Verantwortung (auch stolz!) Für das Feature, das er schreibt. Nun, das ist eine automatische Codeüberprüfung, mit der potenzielle technische / architektonische Probleme erkannt werden können. Wichtiger ist jedoch, zu testen, ob diese neu implementierten Funktionen das tun, was das Unternehmen von ihnen erwartet.

Und dafür gibt es zwei Dinge: Integrationstests und Peer Code Review. Integrationstests helfen dabei, einigermaßen sicher zu sein, dass der neue Code den vorhandenen Code nicht beschädigt. Die Überprüfung des Peer-Codes machen wir am Freitagnachmittag, was eine etwas lockere Zeit dafür ist :-) Jeder Entwickler ist einer Branche zugeordnet, an der er nicht arbeitet neue Funktion zuerst und prüft dann, was getan wurde. Seine wichtigste Aufgabe ist es, sicherzustellen, dass der neue Code den Anforderungen entsprechend wie erwartet funktioniert, nicht gegen unsere eigenen "Regeln" verstößt (verwenden Sie dieses Objekt dafür und nicht dieses), einfach zu lesen ist und dies zulässt einfache erweiterung.

Wir haben also zwei Codeüberprüfungen, eine automatische und eine "menschliche", und wir versuchen zu vermeiden, dass nicht überprüften Code in den HEAD-Zweig geschrieben wird. Jetzt ... Es kommt manchmal aus verschiedenen Gründen vor, wir sind alles andere als perfekt, aber wir versuchen, ein faires Gleichgewicht zwischen Qualität und Kosten (Zeit!) Zu halten.

@pjz bietet ebenfalls eine gute Antwort und er erwähnt Tools zur Codeüberprüfung. Ich habe noch keine verwendet, daher kann ich nichts dazu sagen ... obwohl ich in der Vergangenheit versucht war, mit Crucible zu arbeiten, da wir JIRA bereits verwenden .

Ich denke, das Hauptkonzept, das dabei helfen wird, ist das eines "Staging" -Bereichs.

Ja, Sie möchten keinen fehlerhaften Code einchecken. Sie sollten jedoch auch häufig Code einchecken. Bedeutet dies Perfektion? ;) Nein. Verwende einfach mehrere Bereiche und ein DVCS-ähnliches Git.
Auf diese Weise nehmen Sie (lokal) Änderungen vor und schreiben diese regelmäßig fest, während Sie testen und entwickeln, bis die Tests bestanden sind. Dann drücken Sie auf einen Staging-Bereich, um den Code zu überprüfen.

Sie sollten dann von Staging auf andere Qualitätssicherungsmaßnahmen wie Browsertests und Benutzertests umsteigen. Schließlich können Sie zu einem Volumentestbereich gehen und schließlich produzieren.

Es gibt auch Workflows in diesem Bereich, z. B. alle, die in der Hauptniederlassung arbeiten oder einzelne Niederlassungen für alle Aufgaben verwenden.

Die kontinuierliche Integration selbst kann auch auf mehreren Ebenen erfolgen. Es kann lokal für einen Entwicklerrechner sein, bis die Tests bestanden sind, und es kann sich auch in Staging- und QA-Bereichen befinden, wenn Code an ihn gesendet wird.

Codeüberprüfung und kontinuierliche Integration entkoppeln!

Warum hast du sie kombiniert?

Wir verwenden Git Flow für unsere Repositorys und führen unsere Codeüberprüfungen durch, wenn es um das Zusammenführen in den Entwicklungszweig geht.

Alles, was sich in der Entwicklung befindet, ist vollständig, bereitstellbar und der Code wird überprüft.

Wir haben auch CI für unsere Entwicklungs- und Masterzweige eingerichtet.

Ich denke wirklich, dass Sie ein DVCS (zB mercurial, git) brauchen würden, um dies natürlich zu tun. Mit einem CVCS bräuchten Sie einen Zweig und hoffen, dass es für jeden Gott, den Sie haben, keine Hölle gibt.

Wenn Sie ein DVCS verwenden, können Sie den Integrationsprozess so einteilen, dass der Code bereits überprüft wird, bevor er auf dem CI-Server eingeht. Wenn Sie über kein DVCS verfügen, wird der Code vor der Überprüfung auf Ihrem CI-Server eingehen, es sei denn, die Codeüberprüfer überprüfen den Code auf dem Computer jedes Entwicklers, bevor sie ihre Änderungen übermitteln.

Eine erste Möglichkeit, dies zu tun, besteht darin, hierarchische Integrationsrollen zu haben, insbesondere wenn Sie keine Repository-Verwaltungssoftware haben, mit deren Hilfe Sie persönliche Repositorys (z. B. Bitbucket, Github, Rhodecode) veröffentlichen können. In den folgenden Diagrammen können Sie Leutnants die Arbeit der Entwickler überprüfen lassen und den Diktator als Hauptintegrator überprüfen lassen, wie Leutnants die Arbeit zusammengeführt haben.

Wenn Sie über eine Repository-Verwaltungssoftware verfügen, können Sie auch einen Workflow wie den folgenden verwenden:

Repository-Verwaltungssoftware hilft in der Regel dabei, Benachrichtigungen zu senden, wenn in Repositorys Aktivitäten auftreten (z. B. E-Mail, RSS), und Pull-Anforderungen zuzulassen . Die Codeüberprüfung kann organisch während Pull-Anforderungen erfolgen, da Pull-Anforderungen in der Regel dazu führen, dass Personen Gespräche führen, um den Code zu integrieren. Nehmen Sie diese öffentliche Pull-Anfrage als Beispiel. Der Integrationsmanager kann tatsächlich nicht zulassen, dass Code in das gesegnete Repository (auch als "zentrales Repository" bezeichnet) gelangt, wenn der Code korrigiert werden muss.

Am wichtigsten ist, dass Sie mit einem DVCS immer noch einen zentralisierten Workflow unterstützen können. Sie müssen keinen weiteren fantastischen Workflow haben, wenn Sie nicht möchten. Mit einem DVCS können Sie jedoch ein zentrales Entwicklungs-Repository vom CI trennen Server und erteilen Sie jemandem die Berechtigung, die Änderungen vom Dev-Repo zum CI-Repo zu übertragen, sobald eine Code-Überprüfungssitzung durchgeführt wurde .

PS: Gutschrift für die Bilder gehen zu git-scm.com

Warum nicht mehr als ein Repository haben? Eine für die "tägliche" Arbeit, den Betrieb eines Continuous-Integration-Servers, die Durchführung aller Unit-Tests und Integrationstests, um die schöne enge Rückkopplungsschleife zu erhalten, und eine andere für die "stabile" Arbeit, bei der Commits weniger häufig sind, jedoch einer Überprüfung unterzogen werden müssen.

Abhängig von dem Pfad, den Änderungen einschlagen, wenn sie sich durch das System bewegen, kann dies eine komplexe Lösung sein und funktioniert möglicherweise am besten, wenn Tools wie Git oder Mercurial Queues verwendet werden. Aber viele Organisationen tun etwas Ähnliches.

Bedeutet dies, dass wir Codeüberprüfungen durchführen sollten, wenn eine Funktion abgeschlossen ist, der nicht überprüfte Code jedoch in das Repository gelangt?

Weit oben ist die Art, wie ich es in mindestens drei Projekten gesehen habe, die sich intensiv mit kontinuierlicher Integration befassten, und meiner Erinnerung nach hat es wie ein Zauber funktioniert. Diese Vorgehensweise wird als Codeüberprüfung nach dem Festschreiben bezeichnet. Suchen Sie im Web nach diesem Begriff, wenn Sie an Details interessiert sind.

• ^{Andererseits war der einzige Fall, in dem ich in einem Projekt versucht habe, Pre-Commit- Code-Reviews mit CI zu "heiraten" , ziemlich schmerzhaft. Nun, wenn die Dinge zu 100% reibungslos liefen, war es in Ordnung - aber selbst seltene Unterbrechungen (wie wenn Haupt- und Backup-Reviewer beispielsweise einige Stunden nicht verfügbar waren) machten sich bemerkbar. Mir ist auch aufgefallen, dass die Moral der Teams etwas gelitten hat - es gab ein bisschen zu viele Konflikte.}

Zunächst sollten wir das Konzept der "kontinuierlichen Integration" klarstellen. Bei herkömmlichen Entwicklungsmethoden bedeutet kontinuierliche Integration, dass wir unser Quellcode-Repository jeden Tag integrieren und aufbauen können, um die Fallstricke der "Integrationshölle" zu vermeiden. Die Codeüberprüfungen liegen immer zwischen dem Zeitraum der Codierung und der Einzelprüfung. Wir müssen garantieren, dass der Code, der in den Zweig einfügt, fehlerfrei kompiliert werden kann. Es kommt selten vor, dass Teile des Features in der Verzweigung zusammengeführt werden, da es schwierig ist, die Kohärenz von Schnittstellen- und Kompilierungsfehlern zu handhaben.

Continuous Integration ist im Extreme Programming-Prozess sehr beliebt. Die testgetriebene Entwicklung fügt die Paarprogrammierung hinzu, die Teil eines Codeüberprüfungsprozesses ist, sodass die kontinuierliche Integration einfach zu implementieren ist. Extreme Programming selbst ist ein kontinuierlicher Codeüberprüfungs- und Integrationsprozess. Die Code Reviews gibt es überall.

In einigen Open-Source-Communities werden die Codeüberprüfungen unmittelbar vor dem Zusammenführen des Codes mit dem Zweig ausgeführt. Es sind immer die erfahrensten Personen in diesem Team, die die Codeüberprüfungen durchführen und entscheiden, ob der Code zur Hauptniederlassung zusammengeführt werden kann. Auf diese Weise ist die Dauer der kontinuierlichen Integration etwas länger, die Codequalität jedoch etwas besser.

Kehren Sie zur Frage zurück. Es gibt keine Standardantwort für die Durchführung von Codeüberprüfungen. Dies hängt von Ihrem ursprünglichen Entwicklungsprozess und der tatsächlichen Implementierung Ihrer kontinuierlichen Integration ab.