Checkliste für Code-Reviews von Redwerk – Alle Schritte enthalten

Haben Sie sich jemals gefragt, ob Ihr IT-Dienstleister gute Arbeit geleistet und eine hochwertige App entwickelt hat? Es ist einfach, dies mit einer unabhängigen Code-Überprüfung zu überprüfen. Code-Reviews, die von externen Experten durchgeführt werden, bieten eine frische und unvoreingenommene Perspektive auf die Qualität Ihres Produkts. Sie prüfen den Code rein nach seinen Verdiensten und decken Probleme auf, die interne Teams möglicherweise übersehen haben.

In diesem Artikel teilen wir unsere umfassende Checkliste für Code-Reviews für ein Web-/SaaS-Projekt, damit Sie jeden Schritt des Code-Review-Prozesses verstehen. Als Softwareentwicklungsunternehmen mit über 19 Jahren Erfahrung haben wir unzählige Code-Reviews als tägliche Praxis und als Teil von Due-Diligence-Prüfungen durchgeführt. Wir haben viel Wissen zu teilen, also los geht’s!

Warum eine Checkliste für Code-Reviews verwenden?

Eine Checkliste für Code-Reviews sorgt für Konsistenz in den Entwicklerteams und unterstützt sowohl erfahrene Entwickler als auch neue Mitglieder, die mit den Best Practices ihrer Programmierrahmenwerke nicht vertraut sind.

Hauptvorteile einer Checkliste für Code-Reviews

• Probleme frühzeitig erkennen: Das frühzeitige Erkennen von Fehlern ist entscheidend für die Softwareverbesserung. Checklisten ermöglichen eine schnelle Erkennung kritischer Probleme und verhindern, dass sie zu größeren Problemen werden.
• Best Practices einhalten: Eine Checkliste hilft Teams, Best Practices einzuhalten, technische Schulden zu reduzieren und Sicherheit, Leistung und Wartbarkeit zu verbessern. Dies hält alle auf Kurs mit den strategischen Zielen.
• Zusammenarbeit fördern: Durch die Festlegung klarer Erwartungen für Code-Diskussionen verbessern Checklisten die Kommunikation, beschleunigen die Problemlösung und erhöhen die Softwarequalität.
• Prozesse optimieren: Die Standardisierung von Reviews reduziert die Zeit, die für Diskussionen über Code-Änderungen aufgewendet wird. Eine klare Checkliste ermöglicht eine schnellere Erkennung von Problemen und optimierte Lösungen, wodurch die Produktivität gesteigert wird.

Wichtige Elemente des Code-Reviews: manuell und automatisiert

Ein umfassendes Code-Review sollte aus zwei Teilen bestehen – manueller und automatisierter Überprüfung. Eine Kombination aus beiden hilft, die höchste Qualität und den größten Nutzen aus Code-Reviews zu erzielen.

Während der manuellen Überprüfung werden die folgenden allgemeinen Aspekte geprüft:

• Architektur
• Code-Stil und Sauberkeit
• Klassen- und Variablennamen
• Unit-Tests
• Dokumentation

Bei der manuellen Überprüfung ist es notwendig, sich auf Best Practices für Code-Reviews zu stützen.

Die automatische Überprüfung verwendet Tools, die helfen, das System auf Schwachstellen, veraltete Bibliotheken und ungenutzten Code zu überprüfen, indem große Datenmengen analysiert werden. Alle durch das Programm gefundenen Metriken müssen sorgfältig beschrieben werden.

Die folgenden Tools können für die automatische Überprüfung verwendet werden:

• Statische Code-Analysetools, um potenzielle Fehler und Sicherheitslücken im Code zu finden
• Code-Abdeckungstools, um zu messen, wie viel Code durch eine Test-Suite ausgeführt wird
• Linters, um Abweichungen von Codierstilregeln zu erkennen
• Testautomatisierungstools, um Tests automatisch auszuführen

