Was tun Sie, wenn die Codeüberprüfung einfach zu schwierig ist?

OK, viele Codeüberprüfungen sind ziemlich routinemäßig. Gelegentlich gibt es jedoch Änderungen, die sich weitgehend auf vorhandenen komplexen, fragilen Code auswirken. In dieser Situation ist der Zeitaufwand für die Überprüfung der Sicherheit der Änderungen, das Fehlen einer Regression usw. zu hoch. Vielleicht sogar länger als nötig, um die Entwicklung selbst durchzuführen.

Was ist in dieser Situation zu tun? Zusammenführen und hoffen, dass nichts durchrutscht? (Nicht befürworten!) Tun Sie das Beste, was Sie können, und versuchen Sie nur, offensichtliche Fehler zu entdecken (vielleicht ist dies die am meisten angestrebte Code-Überprüfung?).

Hierbei handelt es sich nicht speziell um eine Frage, ob das Testen im Rahmen einer Codeüberprüfung erfolgen soll. Hier stellt sich die Frage, welche Optionen in der beschriebenen Situation am besten geeignet sind, insbesondere wenn eine dringende Frist gilt, keine umfassende Suite von Komponententests verfügbar ist oder Komponententests für den fragmentierten Code, der geändert wurde, nicht durchführbar sind.

BEARBEITEN: Ich habe den Eindruck, dass einige der bisherigen Antworten / Kommentare meine Formulierung "weit gefasst" aufgegriffen haben, und dies möglicherweise so aufgefasst, dass die Änderung eine große Anzahl von Codezeilen umfasst. Ich kann verstehen, dass dies die Interpretation ist, aber das war nicht wirklich meine Absicht. Mit "allgemeiner Auswirkung" meine ich zum Beispiel, dass das Regressionspotential aufgrund der Vernetzung der Codebasis oder des Umfangs der Folgewirkungen hoch ist, nicht unbedingt, dass die Änderung selbst eine große ist. Beispielsweise kann ein Entwickler einen Weg finden, einen Fehler mit einer einzelnen Zeile zu beheben, indem er eine vorhandene Routine auf hoher Ebene aufruft, die Aufrufe an viele Routinen auf niedrigerer Ebene kaskadiert. Das Testen und Überprüfen der Fehlerbehebung ist einfach. Das manuelle Validieren (über die Codeüberprüfung) der Auswirkungen aller Auswirkungen ist viel schwieriger.

Die Prämisse der Frage ist ehrlich gesagt erstaunlich. Wir nehmen an, dass sich der fragile, komplexe Code stark verändert und dass einfach nicht genügend Zeit vorhanden ist, um ihn ordnungsgemäß zu überprüfen . Dies ist der letzte Code , den Sie verbringen sollte weniger auf die Überprüfung der Zeit! Diese Frage weist darauf hin, dass Sie strukturelle Probleme nicht nur im Code selbst, sondern auch in Ihrer Methodik zur Verwaltung von Änderungen haben.

Wie soll man mit dieser Situation umgehen? Beginnen Sie damit, dass Sie nicht gleich darauf eingehen:

• Identifizieren Sie Ursachen für Komplexität und wenden Sie sorgfältige, gründlich überprüfte und korrekte Refactorings an, um den Abstraktionsgrad zu erhöhen. Der Code sollte für einen neuen College-Mitarbeiter verständlich sein, der etwas über Ihre Geschäftsdomäne weiß.

• Quellen der Fragilität identifizieren; Dies kann durch Überprüfung des Codes selbst, durch Überprüfung des Verlaufs von Fehlerkorrekturen des Codes usw. geschehen. Bestimmen Sie, welche Subsysteme anfällig sind, und machen Sie sie robuster . Fügen Sie Debugging-Logik hinzu. Behauptungen hinzufügen. Erstellen Sie eine langsame, aber offensichtlich korrekte Implementierung desselben Algorithmus und führen Sie in Ihrem Debug-Build beide aus und überprüfen Sie, ob sie übereinstimmen. Führen Sie in Ihrem Debug-Build dazu, dass seltene Situationen häufiger auftreten. (Erstellen Sie beispielsweise einen Speicherzuordner, der einen Block bei der Neuzuweisung immer verschiebt, oder ordnen Sie einen Block immer am Ende einer Seite zu, oder was auch immer.) Machen Sie den Code robust, wenn sich der Kontext ändert. Jetzt haben Sie keinen fragilen Code mehr. Jetzt haben Sie Code, der die Fehler findet, anstatt sie zu verursachen.

