Clean Code

1. Schreiben Sie sauberen Code, der lesbar und wartbar ist

Die einzige gültige Messung der Codequalität: WTFs/Minute

Lesbarkeit ist entscheidend. Sauberer Code sollte von anderen Entwicklern leicht verstanden werden können. Er sollte einfach, elegant und frei von Unordnung sein. Streben Sie danach, Code zu schreiben, der seine Absicht klar ausdrückt, ohne dass umfangreiche Kommentare erforderlich sind. Verwenden Sie aussagekräftige Variablen- und Funktionsnamen, halten Sie Funktionen klein und fokussiert und organisieren Sie den Code logisch.

Wartbarkeit ermöglicht Evolution. Code, der schwer zu ändern ist, wird zur Belastung. Gestalten Sie Ihren Code flexibel und modular, damit er sich an wechselnde Anforderungen anpassen kann. Befolgen Sie Prinzipien wie DRY (Don't Repeat Yourself) und SOLID, um lose gekoppelte, hoch kohäsive Systeme zu schaffen. Refaktorisieren Sie gnadenlos, um die Code-Struktur zu verbessern, ohne das Verhalten zu ändern.

Sauberer Code zahlt sich aus. Obwohl das Schreiben von sauberem Code anfangs mehr Aufwand erfordert, spart es langfristig erheblich Zeit und Kopfschmerzen. Sauberer Code ist leichter zu debuggen, zu erweitern und zu warten. Er ermöglicht es Entwicklern, effizienter zu arbeiten und reduziert das Risiko, bei Änderungen Fehler einzuführen. Machen Sie sauberen Code zu einem Kernbestandteil Ihrer Entwicklungspraxis.

2. Befolgen Sie sinnvolle Namenskonventionen

Der Name einer Variablen, Funktion oder Klasse sollte alle wichtigen Fragen beantworten. Er sollte erklären, warum sie existiert, was sie tut und wie sie verwendet wird.

Verwenden Sie absichtsverdeckende Namen. Wählen Sie Namen, die den Zweck und das Verhalten von Variablen, Funktionen und Klassen klar vermitteln. Vermeiden Sie Ein-Buchstaben-Namen oder kryptische Abkürzungen. Verwenden Sie aussprechbare Namen, die leicht durchsucht werden können. Zum Beispiel:

• Schlecht: d (verstrichene Zeit in Tagen)
• Gut: verstricheneZeitInTagen

Seien Sie konsistent und präzise. Verwenden Sie durchgehend konsistente Namenskonventionen in Ihrem Code. Seien Sie präzise, um Mehrdeutigkeiten zu vermeiden – verwenden Sie beispielsweise sinnvolle Unterscheidungen wie getAktiveKonten() und getAktiveKontenInfo(). Vermeiden Sie Kodierungen oder Präfixe, die ohne Mehrwert Lärm hinzufügen. Klassennamen sollten Substantive sein, Methodennamen sollten Verben sein.

Die Namenslänge sollte dem Umfang entsprechen. Verwenden Sie längere, beschreibendere Namen für Variablen und Funktionen mit größerem Umfang. Kurze Namen sind für kleine, lokale Bereiche akzeptabel. Die Länge eines Namens sollte proportional zu seinem Verwendungsbereich sein. Optimieren Sie für Lesbarkeit und Verständnis im Kontext, in dem der Name verwendet wird.

3. Halten Sie Funktionen klein und fokussiert

Funktionen sollten eine Sache tun. Sie sollten es gut tun. Sie sollten es nur tun.

Klein ist schön. Funktionen sollten klein sein – typischerweise 5-10 Zeilen lang. Sie sollten auf einen Bildschirm passen und sofort verständlich sein. Extrahieren Sie Code in gut benannte Hilfsfunktionen, anstatt lange, komplexe Funktionen zu schreiben. Kleine Funktionen sind leichter zu verstehen, zu testen und zu warten.

Eine Sache gut machen. Jede Funktion sollte einen einzigen, klaren Zweck haben. Wenn eine Funktion mehrere Dinge tut, extrahieren Sie diese in separate Funktionen. Anzeichen dafür, dass eine Funktion zu viel tut, sind:

• Mehrere Abstraktionsebenen
• Mehrere Abschnitte oder Codeblöcke
• Zahlreiche Parameter

Eine Abstraktionsebene beibehalten. Die Anweisungen innerhalb einer Funktion sollten alle auf derselben Abstraktionsebene liegen. Mischen Sie nicht hochrangige Logik mit niedrigstufigen Details. Extrahieren Sie niedrigere Operationen in separate Funktionen. Dies verbessert die Lesbarkeit, indem Funktionen fokussiert und konzeptionell einfach gehalten werden.

4. Üben Sie ordnungsgemäße Formatierung und Organisation

Code-Formatierung dient der Kommunikation, und Kommunikation ist die erste Aufgabe eines professionellen Entwicklers.

Konsistente Formatierung ist wichtig. Verwenden Sie durchgehend konsistente Einrückungen, Zeilenumbrüche und Abstände in Ihrem Code. Dies verbessert die Lesbarkeit und reduziert die kognitive Belastung. Vereinbaren Sie Formatierungsstandards mit Ihrem Team und verwenden Sie automatisierte Tools, um diese durchzusetzen. Wichtige Formatierungsrichtlinien umfassen:

• Richtige Einrückung
• Konsistente Klammerplatzierung
• Logische Zeilenumbrüche
• Angemessene Leerzeichen

Organisieren Sie den Code logisch. Gruppieren Sie verwandten Code zusammen und trennen Sie nicht verwandten Code. Verwenden Sie Leerzeilen, um "Absatz"-Pausen zwischen logischen Abschnitten zu erstellen. Platzieren Sie verwandte Funktionen in der Nähe voneinander. Halten Sie Dateien auf ein einzelnes Konzept oder eine Komponente fokussiert. Teilen Sie große Dateien in kleinere, fokussiertere auf, wenn dies angebracht ist.

Befolgen Sie Standardkonventionen. Halten Sie sich an die Standardkonventionen für Ihre Sprache und Gemeinschaft. Dies macht Ihren Code vertrauter und zugänglicher für andere Entwickler. Zum Beispiel in Java:

• Klassennamen verwenden PascalCase
• Methodennamen verwenden camelCase
• Konstanten verwenden ALL_CAPS

5. Verwalten Sie Abhängigkeiten und vermeiden Sie Duplikationen

Duplikation könnte die Wurzel allen Übels in der Software sein.

Beseitigen Sie Duplikationen. Duplizierter Code ist eine verpasste Gelegenheit zur Abstraktion. Wenn Sie Duplikationen sehen, extrahieren Sie den gemeinsamen Code in eine wiederverwendbare Funktion oder Klasse. Dies verbessert die Wartbarkeit, indem die Logik zentralisiert und das Risiko inkonsistenter Änderungen reduziert wird. Arten von Duplikationen, auf die Sie achten sollten:

• Identische Codeblöcke
• Ähnliche Algorithmen mit leichten Variationen
• Wiederholte switch/case- oder if/else-Ketten

Verwalten Sie Abhängigkeiten sorgfältig. Minimieren Sie Abhängigkeiten zwischen Modulen, um die Kopplung zu reduzieren. Verwenden Sie Dependency Injection und Inversion of Control, um den Code modularer und testbarer zu machen. Befolgen Sie das Dependency Inversion Principle – hängen Sie von Abstraktionen ab, nicht von Konkretisierungen. Dies macht Ihren Code flexibler und leichter zu ändern.

Verwenden Sie das Prinzip des geringsten Wissens. Ein Modul sollte nichts über das Innenleben der Objekte wissen, die es manipuliert. Dies reduziert die Kopplung zwischen Modulen. Verwenden Sie beispielsweise das Law of Demeter – eine Methode sollte nur Methoden aufrufen auf:

• Ihrem eigenen Objekt
• Objekten, die als Parameter übergeben werden
• Objekten, die sie erstellt
• Ihren direkten Komponentenobjekten

6. Behandeln Sie Fehler elegant

Fehlerbehandlung ist wichtig, aber wenn sie die Logik verdeckt, ist sie falsch.

Verwenden Sie Ausnahmen anstelle von Fehlercodes. Ausnahmen sind sauberer und überladen die Hauptlogik Ihres Codes nicht. Sie ermöglichen es, die Fehlerbehandlung vom normalen Ablauf zu trennen. Beim Verwenden von Ausnahmen:

• Erstellen Sie informative Fehlermeldungen
• Stellen Sie Kontext mit Ausnahmen bereit
• Definieren Sie Ausnahme-Klassen basierend auf den Bedürfnissen des Aufrufers

Geben Sie nicht null zurück. Das Zurückgeben von null führt zu Nullzeiger-Ausnahmen und überlädt den Code mit null-Prüfungen. Stattdessen:

• Geben Sie leere Sammlungen anstelle von null für Listen zurück
• Verwenden Sie das Null-Objekt-Muster
• Verwenden Sie Optional in Java oder Maybe in funktionalen Sprachen

Schreiben Sie try-catch-finally-Anweisungen zuerst. Beginnen Sie mit try-catch-finally, wenn Sie Code schreiben, der Ausnahmen werfen könnte. Dies hilft, den Umfang und die Erwartungen für den aufrufenden Code zu definieren. Es stellt sicher, dass Ressourcen ordnungsgemäß verwaltet und freigegeben werden, auch in Fehlerfällen.

7. Schreiben Sie gründliche Unit-Tests

Testcode ist genauso wichtig wie Produktionscode.

Befolgen Sie die drei Gesetze von TDD. Test-Driven Development (TDD) verbessert die Codequalität und das Design:

1. Schreiben Sie einen fehlschlagenden Test, bevor Sie Produktionscode schreiben
2. Schreiben Sie nur so viel Test, um einen Fehler zu demonstrieren
3. Schreiben Sie nur so viel Produktionscode, um den Test zu bestehen

Halten Sie Tests sauber und wartbar. Wenden Sie die gleichen Qualitätsstandards auf Ihre Tests an wie auf Ihren Produktionscode. Refaktorisieren und verbessern Sie den Testcode regelmäßig. Gut strukturierte Tests dienen als Dokumentation und ermöglichen eine furchtlose Refaktorisierung des Produktionscodes.

Streben Sie nach umfassender Testabdeckung. Schreiben Sie Tests, die Randfälle, Grenzbedingungen und Fehlerszenarien abdecken – nicht nur den normalen Ablauf. Verwenden Sie Codeabdeckungs-Tools, um Lücken in der Testabdeckung zu identifizieren. Denken Sie daran, dass 100% Abdeckung keine fehlerfreie Software garantiert, aber Vertrauen in Refaktorisierungen und Änderungen bietet.

8. Refaktorisieren Sie kontinuierlich

Hinterlassen Sie den Campingplatz sauberer, als Sie ihn vorgefunden haben.

Refaktorisieren Sie opportunistisch. Verbessern Sie die Code-Struktur, wann immer Sie an einem Stück Code arbeiten. Befolgen Sie die Boy Scout Rule: Hinterlassen Sie den Code besser, als Sie ihn vorgefunden haben. Kleine, inkrementelle Verbesserungen summieren sich im Laufe der Zeit und verhindern Codeverfall. Häufige Refaktorisierungstechniken umfassen:

• Methoden oder Klassen extrahieren
• Umbenennen zur Klarheit
• Komplexe Bedingungsausdrücke vereinfachen
• Duplikationen entfernen

Refaktorisieren Sie sicher mit Tests. Haben Sie immer eine solide Testsuite, bevor Sie refaktorisieren. Machen Sie kleine, inkrementelle Änderungen und führen Sie Tests häufig aus. Dies gibt Ihnen Vertrauen, dass Ihre Änderungen keine bestehenden Funktionen brechen. Verwenden Sie automatisierte Refaktorisierungstools, wenn verfügbar, um das Risiko von Fehlern zu reduzieren.

Balancieren Sie Refaktorisierung und Wertschöpfung. Während kontinuierliche Refaktorisierung wichtig ist, lassen Sie sich nicht von Fortschritten lähmen. Streben Sie nach "gut genug" statt Perfektion. Konzentrieren Sie Refaktorisierungsbemühungen auf die problematischsten oder am häufigsten geänderten Bereiche des Codes. Kommunizieren Sie den Wert der Refaktorisierung an Stakeholder, um Unterstützung für kontinuierliche Codeverbesserung zu gewährleisten.

9. Wenden Sie objektorientierte und funktionale Programmierprinzipien an

Objekte verbergen ihre Daten hinter Abstraktionen und stellen Funktionen bereit, die auf diesen Daten operieren. Datenstrukturen legen ihre Daten offen und haben keine bedeutungsvollen Funktionen.

Verwenden Sie objektorientierte Prinzipien weise. Wenden Sie Prinzipien wie Kapselung, Vererbung und Polymorphismus an, um flexible, modulare Designs zu erstellen. Befolgen Sie die SOLID-Prinzipien:

• Single Responsibility Principle
• Open-Closed Principle
• Liskov Substitution Principle
• Interface Segregation Principle
• Dependency Inversion Principle

Nutzen Sie funktionale Programmierkonzepte. Selbst in objektorientierten Sprachen können funktionale Programmiertechniken zu saubererem Code führen:

• Reine Funktionen ohne Seiteneffekte
• Unveränderliche Daten
• Höhere Ordnungsfunktionen
• Funktionskomposition

Wählen Sie den richtigen Ansatz für das Problem. Objektorientierte und funktionale Paradigmen haben jeweils Stärken und Schwächen. Verwenden Sie objektorientiertes Design, wenn Sie komplexe Domänen mit Verhalten modellieren müssen. Verwenden Sie funktionale Ansätze für Datenumwandlung und Verarbeitungspipelines. Viele moderne Sprachen unterstützen einen hybriden Ansatz, der es Ihnen ermöglicht, das beste Werkzeug für jeden Teil Ihres Systems zu verwenden.

10. Berücksichtigen Sie die Nebenläufigkeit sorgfältig

Nebenläufigkeit ist eine Entkopplungsstrategie. Sie hilft uns, zu entkoppeln, was getan wird, von wann es getan wird.

Verstehen Sie die Herausforderungen der Nebenläufigkeit. Nebenläufige Programmierung bringt Komplexität und potenzielle subtile Fehler mit sich. Häufige Probleme umfassen:

• Race Conditions
• Deadlocks
• Verpasste Signale
• Speicher-Sichtbarkeitsprobleme

Trennen Sie Nebenläufigkeitsbelange. Halten Sie Ihren nebenläufigkeitsbezogenen Code getrennt von anderem Code. Dies macht es einfacher, darüber nachzudenken und ihn zu testen. Verwenden Sie Abstraktionen wie Executors, Futures und Actors, um Nebenläufigkeit zu verwalten, anstatt mit rohen Threads zu arbeiten.

Bevorzugen Sie Unveränderlichkeit und reine Funktionen. Unveränderliche Objekte und reine Funktionen sind von Natur aus threadsicher. Sie beseitigen viele Nebenläufigkeitsprobleme, indem sie gemeinsam genutzten veränderlichen Zustand vermeiden. Wenn veränderlicher Zustand notwendig ist, verwenden Sie geeignete Synchronisationstechniken und erwägen Sie die Verwendung von atomaren Variablen oder nebenläufigen Sammlungen.

Zuletzt aktualisiert: January 22, 2025