Denken Sie daran, dass Automatisierungstools zwar entscheidend zur Unterstützung und Verbesserung professioneller Code-Reviews beitragen, sie jedoch nicht das kritische Denken, das Urteilsvermögen und die Fachexpertise ersetzen können, die menschliche Prüfer in den Prozess einbringen. Jetzt kommen wir zur eigentlichen Code-Review-Vorlage.

Unsere umfassende Checkliste für Code-Reviews

Vorbereitende Schritte

Es gibt mehrere vorbereitende Schritte, die Sie vor der eigentlichen Code-Überprüfung unternehmen sollten. Sie helfen, eine fokussiertere, produktivere und kollaborativere Code-Review-Erfahrung für alle Beteiligten zu gewährleisten.

Projektanforderungen und -ziele:

• Projektunterlagen, einschließlich Anforderungen, Spezifikationen und Entwurfsdokumente lesen
• Die primären Ziele des Code-Reviews verstehen – Sicherheitsprobleme identifizieren, Codequalität verbessern, Einhaltung von Codierstandards sicherstellen oder etwas anderes?
• Herausfinden, ob es spezifische Bereiche oder Bedenken für die Überprüfung gibt

Projektumfang:

• Feststellen, ob die Überprüfung sich auf bestimmte Module, Funktionen oder Funktionalitäten im Code konzentriert
• Bereiche identifizieren, in denen in der Vergangenheit Probleme aufgetreten sind oder technischer Schulden bekannt sind
• Bei Projekten in regulierten Branchen sicherstellen, dass relevante Abschnitte des Codes auf Konformität überprüft werden
• Im Falle von Sicherheitsaudits Komponenten identifizieren, die mit sensiblen Daten umgehen oder für die Systemsicherheit kritisch sind

Umgebungssetup:

• Sicherstellen, dass Sie Zugriff auf den Code, die Testtools und alle relevanten Dokumentationen haben
• Geeignete Tools für den Überprüfungsprozess auswählen, wie Code-Linters, statische Analysetools oder integrierte Entwicklungsumgebungen (IDEs)
• Falls zutreffend, sicherstellen, dass Sie den Code effektiv ausführen und testen können

Architekturüberprüfung

Die Architekturüberprüfung ist ein wesentlicher Bestandteil unserer Code-Review-Checkliste. Sie bewertet, wie der Code den allgemeinen Designprinzipien des Systems und der langfristigen Wartbarkeit entspricht. Das frühe Erkennen von Architekturproblemen verhindert kostspielige Nacharbeiten im späteren Entwicklungsprozess. Es stellt auch sicher, dass das System Wachstum bewältigen und unter verschiedenen Lasten effizient arbeiten kann.

Übereinstimmung mit architektonischen Entscheidungen:

• Prüfen, ob der Code den in den Spezifikationen dokumentierten Systemarchitekturen entspricht
• Überprüfen, ob die gewählten Architekturpatterns für das Problemfeld und die Systemanforderungen geeignet sind

Trennung von Anliegen und Modularität:

• Prüfen, ob der Code in mehrere Schichten wie Geschäftslogik, Datenzugriff und Präsentation unterteilt ist, falls erforderlich
• Prüfen, ob der Code in entsprechende Dateien aufgeteilt ist, z.B. für das Frontend – HTML, JavaScript und CSS
• Überprüfen, ob die Module gut definiert, kohärent und lose gekoppelt sind
• Sicherstellen, dass es keine Anzeichen von Spaghetticode oder eng gekoppelten Komponenten gibt

Objektorientierte Analyse- und Entwurfsprinzipien:

• Prüfen, ob das Single Responsibility Principle (SRP) beachtet wird: Keine mehr als eine Verantwortung sollte in eine einzelne Klasse oder Funktion gelegt werden
• Sicherstellen, dass der Code dem Open-Closed-Prinzip (OCP) entspricht: Beim Hinzufügen neuer Funktionalitäten sollten diese in neuen Klassen und Funktionen geschrieben werden; bestehender Code sollte nicht modifiziert werden
• Prüfen, ob das Liskov Substitution Principle (LSP) beachtet wird: Die Kindklasse sollte das Verhalten (Bedeutung) der Elternklasse nicht ändern; die Kindklasse kann als Ersatz für eine Basisklasse verwendet werden
• Schnittstellensegregation überprüfen: Umfangreiche Schnittstellen sollten in kleinere, funktionsbasierte Schnittstellen aufgeteilt werden. Die Schnittstelle sollte keine Abhängigkeiten (Parameter) enthalten, die für die erwartete Funktionalität nicht erforderlich sind
• Überprüfung der Abhängigkeitsinjektion: Abhängigkeiten sollten nicht hartkodiert, sondern injiziert werden

Beispiel für eine Verletzung des SRP:

public class CustomerManager
{
    public void AddCustomer(Customer customer) { /* Implementation */ }
    public void UpdateCustomer(Customer customer) { /* Implementation */ }
    public Customer GetCustomer(int id) { /* Implementation */ }
    public void SendWelcomeEmail(Customer customer) { /* Implementation */ }
    public void GenerateCustomerReport() { /* Implementation */ }
}

Datenmanagement und -speicherung:

• Überprüfen, ob Tabellen ordnungsgemäß normalisiert sind, um Datenredundanz zu eliminieren, während bei kritischer Leistung Denormalisierung in Betracht gezogen wird
• Prüfen der Implementierung von Datenbankbeschränkungen, Transaktionen und Rücksetzstrategien zur Fehlerbehandlung
• Strategien für Datensicherung und -wiederherstellung überprüfen, um die Haltbarkeit der Daten sicherzustellen
• Prüfen, ob häufig abgefragte Felder indiziert sind, um Suchoperationen zu beschleunigen
• Analysieren, wie sensible Daten gehandhabt werden, einschließlich Verschlüsselung und Zugriffskontrollmechanismen

Integration und Interoperabilität:

• Bewertung des Designs, der Dokumentation und Verwaltung von APIs, um sicherzustellen, dass sie gut definiert sind und eine sichere, zuverlässige Kommunikation ermöglichen
• Überprüfen der Integration mit externen Diensten und Verwaltung externer Abhängigkeiten
• Falls zutreffend, sicherstellen, dass das System Standarddatenformate wie JSON für Webdienste unterstützt
• Bewertung des Einsatzes von Middleware oder Integrationswerkzeugen zur Verbindung unterschiedlicher Systeme

Skalierbarkeit und Leistung:

• Überprüfen, ob die Architektur erwartetes zukünftiges Wachstum in Bezug auf Benutzer, Daten und Transaktionen bewältigen kann
• Sicherstellen, dass die Architektur sowohl vertikal (Hinzufügen von Ressourcen zu einem einzelnen Server) als auch horizontal (Hinzufügen von mehr Servern) skalierbar ist
• Überprüfen, ob ressourcenintensive Operationen in separate Dienste ausgelagert und über Warteschlangen oder andere Mechanismen aufgerufen werden
• Prüfen, ob es möglich ist, separate Dienste auf verschiedene Serverinstanzen zu verschieben und ob es möglich ist, mehrere Instanzen eines Dienstes auszuführen
• Überprüfung von Leistungsoptimierungsstrategien, einschließlich Caching, Lastverteilung und asynchroner Verarbeitung, um sicherzustellen, dass das System Spitzenlasten effizient bewältigen kann
• Überprüfung von Fallback- und Redundanzmechanismen, die darauf ausgelegt sind, die Systemverfügbarkeit und -leistung unter widrigen Bedingungen aufrechtzuerhalten

Sicherheit:

• Analysieren des Sicherheitsrahmens der App, um sicherzustellen, dass er eine gestaffelte Verteidigungsstrategie gegen verschiedene Bedrohungen umfasst
• Überprüfen der Authentifizierungs-, Autorisierungs- und Prüfmechanismen, um deren Robustheit und Einhaltung der Sicherheitsbestimmungen zu bestätigen
• Prüfen der Verschlüsselungsprotokolle und Sicherheitsmaßnahmen für Daten in Bewegung und im Ruhezustand, um deren Eignung zum Schutz sensibler Informationen zu überprüfen

Code-Qualitätsüberprüfung

Als nächstes in unserer Code-Review-Checkliste steht die Bewertung der Code-Qualität hinsichtlich Lesbarkeit, Wartbarkeit, Wiederverwendbarkeit, Zuverlässigkeit und Erweiterbarkeit. Klarer und gut formatierter Code ist leichter zu verstehen und zu warten, was zu weniger Fehlern, schnellerer Entwicklung und reduzierter technischer Verschuldung führt. Ein konsistenter Codierstil fördert auch eine bessere Zusammenarbeit im Team, da jeder leicht mit dem Code der anderen arbeiten kann.

Methoden und Funktionen:

• Überprüfen, ob die Funktionsnamen die Form „ausdrucksverb + objekt“ haben, damit sie prägnant und leicht verständlich sind
• Prüfen, ob die Funktionsnamen alle Aktionen beschreiben, die sie ausführen
• Bewerten, ob die Funktion zu groß ist und ob sie in kleinere Funktionen aufgeteilt werden sollte
• Analysieren, ob die Funktion nur eine Sache tut, diese aber gut (Single Responsibility Principle)

Variablen:

• Überprüfen, ob jede Variable nur ein Ziel hat
• Sicherstellen, dass Variablen gemäß den Konventionen wie camelCase, kebab-case und snake_case benannt sind
• Sicherstellen, dass die Variablennamen die dargestellte Entität vollständig und genau beschreiben
• Sicherstellen, dass die Variablennamen ein Gleichgewicht zwischen ausreichend Informationen und Prägnanz bieten
• Sicherstellen, dass die Variablennamen leicht verständlich machen, welche Art von Daten sie enthalten
• Prüfen, ob es magische Zahlen oder Zeichenketten gibt

Beispiel für magische Zeichenketten:

if (message == "Insufficient funds")
{
    // Handle insufficient funds error
}
else if (message == "Invalid product ID")
{
    // Handle invalid product ID error
}
// ...more logic based on string comparisons

Bedingte Ausdrücke:

• Prüfen, ob komplexe Überprüfungen in logische Funktionsaufrufe umgewandelt werden
• Prüfen, ob die wahrscheinlichsten Fälle zuerst überprüft werden. Werden alle Optionen berücksichtigt?
• Überprüfen, ob es Funktionen gibt, die viele bedingte Ausdrücke enthalten. Gibt es einen guten Grund, sie nicht neu zu gestalten?

Rekursion:

• Überprüfen, ob die rekursive Funktion einen Ausstiegspunkt enthält
• Prüfen, ob der Basisfall leicht verständlich und erkennbar ist. Komplexe Basisfälle können die gesamte Logik verschleiern
• Überprüfen, ob die Rekursionstiefe den durch die Größe des Programmstapels auferlegten Beschränkungen entspricht

Wartbarkeit von Klassen/Strukturen:

• Prüfen, ob alle Datenstrukturen einen zentralen Zweck haben
• Sicherstellen, dass alle Datenstrukturen gut benannt sind und ihre Namen ihren zentralen Zweck beschreiben
• Prüfen, ob alle Datenstrukturen unabhängig von anderen Klassen sind und lose gekoppelt sind
• Überprüfen, ob alle Datenstrukturen nur dann mit anderen Klassen zusammenarbeiten, wenn es unbedingt notwendig ist
• Sicherstellen, dass alle Datenstrukturen ihre Implementierungsdetails so weit wie nötig vor anderen Datenstrukturen verbergen