• Schreiben Sie eine Reihe automatisierter Tests. Offensichtlich.

• Nehmen Sie keine umfassenden Änderungen vor. Nehmen Sie eine Reihe kleiner, gezielter Änderungen vor, von denen jede als richtig angesehen werden kann.

Grundsätzlich lautet Ihr Szenario jedoch: "Wir haben uns in ein Loch technischer Schulden gegraben, und jede komplexe, nicht überprüfte Veränderung gräbt uns tiefer ein. Was sollen wir tun?" Was machst du, wenn du in diesem Loch bist? Hör auf zu graben . Wenn Sie so viel Schulden haben, dass Sie nicht in der Lage sind, grundlegende Aufgaben wie das Überprüfen des Codes des jeweils anderen zu erledigen, müssen Sie aufhören, mehr Schulden zu machen, und Zeit damit verbringen, diese zu tilgen.

Eines der Hauptziele einer Codeüberprüfung ist es, die Qualität zu verbessern und robusten Code zu liefern . Robust, da 4 Augen normalerweise mehr Probleme als 2 erkennen. Und der Prüfer, der den zusätzlichen Code nicht geschrieben hat, wird mit größerer Wahrscheinlichkeit (möglicherweise falsche) Annahmen in Frage stellen.

Das Vermeiden von Peer Reviews würde in Ihrem Fall nur dazu beitragen, die Fragilität Ihres Codes zu erhöhen. Selbstverständlich könnte eine Verstärkung der Tests mit einer soliden und wiederholbaren Testsuite die Qualität verbessern. Sie sollte jedoch die Peer Review ergänzen und nicht ersetzen .

Ich denke, dass Komplexität verstanden und gemeistert werden muss, und die vollständige Begutachtung durch Fachkollegen ist die Gelegenheit, Wissen auszutauschen und dies zu erreichen. Die Investition, die Sie tätigen, damit mehr Menschen die Stärken und Schwächen des fragilen Codes verstehen, trägt dazu bei, ihn im Laufe der Zeit zu verbessern.

Ein Zitat zum Abschluss:

"Wenn du schnell gehen willst, geh allein. Wenn du weit gehen willst, geh zusammen"

Willkommen in der Welt der Legacy-Softwareentwicklung.

Sie haben Hunderttausende, Millionen, Zehntausende von Codezeilen.

Diese Codezeilen sind insofern wertvoll, als sie eine Einnahmequelle darstellen und durch nichts zu ersetzen sind.

Ihr Geschäftsmodell basiert auf der Nutzung dieser Codebasis. Ihr Team ist also klein, die Codebasis ist groß. Das Hinzufügen von Funktionen ist erforderlich, um Benutzer zum Kauf einer neuen Version Ihres Codes oder zur Zufriedenheit bestehender Kunden zu bewegen.

In einer perfekten Welt ist Ihre riesige Codebasis bis zum Wazoo einheitentestet. Du lebst nicht in einer perfekten Welt.

In einer weniger perfekten Welt haben Sie das Budget, um Ihre technischen Schulden zu beheben - zerlegen Sie Ihren Code in testbare Einheiten, führen Sie aufwändige Integrationstests durch und wiederholen Sie diese.

Dies zahlt jedoch Schulden ab, ohne neue Funktionen hervorzubringen. Das passt nicht zum Business Case "Profitieren Sie von vorhandenem Code, indem Sie ihn modifizieren, um einen Anreiz für ein Upgrade zu schaffen".

Sie könnten große Codestücke nehmen und sie mit moderneren Techniken neu schreiben. Aber überall, wo Sie mit dem vorhandenen Code interagieren, werden Sie mögliche Haltepunkte anzeigen. Dieser Hack in dem System, den Sie losgeworden sind, hat tatsächlich eine Eigenart in einem Subsystem kompensiert, das Sie nicht neu geschrieben haben. Immer.