Wiederverwendbarkeit:

• Sicherstellen, dass der Code dem „Don’t repeat yourself“ (DRY) Prinzip folgt: jedes Wissenselement muss eine einzige, eindeutige, autoritative Darstellung innerhalb eines Programms haben
• Prüfen, ob es doppelten Code gibt, der in eine gemeinsame Methode oder Klasse refaktoriert werden kann
• Überprüfen, ob es Funktionen oder Methoden gibt, die ähnliche Aufgaben ausführen und konsolidiert werden können

Beispiel für Funktionen, die in eine einzelne Methode mit einem zusätzlichen Parameter konsolidiert werden können:

public class CustomerService
{
    public Customer GetCustomerById(int id)
    {
        // Logic to retrieve customer from database by ID
        return customer;
    }

    public Customer GetCustomerByEmail(string email)
    {
        // Logic to retrieve customer from database by email
        return customer;
    }
}

Fehlerbehandlung und Logging:

• Prüfen, ob die Fehlerbehandlungstechnik definiert ist, das Format der Fehler (Nachrichten, Statuscodes) spezifiziert und wo Fehler hin gesendet werden (Konsole, Datei, AWS S3)
• Überprüfen, ob irgendwo Fehler ignoriert werden. Zum Beispiel bedeutet ein leerer „catch“-Block, dass der Fehler ignoriert wird, was das Debugging erschwert
• Prüfen, ob der Fehlerbehandlungscode in einem einzigen Modul zentralisiert ist, das bei Bedarf ausgetauscht werden kann
• Sicherstellen, dass dem Benutzer nicht zu viele Informationen zurückgegeben werden und keine sensiblen Informationen wie Systempfade, Datenbankdetails oder interne Fehlercodes offengelegt werden
• Überprüfen der Implementierung von Logging-Leveln, wie DEBUG, INFO, WARN, ERROR, FATAL
• Prüfen der Richtlinien für Log-Rotation und Archivierung zur Verwaltung der Log-Dateigrößen und zur Aufbewahrung historischer Daten

Beispiel für Code, der das effektive Debugging erschwert:

public decimal CalculateAverage(List numbers)
{
    try
    {
        int sum = 0;
        foreach (var number in numbers)
        {
            sum += number;
        }
        return sum / numbers.Count;
    }
    catch (Exception) 
    {
        // Log the error somewhere (omitted for brevity)
        return 0;
    }
}

Drittanbieter-Bibliotheken:

• Analysieren, ob eine bestimmte Bibliothek wirklich benötigt wird
• Prüfen, ob die Bibliothek unter einer Open-Source-Lizenz verteilt wird
• Überprüfen, ob es bekannte Schwachstellen in der Bibliothek gibt
• Prüfen, ob unbekannte Bibliotheken verwendet werden, insbesondere anstelle von populären und gut unterstützten aus der Community
• Prüfen, ob die Bibliotheksbetreuer und die Community aktiv sind. Ist es einfach, sie bei Problemen zu kontaktieren?
• Überprüfen, ob im Projekt verschiedene Frontend-Bibliotheken in verschiedenen Abschnitten verwendet werden

Kommentare und Dokumentation:

• Sicherstellen, dass Kommentare sinnvoll, prägnant und nur nicht offensichtlichen Code erklären
• Prüfen, ob die Dokumentation vollständig und klar ist, insbesondere für Teile des Codes, die komplex oder zentral sind
• Sicherstellen, dass alle Kommentare und Dokumentationen die aktuellste Version des Codebasis widerspiegeln, unter Berücksichtigung kürzlicher Änderungen oder Aktualisierungen

Code-Vereinfachung und Refaktorisierung:

• Möglichkeiten zur Refaktorisierung oder Vereinfachung des Codes erkennen, um die Komplexität zu reduzieren, ohne die Funktionalität zu verlieren
• Förderung der Entfernung überflüssiger oder veralteter Codeabschnitte, um den Code schlanker und effizienter zu machen
• Unterstützung der Verwendung anerkannter Designmuster und Frameworks, wo geeignet, für ein gemeinsames Verständnis unter Entwicklern und Einhaltung von Best Practices der Branche

Testabdeckung und -qualität

Die Testabdeckung stellt sicher, dass Ihre Testbemühungen so viele Aspekte Ihrer App wie möglich abdecken. Dazu gehören Codeabdeckung, Anforderungen, Funktionalität, Geschäftslogik, Benutzerszenarien, Leistung und Sicherheit. Nicht abgedeckter Code könnte kritische Fehler verbergen. Aber denken Sie daran, dass eine hohe Codeabdeckung nicht gleichbedeutend mit hoher Qualität ist. Achten Sie auf das Design, die Ausführung und die Effektivität Ihrer Tests für wahre Software-Exzellenz.

Testabdeckung:

• Sicherstellen, dass die Test-Suite alle in der Dokumentation angegebenen funktionalen Anforderungen abdeckt
• Überprüfen, ob die Tests Grenzbedingungen und Randfälle abdecken
• Das Gleichgewicht zwischen Unit-Tests und Integrationstests bewerten: Es sollte eine ausreichende Anzahl von Unit-Tests für einzelne Komponenten und Integrationstests geben, um sicherzustellen, dass diese Komponenten zusammenarbeiten

Dokumentation und Wartbarkeit:

• Prüfen, ob jeder Test eine klare Beschreibung dessen hat, was getestet wird und welches Ergebnis erwartet wird
• Die Struktur und Organisation des Testcodes auf Wartungsfreundlichkeit überprüfen: die Verwendung von Test-Fixtures, Setup/Teardown-Methoden und datengesteuerten Tests
• Sicherstellen, dass alle mit den Tests verbundenen Dokumentationen, wie Testpläne oder Testfallbeschreibungen, aktuell sind und den tatsächlichen Tests entsprechen

Testzuverlässigkeit und -stabilität:

• Überprüfen, ob die Tests konsistente Ergebnisse liefern und nicht unzuverlässig sind
• Prüfen, wie Tests mit externen Systemen oder Abhängigkeiten wie Datenbanken oder APIs umgehen
• Überprüfen, ob Testfehler das Problem klar anzeigen und sinnvolle Fehlermeldungen und Protokolle zurückgeben, die die Fehlerquelle identifizieren

Leistung und Effizienz:

• Die Gesamtdauer der Testausführung überprüfen. Langlaufende Tests könnten optimiert oder parallel ausgeführt werden
• Prüfen, ob die Tests in Bezug auf Speicher- und CPU-Nutzung effizient sind
• Sicherstellen, dass die Test-Suite erhöhte Lasten bewältigen kann, was besonders für Leistungstests wichtig ist

Sicherheit

Stellen Sie sich vor, Sie bauen ein Haus, ohne strukturelle Mängel zu überprüfen. Ähnlich setzt unsicherer Code Ihre App Angriffen aus, gefährdet die Daten der Benutzer, die Systemintegrität und den Ruf. Deshalb beinhalten unsere Code-Review-Richtlinien auch eine Sicherheitsüberprüfung.

Authentifizierung und Autorisierung:

• Überprüfen, ob Passwörter sicher gespeichert werden (gehasht und gesalzen)
• Sicherstellen, dass strenge Passwortrichtlinien durchgesetzt werden, einschließlich Passwortlänge und Komplexität
• Falls für privilegierten Zugriff eine Multi-Faktor-Authentifizierung erforderlich ist, prüfen, ob diese vorhanden ist
• Überprüfen, ob Autorisierungsprüfungen für alle sensiblen Aktionen vorhanden sind
• Sicherstellen, dass das Prinzip des geringsten Privilegs befolgt wird (nur notwendige Berechtigungen gewähren)

Eingabevalidierung und -bereinigung:

• Prüfen, ob alle Benutzereingaben, wie Typ, Länge und erlaubte Zeichen, validiert werden
• Überprüfen, ob Datenbereinigungstechniken, Escaping oder Encoding verwendet werden, um Injektionsangriffe zu verhindern
• Sicherstellen, dass gespeicherte Prozeduren für Datenbankinteraktionen verwendet werden, um manuelle SQL-Konstruktionen zu vermeiden

Datensicherheit:

• Prüfen, ob sensible Datenelemente im Ruhezustand und während der Übertragung mit starken Algorithmen wie AES und TLS verschlüsselt werden
• Sicherstellen, dass sichere Schlüsselverwaltungspraktiken befolgt werden, wie die Verwendung von Hardware-Sicherheitsmodulen für die Speicherung und regelmäßige Rotation von Schlüsseln
• Sicherstellen, dass der Datenzugriff auf autorisierte Benutzer und Prozesse beschränkt ist
• Überprüfen der Datenentsorgungsverfahren, um sicherzustellen, dass Daten überschrieben werden, um eine unbefugte Wiederherstellung zu verhindern

Sitzungsverwaltung:

• Die Sicherheit von Sitzungs-IDs analysieren, um Sitzungsübernahme zu verhindern. Sind sie zufällig und nicht erratbar?
• Sicherstellen, dass Sitzungen nach Inaktivität oder Abmeldung ungültig werden
• Überprüfen, ob CSRF (Cross-Site Request Forgery) Tokens implementiert sind, um unbefugte Aktionen zu verhindern
• Prüfen, ob sichere Kommunikationsprotokolle wie HTTPS verwendet werden

Fehlerbehandlung und Protokollierung:

• Sicherstellen, dass generische Fehlermeldungen bereitgestellt werden, anstatt detaillierte Stack-Traces, die interne Details offenlegen
• Überprüfen, ob Protokolle sicher gespeichert und auf verdächtige Aktivitäten überwacht werden, wie fehlgeschlagene Anmeldeversuche oder ungewöhnliche Zugriffsmuster
• Sicherstellen, dass Protokolle keine sensiblen Daten wie Passwörter oder Kreditkartennummern speichern

Sichere Codierungspraktiken:

• Prüfen, ob Sicherheitsbest Practices wie die OWASP Top 10 befolgt werden
• Analysieren, ob Speicherverwaltungspraktiken sicher sind, um Pufferüberläufe und andere speicherbezogene Exploits zu verhindern
• Überprüfen, ob kryptografisch sichere Zufallszahlengeneratoren für kritische Aufgaben wie Passwortgenerierung und Sitzungstokens verwendet werden

Wie man den Code-Review-Prozess verbessert

Nachdem Sie gemeistert haben, was bei einem Code-Review zu prüfen ist, ist es an der Zeit, den Prozess selbst zu verfeinern. Hier sind mehrere Strategien, um die Qualität Ihrer Code-Reviews zu steigern:

• Implementieren Sie einen umfassenden Stilguide: Über die Debatten um Leerzeichen oder Namensgebung hinaus sollte ein gründlicher, organisationsweiter Code-Stilguide Best Practices für die effektive Nutzung der Funktionen der Programmiersprache umfassen.
• Fristen setzen: Erstellen Sie klare Richtlinien für die erwarteten Durchlaufzeiten basierend auf Code-Länge und -Komplexität, z. B. ein-Tages-Reviews für Standard-Updates und mehr Zeit für umfangreiche Änderungen.
• Fördern Sie aufschlussreiche Dialoge: Wechseln Sie vom bloßen Kommentieren des Codes zum Fragen nach den Entscheidungen des Autors. Erkundigen Sie sich nach den Beweggründen hinter bestimmten Formaten oder Entscheidungen, um einen konstruktiven Dialog zu fördern.
• Fördern Sie Team-Einheit in Feedback: Formulieren Sie Kritik im kollektiven Kontext, indem Sie Aussagen wie „Wir bevorzugen diese Methode, weil sie die Lesbarkeit verbessert“ verwenden. Vermeiden Sie beschuldigendes Feedback, um eine positive Teamstimmung zu erhalten.
• Feedback auf objektiven Prinzipien basieren: Geben Sie Feedback, das auf etablierten Codierprinzipien oder -rahmen basiert, anstatt auf persönlichen Vorlieben. Dieser Ansatz trägt nicht nur zur Konsistenz bei, sondern schafft auch eine Lernumgebung für Entwickler.
• Auf wirkungsvolle Verbesserungen konzentrieren: Priorisieren Sie Änderungen, die den Projektwert erheblich steigern, während Sie überprüfen. Konzentrieren Sie sich auf kritische Verbesserungen über Perfektion, unter Berücksichtigung der Zeit- und Umfangsgrenzen des Projekts.

Unsere Erfahrungen mit Code-Reviews

Für Redwerk sind Code-Reviews eine sehr natürliche Tätigkeit. Wir überprüfen den von uns geschriebenen Code während der Entwicklung von Softwarelösungen für unsere Kunden. Aber wir sind ebenso gerne bereit, externen Code zu überprüfen und unser Fachwissen zu teilen, um diese Produkte zu verbessern und anderen Entwicklern zu helfen. Hier ein Einblick in unsere neuesten Code-Review-Projekte.

Project Science

Project Science ist eine IT-Angebotsmanagement-Software, entwickelt von Complete Network, einem führenden Anbieter von Managed Network und IT-Support-Dienstleistungen in den USA. Complete Network beauftragte Redwerk, eine Code-Überprüfung der Project Science Backend-API durchzuführen.

Wir haben die Architektur, die Datenbankstruktur und die Codequalität überprüft und 40 kritische Probleme markiert. Wir entdeckten einfache Möglichkeiten, die Leistung der App durch die Verwendung von Django-Caching, Datenbankabfrage-Caching und Python-Geschwindigkeitstools zu steigern. Unsere Python-Entwickler meldeten 50 Fälle von ungenutztem Code, leeren Dateien, ungenutzten Funktionen, der Übernutzung von Python-Reservierten Wörtern und anderen Lesbarkeits- und Wiederverwendbarkeitsproblemen.

Mit unserer Hilfe konnte Complete Network die Wartbarkeit des Codes um 80 % steigern und gesunde Codierungspraktiken einführen, um ähnliche Probleme in der Zukunft zu verhindern.

Site Compass

Site Compass ist eine Netzwerk-Mapping-App, entwickelt von Reivernet Group, einem US-basierten Netzwerk-Systemintegrator, der komplexe Datennetze für die Hotel-, Bildungs- und Regierungssektoren verwaltet. Sie ist in C# unter Verwendung der Uno-Plattform aufgebaut.

Reivernet Group wandte sich an Redwerk, um ein unvoreingenommenes Audit der Site Compass App zu erhalten und sich auf die offizielle Veröffentlichung vorzubereiten. Unser Arbeitsumfang umfasste die Überprüfung der Architektur, der Datenbank, der Backend-Qualität, der Code-Abdeckung und der Sicherheit.

Wir berichteten über Beispiele für enge Kopplung, Klassen mit zu hoher Vererbungstiefe, Methoden mit zu vielen Parametern, übergroße Typen, die zum God-Object-Phänomen führen, und mehrere andere Probleme. Dank unseres Audits konnte Reivernet Group die kritischen Probleme vor der Markteinführung des Produkts beheben, was zu einer 90%igen Lesbarkeit und Wartbarkeit des Codes führte.

Haben Sie noch Fragen zu Code-Reviews? Erzählen Sie uns von Ihren Bedürfnissen, und wir vereinbaren eine kostenlose Beratung für Sie.

FAQ