Was Sie tun können , ist vorsichtig zu handeln. Sie können einen Teil des Codes finden, den Sie tatsächlich verstehen und dessen Verhalten und Interaktion mit dem Rest des Systems gut verstanden ist. Sie können dies modernisieren, indem Sie Komponententests hinzufügen und das Verhalten noch klarer gestalten.

Suchen Sie dann die Teile der restlichen App, die hauptsächlich damit interagieren, und greifen Sie sie nacheinander an.

Auf diese Weise können Sie das Subsystem verbessern und Funktionen hinzufügen, für die die Kunden bereit sind, zu zahlen.

Kurz gesagt, dies ist die Kunst des Möglichen - Änderungen vorzunehmen, ohne Dinge zu beschädigen, die einen Geschäftsfall darstellen.

Aber das ist nicht deine Frage. Ihre Frage lautet: "Ich mache etwas, das riesig ist und wahrscheinlich Dinge kaputt macht, und wie befolge ich Best Practices?"

Wenn Sie etwas Großes tun, müssen Sie sich mehr Mühe geben, um Fehler aufzuspüren und zu beheben, als wenn Sie es schreiben. Dies ist die allgemeine Regel bei der Softwareentwicklung: Es ist einfach, Dinge zu schreiben, und es ist schwierig, sie fehlerfrei zu machen.

Wahrscheinlich hängt Ihnen ein Geschäftsfall über den Kopf, in dem Sie einem Stakeholder versprochen haben, dass diese massive Änderung eintritt. Und es ist "erledigt", sodass Sie zurückgeschubst werden, wenn Sie sagen: "Nein, das ist nicht erledigt, es sieht einfach so aus." mag ich".

Wenn Sie die Macht und das Budget haben, geben Sie tatsächlich die Mühe, Vertrauen zu schaffen, dass die Änderung funktioniert, oder lehnen Sie die Änderung einfach ab. Dies wird eine Frage des Grades sein, nicht der Art.

Wenn Sie nicht über so viel Leistung verfügen, aber dennoch einige haben, sollten Sie darauf bestehen, dass das neue System für Einheiten testbar ist . Wenn Sie ein Subsystem neu schreiben, bestehen Sie darauf, dass das neue Subsystem aus kleinen Teilen mit genau festgelegten Verhaltensweisen und Komponententests besteht.

Dann ist da noch der schlimmste Fall. Sie gehen tiefer in die Verschuldung. Sie leihen sich etwas gegen die Zukunft des Programms aus, indem Sie mehr Code haben, der zerbrechlich und fehleranfällig ist, um das Feature jetzt herauszubekommen und die Konsequenzen zu verdammen. Sie führen eine durchlaufbasierte Qualitätssicherung durch, um die schlimmsten Probleme zu finden, und ignorieren den Rest. Dies ist tatsächlich manchmal die richtige Antwort aus Sicht des Geschäfts, da es jetzt am billigsten ist. Verschuldung zur Erzielung von Gewinnen ist eine gültige Geschäftsstrategie, insbesondere wenn die Tilgung der Schulden durch Insolvenz (Aufgeben des Codes) auf dem Tisch liegt.

Ein großes Problem ist, dass die Anreize der Firmeninhaber selten auf die Entscheidungsträger und Programmierer abgestimmt sind. Es besteht tendenziell ein großer Druck zu „liefern“, und dies zu tun, indem nahezu unsichtbare (für Ihre Vorgesetzten) technische Schulden generiert werden, ist eine große kurz- und manchmal mittelfristige Strategie. Selbst wenn Ihre Vorgesetzten / Stakeholder am besten bedient würden, wenn Sie nicht all diese Schulden machen würden.

Lösen Sie die größeren Probleme, bei denen die Codeüberprüfung zu schwierig ist.

Diejenigen, die ich bisher gesehen habe:

1. Keine Unit-Testsuite
2. Komplexe Code-Zusammenführungen, die durch eine sinnvollere Codestruktur und Delegation von Codierungsaufgaben vermieden werden könnten
3. Ein offensichtlicher Mangel an rudimentärer Architektur

1. Sie können die Codeüberprüfung zurücksenden und den Entwickler anweisen, sie in kleinere, inkrementellere Änderungsmengen aufzuteilen und eine kleinere Codeüberprüfung einzureichen.

2. Sie können weiterhin nach Code-Gerüchen, Mustern und Anti-Mustern, Code-Formatierungsstandards, SOLID-Prinzipien usw. suchen, ohne unbedingt jedes Detail des Codes durchgehen zu müssen.

3. Sie können weiterhin taktische Codeüberprüfungen für eine ordnungsgemäße Eingabeüberprüfung, Sperren / Thread-Verwaltung, mögliche nicht behandelte Ausnahmen usw. auf detaillierter Ebene durchführen, ohne unbedingt die allgemeine Absicht des gesamten Änderungssatzes zu verstehen.

4. Sie können eine Bewertung der allgemeinen Risikobereiche vorlegen, von denen Sie wissen, dass sie möglicherweise vom Code betroffen sind, und den Entwickler bitten, zu bestätigen, dass diese Risikobereiche einem Komponententest unterzogen wurden ).

In dieser Situation ist der Zeitaufwand für die Überprüfung der Sicherheit der Änderungen, das Fehlen einer Regression usw. zu hoch.

Code Reviews sollten nicht primär auf Korrektheit ausgerichtet sein. Sie dienen dazu, die Lesbarkeit des Codes, die Wartbarkeit und die Einhaltung der Teamstandards zu verbessern.

Das Auffinden von Korrektheitsfehlern während einer Codeüberprüfung ist ein nettes Nebenprodukt, aber ein Entwickler sollte sicherstellen, dass der Code einwandfrei funktioniert (einschließlich Nichtregression), bevor er zur Überprüfung eingereicht wird .

Korrektheit sollte von Anfang an eingebaut werden. Wenn ein Entwickler dies nicht erreichen kann, lassen Sie ihn das Programm koppeln oder einen Plan mit dem gesamten Team ausarbeiten, aber behandeln Sie ihn nicht als etwas, das Sie nachträglich hinzufügen können.

Wenn Sie der Meinung sind, dass die Codeüberprüfung zu schwierig ist, weil sich der spröde Code geändert hat, der fast unmöglich zu ändern ist, ohne ihn zu beschädigen, haben Sie ein Problem. Das Problem liegt aber nicht bei der Codeüberprüfung. Das Problem liegt auch nicht bei Unit-Tests, da der spröde Code nicht Unit-getestet werden kann! Wenn Ihr Code für Einheiten testbar wäre, wäre er in kleine, unabhängige Einheiten aufgeteilt worden, die getestet werden können und die gut zusammenarbeiten, und genau das haben Sie nicht!

Sie haben also eine Menge Müllcode (auch als "technische Schulden" bekannt). Das Schlimmste, was Sie tun können, ist, den Müllhaufen zu reparieren und den Job nicht zu beenden, da Sie auf diese Weise einen noch größeren Müllhaufen erhalten. Das erste, was Sie tun müssen, ist, Ihr Management dazu zu bringen, es zu reparieren und den Job zu beenden. Oder du nicht. In diesem Fall fasst du es einfach nicht an.

Wenn Sie das Problem beheben, extrahieren Sie eine Einheit aus dem Code, wandeln sie in eine Einheit mit genau definiertem und gut dokumentiertem Verhalten um, schreiben Unit-Tests für diese Einheit, überprüfen den Code und beten, dass nichts kaputt geht. Und dann machst du dasselbe mit der nächsten Einheit und so weiter.

Das Knifflige kommt, wenn Sie auf Fehler stoßen. Das Code-Nest Ihrer Ratten macht in einigen Fällen die falschen Dinge, weil die Dinge so spröde und kompliziert sind, dass etwas schief geht. Wenn Sie Einheiten extrahieren, wird der verbleibende Code klarer. (Ich hatte einen Fall, in dem nach einem Refactoring eine Funktion mit "if (condition1 && condition2 && condition3) crash ();" gestartet wurde, was genau das Verhalten vor dem Refactoring war, nur klarer. Ich habe dann diese Zeile gelöscht :-) Du wirst sehen seltsames und unerwünschtes Verhalten klar, so dass Sie es beheben können. Auf der anderen Seite müssen Sie dort das Verhalten des vorhandenen Codes ändern, sodass dies sorgfältig erfolgen muss.

Leider können Sie zum Zeitpunkt der Codeüberprüfung nicht wirklich viel dagegen tun, außer eine weitere Tasse Kaffee zu sich zu nehmen. Die eigentliche Lösung für dieses Problem besteht darin, die angehäuften technischen Probleme zu lösen: zerbrechliches Design, fehlende Tests. Hoffentlich haben Sie zumindest eine funktionierende Qualitätssicherung. Wenn Sie das nicht haben, beten Sie immer um ein paar Hühnerknochen.

Wenn Sie nicht zufrieden sind mit Buggy / nicht funktionierende Software zu versenden und beheben später dann V & V Anstrengung sollte länger sein als Entwicklungsaufwand!

Wenn vorhandener Code zerbrechlich ist, lautet die erste Frage: "Sollten Sie ihn überhaupt ändern?" Das Management muss sich erkundigen, ob die Kosten / das Risiko für die Neugestaltung und Neuimplementierung dieses Codes höher sind als die Kosten / das Risiko für die Behebung des wackeligen Müllhaufens. Wenn es einmalig ist, kann es einfacher sein, es einfach zu reparieren. Wenn in Zukunft wahrscheinlich mehr Änderungen erforderlich sein werden, ist es möglicherweise eine bessere Entscheidung, den Treffer jetzt zu nehmen, um in Zukunft mehr Schmerzen zu vermeiden. Sie müssen dies mit Ihrem Management besprechen, da es Teil Ihrer Aufgabe ist, Ihren Managern gute Informationen zur Verfügung zu stellen. Sie müssen diese Entscheidung treffen, da es sich um eine strategische Entscheidung handelt, die über Ihrer Verantwortungsebene liegt.

Aus meiner Erfahrung heraus empfehle ich Ihnen dringend, Ihren Code mit einer angemessenen Anzahl von Tests, sowohl in Bezug auf die Einheit als auch auf die Integration, abzudecken, BEVOR Änderungen am betreffenden System vorgenommen werden. Es ist wichtig, sich daran zu erinnern, dass es heutzutage eine sehr gute Anzahl von Werkzeugen für diesen Zweck gibt, unabhängig davon, mit welcher Sprache Sie sich entwickeln.

Außerdem gibt es DAS Tool aller Tools, mit denen Sie Ihre Integrationstests erstellen können. Ja, ich spreche von Containern und speziell von Docker und Docker Compose . Es bietet uns auf wunderbare Weise die Möglichkeit, schnell eine komplexe Anwendungsumgebung mit Infrastruktur (Datenbank, Mongodb, Warteschlangenserver usw.) und Anwendungen einzurichten.

Die Werkzeuge stehen zur Verfügung, nutzen Sie sie! :)

Ich weiß nicht, warum es noch nicht erwähnt wurde, aber diese 2 sind die wichtigsten Stücke:

• Sie haben die Änderungsliste in mehrere kleinere Änderungslisten aufgeteilt, die Sie nacheinander überprüfen. *
• Wenn die Überprüfung einer Änderungsliste nicht zu einer Entscheidung führt, dass die Änderungsliste gut zu sein scheint, lehnen Sie die Änderung offensichtlich ab.

* Beispiel: Sie ersetzen Bibliothek A durch Bibliothek B. Eine Änderungsliste führt Bibliothek B ein, verschiedene Änderungslisten ersetzen Stück für Stück die Verwendung von A durch B (z. B. eine Änderungsliste pro Modul), und die letzte Änderungsliste löscht Bibliothek A.

Tun Sie das Beste, was Sie können, und versuchen Sie nur, offensichtliche Fehler zu entdecken (vielleicht ist dies die Code-Überprüfung, die am meisten zielen sollte)?

Unterschätzen Sie nicht den potenziellen Wert von Code-Revuen. Sie können Fehler gut erkennen:

• Finden Sie Fehler, die beim Testen nur schwer zu erkennen sind
• Finden Sie Fehler, die sich beim Testen nur schwer identifizieren / beheben lassen

Sie sind auch aus anderen Gründen nützlich:

• Helfen Sie dabei, die Mitglieder des Teams zu trainieren
• Stellen Sie sicher, dass der Code anderen Qualitätsmetriken entspricht, z. B., dass er verständlich und wartbar ist und nicht nur fehlerfrei

Was ist in dieser Situation zu tun?

Im besten / idealen Fall bedeutet Codeüberprüfung nicht nur "keine offensichtlichen Fehler": Es bedeutet "offensichtlich keine Fehler" (obwohl Sie es natürlich auch testen möchten).

Wenn Sie die neue Codebasis nicht über die Codeinspektion überprüfen können, müssen Sie eine umfassendere Black-Box-Prüfung durchführen. Sie sind vielleicht an einen Entwicklungszyklus gewöhnt, in dem Sie Code nach bestandener Prüfung in die Produktion einbinden. Wenn er jedoch die Prüfung nicht besteht, können Sie ihn nicht in die Produktion einbinden, und es ist ein längerer Zyklus erforderlich: z. B. Integrationstests , Systemtests, Alphatests, Abnahmetests, Betatests usw.

Keine umfassende Suite von Komponententests verfügbar oder Komponententests für den fragmentierten Code, der geändert wurde, nicht durchführbar

Was ist mit Integrations-, System- und Akzeptanztests?

Auf jeden Fall sollten Sie dem Projektmanager und Produktmanager wahrscheinlich mitteilen, dass der Code mit ziemlicher Sicherheit fehlerhaft ist und eine unbekannte Anzahl von Fehlern aufweist. und dass sie "bekommen, was sie inspizieren" anstatt nur "was sie erwarten" - dh dass die Codequalität nicht besser ist als ihre Tests (weil die Codequalität durch die Code Inspektion nicht garantiert wurde und werden kann) .

Sie sollten diese Nachricht möglicherweise an den Kunden oder die Benutzer weiterleiten, damit sie Betatests durchführen (wenn sie bereit sind, frühzeitig zu übernehmen) oder die ältere Version verwenden, bis die neue Version nicht mehr betatauglich ist (wenn sie es nicht sind).

Es wird viel Code geschrieben und ohne ordnungsgemäße Codeüberprüfung zusammengeführt. Es kann funktionieren. Es gibt einen Grund , warum es Code genannt Geruch nicht „gebrochen Code“ oder etwas in diesem Sinne. Die fehlende Codeüberprüfung ist ein Warnsignal und kein Vorbote des Schicksals.

Die Lösung für dieses Problem ist, dass es keine Lösung für alle Fälle gibt, die wir in eine Antwort im StackExchange-Stil packen können. Es ist der starke Konsens der Softwareentwickler, dass die Codeüberprüfung eine entscheidende "Best Practice" darstellt und in diesem Fall übersprungen wird. Ihre Entwicklung ist nicht mehr in diesem engen Kanal von "Befolgen aller Best Practices". Sie müssen Ihren eigenen Weg finden.

Was ist überhaupt eine "Best Practice"? Wenn man es genau betrachtet, handelt es sich um eine Reihe von Praktiken, von denen die Leute im Allgemeinen denken, dass sie den Code besser machen. Machen sie den Code richtig? Mist nein! Das Internet ist übersät mit Geschichten von Unternehmen, die sich an "Best Practices" orientierten und sich dadurch stauen ließen. Vielleicht ist ein besserer Standpunkt zu "Best Practices", dass es sich um die "fire and forget" -Lösungen der Software-Welt handelt. Ich kann nichts über Ihr Unternehmen, Ihr Projekt, Ihr Team wissen und in der Lage sein, "Best Practices" als Dinge, die Ihnen helfen, abzuspielen. Sie sind die allgemeinen "keinen Schaden anrichten" Ratschläge.

Sie haben deutlich von diesem Plan abgewichen. Zum Glück erkennen Sie es. Gut gemacht! Sie sagen, Wissen ist die halbe Miete; wenn ja, ist das Bewusstsein weit über die Hälfte davon! Jetzt ist eine Lösung erforderlich. Aus Ihrer Beschreibung geht hervor, dass sich das Geschäftsumfeld, in dem Sie sich befinden, zu einem Punkt entwickelt hat, an dem der langweilige Ratschlag "Mach die Codeüberprüfung, es ist die beste Vorgehensweise" nichts mehr ändert. Hierfür empfehle ich eine wichtige Regel, die ich bei den Best Practices für Software verwende:

Kein bewährtes Verfahren für die Softwareentwicklung übertrifft die Anforderungen eines Unternehmens.

Ehrlich gesagt zahlen sie Ihren Gehaltsscheck, und das Überleben des Unternehmens ist in der Regel weitaus wichtiger als die Qualität der Software. Wir geben es nicht gerne zu, aber perfekt geschriebene Software ist nutzlos, wenn sie im Körper eines Unternehmens gefangen ist, das vor den Bemühungen um die Aufrechterhaltung dieser perfekt geschriebenen Software im Sterben liegt.

Also wohin gehst du? Folgen Sie der Spur der Gewalt. Sie haben darauf hingewiesen, dass es aus unerklärlichen Gründen unvernünftig ist, für eine Aufgabe eine Codeüberprüfung durchzuführen. Nach meiner Erfahrung ist dieser Grund immer zeitlich. Es ist immer entweder "nicht genug Zeit" oder "nicht genug Geld, um die Gehälter in Fluss zu halten, während Sie die Zeit verbringen." Das ist Geschäft; es ist in Ordnung. Wenn es einfach wäre, würde es jeder tun. Folgen Sie der Spur der Gewalt nach oben und finden Sie das Management, das in der Lage ist, Ihnen zu helfen, zu verstehen, warum eine Codeüberprüfung keine Option ist. Die Sprache ist schwer, und oft sickert ein Dekret vom oberen Management herunter und wird verzerrt. Die Lösung Ihres Problems liegt möglicherweise in dieser Verzerrung.

Die Antwort darauf ist notwendigerweise ein spezifisches Fallszenario. Es ist vergleichbar mit dem Versuch, vorherzusagen, ob ein Münzwurf Kopf oder Zahl ist. Die Best Practices besagen, dass es 100-mal gekippt werden muss und die Erwartung ungefähr 50 Köpfe und 50 Schwänze beträgt, aber Sie haben keine Zeit, es 1-mal zu kippen. Hier kommt es auf die Details Ihrer Situation an. Wussten Sie, dass eine Münze normalerweise in der gleichen Ausrichtung landet, in der sie in etwa 51% der Fälle geworfen wurde? Haben Sie sich die Zeit genommen, um zu beobachten, in welche Richtung die Münze geworfen wurde? Es könnte einen Unterschied machen.

Eine allgemeine Lösung, die Ihnen zur Verfügung stehen könnte, besteht darin, einen Weg zu finden, um den Codeüberprüfungsprozess zu entwickeln und ihn zu einem sehr geringen Kostenaufwand zu machen. Ein Großteil der Kosten eines Codeüberprüfungsprozesses besteht darin, dass sich jeder zu 100% der Codeüberprüfung widmet, während Sie dies tun. Dies muss der Fall sein, da der Code nach Abschluss der Codeüberprüfung gesegnet ist. Vielleicht können Sie den Code in einen anderen Zweig stellen und die Codeüberprüfung parallel zur Entwicklung auf dem Haupttrunk durchführen. Oder Sie können es sogar so einrichten, dass die Software die Tests für Sie durchführt. Vielleicht befinden Sie sich in einer Geschäftsumgebung, in der Ihre Kunden den "neuen" Code parallel zum alten ausführen und die Ergebnisse vergleichen lassen können. Dies macht die Kunden zu einer Reihe von Anwendungsfallerstellungsgeräten.

Ein Schlüssel zu all diesen laufenden "Maybes" ist, dass Sie sich bemühen sollten, Ihren Code leicht in Teile zu zerlegen. Möglicherweise können Sie Teile des Codes "beweisen", ohne sich auf eine formelle Codeüberprüfung verlassen zu müssen, indem Sie sie in weniger unternehmenskritischen Projekten verwenden. Es ist einfacher, dies zu tun, wenn sich die Änderungen in kleineren Teilen befinden, auch wenn die Gesamtsumme zu groß ist, um von Fachleuten begutachtet zu werden.

Suchen Sie im Allgemeinen nach Lösungen, die spezifisch für Ihr Projekt, Ihr Unternehmen und Ihr Team sind. Die allgemeine Antwort lautete "Best Practices". Da Sie diese nicht verwenden, sollten Sie dieses Mal nach maßgeschneiderten Lösungen für dieses Problem suchen. Das ist Geschäft. Wenn alles so laufen würde, wie wir es uns immer vorgestellt hatten, wäre es viel einfacher, Börsengänge zu bewerten, nicht wahr?

Wenn es schwierig ist, eine Codeüberprüfung zu ersetzen, denken Sie daran, dass es noch nie einen einzigen Code gab, von dem nachgewiesen wurde, dass er in einer Codeüberprüfung funktioniert. * Bei einer Codeüberprüfung können Sie nur auf den Code vertrauen und Korrekturen vornehmen bevor sie zum Problem werden. Diese beiden wertvollen Produkte einer Codeüberprüfung können auf andere Weise erworben werden. Die Codeüberprüfung hat nur einen anerkannten Wert dafür, besonders gut darin zu sein.

* Nun, fast: Der L4-Mikrokern hat vor einiger Zeit eine Codeüberprüfung durch ein automatisiertes Proof-System erhalten, das beweist, dass sein Code genau das tut, was in der Dokumentation angegeben ist, wenn er von einem konformen C ++ - Compiler kompiliert wird.

Wie @EricLippert in seiner ausgezeichneten Antwort hervorhebt, erfordert diese Art der Änderung mehr Aufmerksamkeit und nicht weniger . Wenn Sie feststellen, dass eine Änderung, an der Sie arbeiten, zu einer solchen Änderung führen wird, gibt es einige Strategien, die möglicherweise Abhilfe schaffen:

• Versionskontrolle häufig durchführen. Die Überprüfung kann von Commit zu Commit erfolgen und ist möglicherweise verständlicher, wenn Sie über kleinere Commits verfügen.
• Vergewissern Sie sich, dass Sie die Gründe für jede Änderung so klar wie möglich angeben.
• Wenn überhaupt plausibel, verwenden Sie die Paarprogrammierung für diese Art von Änderung. Wenn Sie drei Augenpaare anstelle von zwei haben, können Sie Probleme vermeiden, die normalerweise übersehen werden, und wenn Sie während der Arbeit ein Paar haben, können Sie die Kommentare zu Code verbessern, von dem Sie dachten, dass er offensichtlich ist, der sich jedoch als weniger offensichtlich herausstellt als Sie dachten, was dem Rezensenten später weiterhelfen wird. Die Hilfe bei (a) der Reduzierung von Fehlern während der Entwicklung und (b) der Verbesserung der Dokumentation kann dazu führen, dass weniger Arbeitsstunden dafür aufgewendet werden, obwohl mehr Personen involviert sind.

Weitere Antworten befassen sich damit, wie Sie zu diesem Punkt gekommen sind. Viele von ihnen machen Vorschläge, um Abhilfe zu schaffen, aber ich möchte meine Antwort einbringen, um die kurze Antwort zu geben.

Was tun, wenn Codeüberprüfungen "zu schwer" sind?

1. Gehen Sie zurück zum Hauptzweig der Codezeile
2. Schreiben Sie Tests für die Funktionalität, die Sie überarbeitet haben (z. B. Funktionstests).
3. Lass die Tests bestehen
4. Füge die Tests in den Code ein, der "schwer zu testen" ist
5. Bestehen die Tests noch?

Ja

Ihre Entwickler waren großartig! Katzen zurück für alle!

(oder für diejenigen, die " Die Simpsons " nicht im US-Fernsehen gesehen haben: Wenn die Tests bestanden sind, überspringen Sie den Versuch, sich die Unterschiede anzuschauen, und lassen Sie sich von dem Entwickler zu einem Rundgang durch die Änderungen führen.)

Nein

Refactoring fortsetzen und Testabdeckung hinzufügen, bis die Tests bestanden sind.

Wie eine Multiplikation ergibt die Codeüberprüfung ein Ergebnis von Null, wenn sie auf Null angewendet wird. In diesem Fall wird der Wert nicht erhöht, in den meisten anderen Fällen jedoch.

Der Code, mit dem Sie arbeiten müssen, ist zu schlecht konzipiert, um von der Codeüberprüfung während der weiteren Entwicklung zu profitieren. Verwenden Sie den Codeüberprüfungsprozess, um ihn umzugestalten oder neu zu entwickeln.

Es kann auch sein, dass der Code noch erträglich ist, aber die Aufgabe nicht gut ist. Es ist zu breit und sollte in kleineren Schritten erfolgen.