Wichtigste Erkenntnisse
Halte Code jetzt sauber, denn ein funktionierendes Durcheinander verteuert jede künftige Änderung.
Unordnung wächst schleichend. Eine hastig entwickelte Funktion mag heute funktionieren, doch verworrener Code macht die nächste Änderung langsamer und riskanter. Martin beschreibt ein beliebtes Produkt, dessen Veröffentlichungszyklen sich immer weiter hinzogen, bei dem sich Fehler häuften und die Leistung nachließ, bis das Unternehmen schließlich scheiterte. Je größer das Durcheinander wird, desto schlimmer kann es werden, zusätzliches Personal einzustellen: Neue Mitarbeitende kennen den Entwurf nicht, und der Druck, schnell voranzukommen, verleitet zu weiterem Stückwerk.
Die Wartung ist die eigentliche Arbeitslast. Im Vorwort des Buchs wird geschätzt, dass Wartung 80 Prozent oder mehr der Softwarearbeit ausmacht. Auch eine vollständige Neuentwicklung ist kein einfacher Ausweg. Ein neues Team muss das alte System nachbilden, während dieses weiterhin verändert wird, und auch der neue Code kann sich verheddern. Sauberer Code ist keine Zierde. Er bewahrt die Fähigkeit des Teams, das Produkt weiterzuentwickeln.
Das wirtschaftliche Argument überzeugt am meisten, wenn man es als Rückkopplungsschleife versteht: Eine schlechte Struktur erhöht die Kosten von Änderungen, dadurch steigt der Druck, Abkürzungen zu nehmen, und das verschlechtert die Struktur weiter. Sauberkeit ist somit eine Maßnahme des Risikomanagements und keine Stilpräferenz. Auch die Warnung, in einem unübersichtlichen Projekt mehr Leute einzustellen, trifft einen organisatorisch wichtigen Punkt: Mehr Personal überträgt nicht augenblicklich implizites Wissen. Sauberkeit garantiert dennoch keinen kommerziellen Erfolg, und Code aufzupolieren, ohne den Kundennutzen zu berücksichtigen, kann Aufwand verschwenden. Entscheidend ist, ob eine Bereinigung die Kosten oder Risiken plausibler künftiger Änderungen senkt.
Lass Namen und Layout die Geschichte erzählen, bevor Kommentare nötig werden.
Namen vermitteln Bedeutung. Eine Variable namens `d` zwingt die Lesenden zum Raten; ein Name, der angibt, was gemessen wird und in welchen Einheiten, liefert nützlichen Kontext. Dasselbe Prinzip macht aus einer undurchsichtigen Liste von Integer-Arrays erkennbare Felder eines Spielbretts mit benanntem Status und einer klaren Prüfung der Markierung. Bevorzuge Namen, die sich gut aussprechen und suchen lassen, einheitlich sind und zum jeweiligen Geltungsbereich passen. Verwende Fachbegriffe, wenn sie unter Programmierenden gebräuchlich sind, und die Sprache des Fachgebiets, wenn der Begriff aus der Welt der Nutzenden stammt.
Layout lenkt die Aufmerksamkeit. Leerzeilen trennen Gedanken, Einrückungen machen die Struktur sichtbar, und benachbarte Funktionen, die zusammengehören, ersparen unnötiges Suchen. Martin vergleicht eine Quelldatei mit einer Zeitung: Zuerst wird der Hauptgedanke vorgestellt, dann folgen nach und nach die Einzelheiten. Teams sollten sich auf Formatierungsregeln einigen und sie nach Möglichkeit automatisieren, damit Lesende nicht in jeder Datei eine neue visuelle Sprache entschlüsseln müssen.
Benennung und Layout dienen als Karte des begrifflichen Geländes eines Programms. Eine gute Karte enthält nicht jede Information, hilft aber dabei, vorherzusagen, wo die nächste relevante Information zu finden ist. Diese Vorhersagbarkeit ist wichtig, weil Wartung bedeutet, beim Navigieren durch unbekannten Code wiederholt ein mentales Modell aufzubauen. Dabei gilt: Längere Namen und kleinere Dateien sind nicht automatisch verständlicher. Ein Name kann zum Absatz werden, und zu starke Aufteilung kann einen einfachen Gedanken über viele Stellen verstreuen. Entscheidend ist der praktische Nutzen: Hilft die Wahl neuen Lesenden, die Absicht zu verstehen, ohne ständig weit entfernten Kontext nachschlagen zu müssen?
Verkleinere jede Funktion, bis ihr Name einen klaren Schritt beschreibt.
Bleib auf einer Gedankenebene. Eine Funktion sollte einen einzigen Vorgang ausdrücken, und ihre Anweisungen sollten sich auf ungefähr derselben Abstraktionsebene bewegen. In dem FitNesse-Beispiel des Buchs vermischte eine lange Routine das Auffinden einer Seite, das Darstellen eines Pfads, das Zusammensetzen von Zeichenketten und die HTML-Ausgabe. Durch das Herauslösen benannter Schritte wurde ihr Zweck verständlich: feststellen, ob die Seite ein Test ist, gegebenenfalls Einrichtungs- und Aufräuminhalte hinzufügen und sie dann darstellen. Kleine Blöcke, die beschreibende Funktionen aufrufen, verringern außerdem die Verschachtelung und lassen den Code einer Sequenz von oben nach unten folgen.
Halte die Schnittstelle überschaubar. Jedes Argument fügt Informationen hinzu, die Lesende im Blick behalten müssen; ziehe daher keine oder nur wenige Argumente vor. Boolesche Schalter verbergen oft zwei verschiedene Aufgaben. Verdeckte Seiteneffekte sorgen für Überraschungen, während eine Funktion, die zugleich den Zustand ändert und ein Ergebnis meldet, Befehle und Abfragen vermischt. Einen veränderten Wert zurückzugeben ist meist klarer, als stillschweigend ein Ausgabe-Argument zu verändern.
Das Gestaltungsprinzip besteht nicht einfach darin, den Code kurz zu halten. Es geht um die gezielte Steuerung der Aufmerksamkeit: Jede Funktion sollte von den Lesenden verlangen, jeweils nur eine Art von Problem im Kopf zu behalten. Beim Debuggen, wenn bereits Zustand und Ursache verfolgt werden müssen, ist das besonders hilfreich. Die Vorliebe des Buchs für winzige Funktionen kann jedoch übertrieben werden. Eine Funktion herauszulösen, nur um ein Implementierungsdetail zu wiederholen, kann zusätzliche Navigation verursachen, ohne Bedeutung zu schaffen. Das Herauslösen lohnt sich, wenn es einen echten Begriff benennt, eine nützliche Abstraktionsgrenze schafft oder eine wichtige Abfolge verständlicher macht.
Verwende Kommentare sparsam und lass eine einheitliche Formatierung die Struktur des Codes sichtbar machen.
Kommentare verlieren den Bezug zur Wahrheit. Der Code ändert sich, seine Erläuterungen können jedoch zurückbleiben und dadurch unzutreffend oder losgelöst werden. Ein Hinweis, der eine Funktion oder Variable lediglich umformuliert, fügt nur Rauschen hinzu; auskommentierter Code ist besonders kostspielig, weil Lesende nicht erkennen können, ob er zur Geschichte gehört oder einen künftigen Plan darstellt. Die Versionsverwaltung bewahrt frühere Versionen auf, daher muss veralteter Code die Arbeitsdatei nicht verstopfen. Kommentare haben dennoch ihren Platz, wenn sie Absichten erklären, vor Folgen warnen oder Informationen verdeutlichen, die sich im Code nicht knapp ausdrücken lassen.
Formatierung ist Kommunikation. Einheitliche Abstände, Einrückungen und Anordnungen helfen Lesenden, die Hauptgedanken einer Klasse von Implementierungsdetails zu unterscheiden. Das Buch empfiehlt kurze Dateien und Zeilen als hilfreiche Leitlinien, nicht als Gesetze, und betont, dass der gemeinsame Stil eines Teams wichtiger ist als die bevorzugte Klammerplatzierung einer einzelnen programmierenden Person. Formatierungswerkzeuge können die Vereinbarung durchsetzen und dafür sorgen, dass sich Code-Reviews auf die Inhalte konzentrieren.
Entscheidend ist die Unterscheidung zwischen Dokumentation, die eine Entscheidung erklärt, und Kommentaren, die Syntax umformulieren. Erstere kann Überlegungen bewahren, die sonst verloren gingen; Letztere konkurriert mit dem Code um Aufmerksamkeit und kann falsch werden. Die Pflege von Kommentaren ist damit Teil des Entwurfs und keine bloße Aufräumarbeit. Auch Formatierungsregeln dienen der Zusammenarbeit: Einheitlichkeit senkt die kleinen Interpretationskosten, die bei jeder Datei anfallen. Kommentare können dennoch wesentlich sein, wenn es um nicht offensichtliche Einschränkungen geht, insbesondere wenn sich die Absicht nicht sicher aus dem Code erschließen lässt. Ziel ist nicht Schweigen, sondern eine verlässliche Hierarchie, in der der Code maßgeblich ist und Kommentare wirklich fehlenden Kontext ergänzen.
Betrachte Tests als Sicherheitsnetz, das Umgestaltungen überstehbar macht.
Tests schützen Veränderungen. Eine automatisch ausgeführte Testsuite ermöglicht es Entwicklerinnen und Entwicklern, die Struktur zu verändern und zugleich zu prüfen, ob das etablierte Verhalten erhalten bleibt. Das Buch beschreibt ein Team, das Testcode als Wegwerfware behandelte. Als die Tests immer verworrener wurden, war ihre Wartung mühsam, die Suite wurde aufgegeben und die Entwickelnden fürchteten sich davor, den Produktivcode zu verbessern. Die Fehler nahmen zu, und der Code verschlechterte sich. Tests verdienen daher dieselbe Sorgfalt wie der Code, den sie schützen.
Schreibe verständliche und verlässliche Tests. Bei einem nützlichen Test sind Vorbereitung, Aktion und erwartetes Ergebnis leicht zu erkennen. Halte Tests schnell, unabhängig, wiederholbar und selbstprüfend und ordne sie dem getesteten Code nahe an. Prüfe jeweils ein sinnvolles Konzept und untersuche Grenzfälle, statt dich auf den Erfolgsfall zu verlassen. Bei der testgetriebenen Entwicklung steht ein fehlschlagender Test vor der Änderung am Produktivcode; anschließend wird nur so viel implementiert, wie nötig ist, um ihn zu bestehen. So bleibt die Rückmeldung häufig.
Tests fangen nicht nur Regressionen ab. Sie ermöglichen Umgestaltungen, indem sie die Folgen von Änderungen sichtbar machen. Das verbindet Verifikation und Entwurf auf wirkungsvolle Weise: Code, der sich schwer testen lässt, weist oft verborgene Abhängigkeiten oder unklare Zuständigkeiten auf. Eine bestandene Suite beweist jedoch nicht, dass die Software den Bedürfnissen der Nutzenden entspricht. Tests können verständlich, schnell und umfassend sein und dennoch eine falsche Annahme festschreiben. Ihre Aussagekraft hängt von der Qualität der Verhaltensfragen ab, die sie stellen. Mehrdeutige Anforderungen sollten daher offengelegt und nicht stillschweigend in Prüfbedingungen verwandelt werden.
Refaktoriere in winzigen, überprüften Schritten statt mit einer heroischen Neuentwicklung.
Funktionierender Code ist nur ein Entwurf. Martins Kommandozeilenparser Args begann als einfacher Parser für boolesche Werte. Durch das Hinzufügen von Zeichenketten- und Integer-Optionen breiteten sich wiederholte Logik und verworrene Fehlerbehandlung aus. Statt weiter Funktionen aufzuschichten, ergänzte er eine gemeinsame Abstraktion für das Zuordnen von Argumenten und formte das Programm mit kleinen Änderungen um; zwischen den Schritten prüfte er die Tests. Der fertige Entwurf entstand durch Verfeinerung und nicht durch einen Neuanfang.
Tests decken Fehler auf und schützen zugleich Änderungen. Bei der Fallstudie SerialDate ergab eine erste Überprüfung der Testabdeckung, dass die vorhandenen Tests nur etwa die Hälfte der ausführbaren Anweisungen abdeckten. Eine unabhängige Testsuite hob die Abdeckung auf etwa 92 Prozent und deckte Fehler an Datumsgrenzen auf. Dazu gehörte eine Wochentagsberechnung, die das Ausgangsdatum zurückgab, obwohl sie das nächste Vorkommen hätte liefern sollen. Im Zuge der Fehlerbehebung wurden außerdem Namen verbessert, Zuständigkeiten verschoben und ungenutzter Code entfernt.
Inkrementelles Refactoring ähnelt einem kontrollierten Experiment: Man ändert eine Entwurfsvariable, beobachtet, ob das Verhalten stabil bleibt, und behält das Nützliche bei. Dadurch verringert sich die Zahl möglicher Ursachen, wenn eine Regression auftritt. Die Fallstudien zeigen auch, warum Testabdeckung ein Diagnosewerkzeug und keine Qualitätsbewertung ist. Mehr ausgeführte Zeilen können blinde Flecken aufdecken, doch nur gut gewählte Prüfungen stellen sinnvolles Verhalten sicher. Ein diszipliniertes Vorgehen braucht daher sowohl mechanische Sicherheit als auch ein kritisches Urteil darüber, was das Programm tun sollte – insbesondere an Grenzstellen, an denen intuitive Regeln oft versagen.
Gib jeder Klasse eine klare Zuständigkeit und verbirg Details hinter nützlichen Abstraktionen.
Zähle die Gründe für Änderungen. Das Single-Responsibility-Prinzip besagt, dass eine Klasse einen hauptsächlichen Grund haben sollte, sich zu ändern. Ein Dashboard, das sowohl eine Benutzeroberfläche verwaltet als auch Versionsdetails der Software meldet, kann aufgeteilt werden, damit sich beide Belange unabhängig voneinander weiterentwickeln. Kohäsive Klassen halten zusammengehörige Daten und Verhalten beieinander, während kleine Klassen es erleichtern, den von einer Änderung betroffenen Teil zu finden.
Entscheide bewusst zwischen Objekten und Datenstrukturen. Objekte verbergen ihre Repräsentation und bieten Verhalten; Datenstrukturen legen ihre Felder zur direkten Verwendung offen. Keiner der beiden Ansätze ist in jeder Situation überlegen. Ein Formensystem, in dem häufig neue Formen hinzukommen, profitiert von polymorphen Objekten; werden dagegen häufig neue Operationen ergänzt, kann ein System mit Datenstrukturen und externen Funktionen einfacher sein. Halte beim Start des Systems die Objekterzeugung und das Verknüpfen von Abhängigkeiten vom Laufzeitverhalten getrennt. So lässt sich die Architektur leichter testen und verändern.
Der zentrale architektonische Vorteil liegt im lokalen Denken. Wenn eine Klasse eine zusammenhängende Zuständigkeit hat, können Lesende eine Änderung verstehen, ohne sich gedanklich die ganze Anwendung vor Augen führen zu müssen. Die Unterscheidung zwischen Objekten und Datenstrukturen verhindert, dass Entwurf zur Modesache wird: Die richtige Wahl hängt davon ab, ob sich eher die Typen oder die Operationen verändern werden. Dem steht ein möglicher Nachteil gegenüber. Zu viele winzige Klassen können die Navigation erschweren, und eine Abstraktion ohne absehbare Veränderlichkeit kann unnötiger Ballast sein. Ein guter Entwurf verringert die Komplexität wahrscheinlicher Änderungen, statt um ihrer selbst willen möglichst viele Abstraktionen zu schaffen.
Lass die Fehlerbehandlung die Hauptlogik schützen, statt sie zu verschlucken.
Trenne Fehlerpfade ab. Wer Fehlercodes zurückgibt, zwingt aufrufenden Code dazu, jedes Ergebnis zu prüfen, wodurch sich häufig Bedingungen um den Hauptvorgang schachteln. Ausnahmen können die Fehlerbehandlung in einen eigenen Handler verlagern und so den normalen Ablauf leichter nachvollziehbar machen. Fehlertypen sollten sich danach richten, was Aufrufende abfangen müssen, und Fehlermeldungen sollten den fehlgeschlagenen Vorgang mit nützlichem Kontext benennen. Durch das Kapseln einer Bibliothek eines Drittanbieters lassen sich deren zahlreiche Ausnahmen in eine kleinere, von der Anwendung kontrollierte Schnittstelle übersetzen.
Vermeide gewöhnliche Ausnahmen durch passenden Entwurf. Wenn sich ein normalerweise vorkommender Fall, etwa das Fehlen von Verpflegungskosten, durch ein Sonderobjekt darstellen lässt, das den Tagessatz liefert, braucht die Hauptberechnung keinen Sonderzweig mehr. Ebenso zwingt die Rückgabe von null Aufrufende zu wiederholten Prüfungen und schafft Gelegenheiten für Fehler. Ziehe stattdessen ein ausdrücklich leeres Ergebnis oder eine aussagekräftige Ausnahme vor, und übergib keinen Nullwert, wenn die Methode keine sinnvolle Möglichkeit hat, darauf zu reagieren.
Fehlerbehandlung ist am klarsten, wenn sie ungewöhnliches Scheitern von gewöhnlichen Abweichungen unterscheidet. Das Sonderfallobjekt ist nützlich, weil es eine fachliche Regel an die Grenze verlagert, an der die außergewöhnliche Bedingung verstanden wird, statt alle Aufrufenden zu zwingen, sie zu wiederholen. Wrapper schaffen zudem eine stabile Schnittstelle um wechselhafte externe APIs. Ausnahmen haben allerdings ihren Preis: Weit gefasste Auffangblöcke können Fehler verbergen, und Ausnahmen als normale Steuerungslogik einzusetzen verschleiert das erwartete Verhalten. Entscheidend ist, ob die aufrufende Stelle sinnvoll auf den Fehler reagieren kann. Wenn nicht, braucht der Entwurf möglicherweise eine bessere Darstellung des Normalfalls oder eine klarere Fehlergrenze.
Minimiere gemeinsam genutzten Zustand, denn nebenläufiger Code kann zwischen gewöhnlichen Schritten scheitern.
Nebenläufigkeit trennt das Geschehen vom Zeitpunkt. Sie kann den Durchsatz erhöhen, wenn eine Aufgabe auf eine Eingabe oder das Netzwerk wartet, während eine andere den Prozessor nutzen kann. Doch selbst eine einfache Erhöhung um eins ist nicht unbedingt unteilbar: Zwei Threads können denselben Wert lesen, beide denselben nächsten Wert berechnen und sich dann gegenseitig überschreiben. Das Problem lässt sich nur schwer reproduzieren, weil die Thread-Zeitplanung viele mögliche Ausführungsreihenfolgen erzeugt.
Verringere das Risiko an der Quelle. Halte den nebenläufigkeitsspezifischen Code von der gewöhnlichen Geschäftslogik getrennt, beschränke den Zugriff auf gemeinsam genutzte Daten und ziehe nach Möglichkeit unabhängige Arbeit oder Kopien vor. Verwende etablierte threadsichere Sammlungen und Ausführungsbibliotheken, statt Synchronisierung leichtfertig selbst zu erfinden. Halte geschützte Abschnitte klein, plane das Herunterfahren frühzeitig und teste unter verschiedenen Lasten und auf unterschiedlichen Plattformen. Eine gezielte Veränderung des Thread-Timings kann Fehler aufdecken, die gewöhnliche Tests übersehen.
Die wichtigste Veränderung der Sichtweise besteht darin, Nebenläufigkeit nicht als schnellere Variante gewöhnlichen Codes zu behandeln. Sie verändert den Raum möglicher Verhaltensweisen, sodass Korrektheit von Abläufen abhängt, die sich beim einmaligen linearen Lesen nicht erschließen. Isolation und klar begrenzte Zuständigkeiten sind daher bessere Mittel, als einfach überall Sperren hinzuzufügen. Belastungstests und gezielte Timing-Änderungen können seltene Fehler aufdecken, doch wiederholtes Bestehen eines Tests beweist keine Sicherheit. Am verlässlichsten ist eine Praxis, die durchdachten Zustandsentwurf, Kenntnis der Bibliotheken und wiederholte Tests verbindet und sporadische Fehler als Hinweise statt als Pech behandelt.
Analyse
Clean Code lässt sich am besten als Handbuch dazu lesen, wie ein Team seine Fähigkeit bewahrt, Software zu verstehen und zu verändern. Die zentrale These ist wirtschaftlicher Art: Lesbarkeit, Tests und eine disziplinierte Struktur sind kein nachträglicher Feinschliff. Sie gehören zu den Voraussetzungen, die künftige Auslieferungen überhaupt ermöglichen. Das Buch entwickelt diese These anhand einer Reihe von Ebenen – von kleinen Entscheidungen wie der Benennung einer Variablen bis hin zu größeren Strukturen wie Klassengrenzen, dem Systemstart und nebenläufiger Ausführung. Der wiederkehrende Erzählbogen ist die Reparatur: funktionierenden, aber unbeholfenen Code untersuchen, die Ursache der Reibung erkennen, eine kleine Veränderung vornehmen und prüfen, ob das Verhalten erhalten bleibt.
Der wichtigste Beitrag ist die Verbindung zwischen Codequalität und Änderungsrisiko. Namen verringern den Interpretationsaufwand. Kleine Funktionen machen Absicht und Kontrollfluss sichtbar. Tests nehmen strukturellen Änderungen ihren Schrecken. Abgrenzungen halten Unsicherheiten aus Bibliotheken, Infrastrukturen und externen Diensten in Schach. Das sind weniger voneinander unabhängige Regeln als sich gegenseitig verstärkende Methoden, mit denen die Zahl der Tatsachen verringert wird, die Entwickelnde gleichzeitig im Kopf behalten müssen. Die Fallstudien zu Args und SerialDate machen diese Methode konkret und zeigen, wie sich der Entwurf durch aufeinanderfolgende, getestete Entscheidungen verbessert, nicht durch einen einzigen Geistesblitz.
Nicht alle Empfehlungen des Buchs sollten als allgemeingültige Gesetze behandelt werden. Winzige Funktionen, wenige Argumente, möglichst wenige Klassen und ein Minimum an Kommentaren können dogmatisch werden, wenn man sie von ihrem Zweck löst. Zu starke Zerlegung kann einen Begriff verstreuen; knappe Kommentare können die Begründung auslassen; eine große Testsuite kann überholte Annahmen bewahren. Der Text räumt konkurrierende Denkschulen und Zielkonflikte selbst ein, besonders bei der Entscheidung zwischen objektorientierten und prozeduralen Repräsentationen. Diese Offenheit ist wichtig.
Auch die Java-Beispiele aus dem Jahr 2007 verorten manche Empfehlungen in ihrem historischen Kontext. Moderne Sprachfunktionen, statische Analyse, automatisierte Formatierung, Werkzeuge für Abhängigkeiten und Nebenläufigkeitsbibliotheken können bestimmte Lasten verringern. Doch sie können nicht entscheiden, ob ein Name die Absicht vermittelt oder eine Abgrenzung eine echte Grenze für Änderungen darstellt. Die dauerhafte Lehre lautet daher nicht, jedes Beispiel nachzuahmen. Es geht darum, Code verständlich, testbar und kostengünstig veränderbar zu machen und dann mit Augenmaß zu entscheiden, welche Bereinigung diesem Ziel tatsächlich dient.
Rezensionsübersicht
Clean Code gilt weithin als unverzichtbare Lektüre für Softwareentwickler und bietet wertvolle Einblicke in das Schreiben lesbaren und wartbaren Codes. Gelobt wird das Buch für seine praktischen Ratschläge zu Namenskonventionen, Funktionsdesign und Tests; manche Leser fanden es jedoch zu stark auf Java ausgerichtet und seine Empfehlungen gelegentlich überzogen. Die Fallstudien stießen auf gemischte Reaktionen: Einige fanden sie hilfreich, andere weniger überzeugend. Trotz seiner Schwächen betrachten viele Entwickler das Buch als Pflichtlektüre, die ihre Programmierpraxis und ihr Verständnis für professionelles Softwarehandwerk maßgeblich verbessert hat.
Andere lasen auch
Glossar
Single-Responsibility-Prinzip
ein Hauptgrund für ÄnderungenEine Klasse oder ein Modul sollte eine zentrale Verantwortung haben, also einen Hauptgrund, aus dem Änderungen erforderlich werden. Das Prinzip fördert die Bündelung von Verhalten, das sich aus demselben Grund ändert, und die Trennung von Verhalten, das sich voraussichtlich unabhängig weiterentwickelt. Es ist eine Orientierungshilfe für Kohäsion und Änderungsmanagement, keine Forderung, dass jede Klasse nur eine Methode enthalten darf.
Demeter-Gesetz
das Wissen über Mitwirkende begrenzenEine Methode sollte mit Objekten kommunizieren, die sie direkt besitzt, erstellt, erhält oder zu denen sie in enger Beziehung steht, statt sich durch Ketten anderer Objekte zu bewegen. Ziel ist es, das Wissen über interne Strukturen zu verringern. Anstatt mehrere Objekte zu durchlaufen, um ein Detail zu erhalten, bittet ein Aufrufer einen Mitwirkenden, die benötigte Operation auszuführen.
Dependency Injection
Abhängigkeiten von außen bereitstellenEine Entwurfstechnik, bei der ein Objekt die benötigten Dienste oder Mitwirkenden erhält, anstatt sie selbst zu erstellen oder zu suchen. Ein Konstruktor, Setter oder Container stellt diese Abhängigkeiten während der Einrichtung bereit. Dadurch werden die Objekterstellung und das Anwendungsverhalten voneinander getrennt, und Implementierungen lassen sich leichter austauschen, konfigurieren und testen.
F.I.R.S.T.-Prinzip
Merkmale zuverlässiger TestsEine Eselsbrücke für fünf Merkmale sauberer Tests: schnell, unabhängig, wiederholbar, selbstvalidierend und zeitnah. Schnelle Tests werden häufig ausgeführt; unabhängige Tests sind nicht von der Ausführungsreihenfolge abhängig; wiederholbare Tests funktionieren in unterschiedlichen Umgebungen; selbstvalidierende Tests zeigen eindeutig Erfolg oder Fehlschlag an; zeitnahe Tests werden zeitnah zum Produktionscode geschrieben, den sie prüfen.
Sonderfallmuster (Special Case Pattern)
eine Ausnahme als normale Daten darstellenEine Entwurfstechnik, bei der ein Objekt für einen ungewöhnlichen, aber erwarteten Zustand ein sinnvolles Verhalten bereitstellt. Der Client-Code verwendet dann dieselbe Operation, ohne wiederholt den Sonderfall prüfen zu müssen. Das Beispiel im Buch ist ein Ausgabenobjekt, das den Tagegeldbetrag zurückgibt, wenn keine Ausgaben für Mahlzeiten vorliegen, sodass diese Regel nicht in der Hauptberechnung des Aufrufers steckt.
Lernende Tests
Tests zur Erkundung einer externen APIKleine, gezielte Tests, die geschrieben werden, um das Verhalten eines Drittanbieterpakets zu entdecken und festzuhalten. Sie dienen als kontrollierte Experimente, während Entwickler eine unbekannte Schnittstelle kennenlernen, und können nach einer Aktualisierung erneut ausgeführt werden, um inkompatible Änderungen aufzudecken. Sie prüfen das Verständnis des Teams und die beabsichtigte Nutzung der Abhängigkeit, nicht deren gesamte Implementierung.
Einfaches Design (Simple Design)
Design, verfeinert anhand von vier PrioritätenEin Entwurfsansatz, der als geordnete Folge von Prioritäten dargestellt wird: sicherstellen, dass das System seine Tests besteht, Duplikate entfernen, die Absicht des Programmierers klar ausdrücken und unnötige Klassen und Methoden vermeiden. Die Reihenfolge ist wichtig. Tests und Klarheit haben Vorrang vor der Minimierung der Anzahl der Programmelemente, während Refactoring das Design durch kleine, überprüfte Änderungen entstehen lässt.
FAQ
Worum geht es in Clean Code: A Handbook of Agile Software Craftsmanship?
- Schwerpunkt Softwarehandwerk: Das Buch betont, wie wichtig es ist, sauberen, wartbaren Code zu schreiben, und stellt dies als Kennzeichen von Professionalität in der Softwareentwicklung heraus.
- Prinzipien und Methoden: Es erläutert verschiedene Prinzipien, Patterns und Methoden, die Programmierern helfen, Code zu schreiben, der nicht nur funktioniert, sondern auch leicht zu lesen und zu verstehen ist.
- Beispiele aus der Praxis: Zahlreiche Beispiele für guten und schlechten Code zeigen, wie sich unübersichtlicher Code durch Refactoring und disziplinierte Vorgehensweisen in sauberen Code verwandeln lässt.
Warum sollte ich Clean Code von Robert C. Martin lesen?
- Programmierkenntnisse verbessern: Die Lektüre des Buches kann deine Programmierkenntnisse erheblich erweitern, indem es dir zeigt, wie du Code schreibst, der leichter zu warten und zu verstehen ist.
- Berufliche Weiterentwicklung: Es ist eine wertvolle Ressource für alle, die ihre Karriere in der Softwareentwicklung voranbringen möchten, und vermittelt eine Haltung, die auf handwerklichem Können und Qualität beruht.
- Praktische Ratschläge: Das Buch bietet praktische Ratschläge, die sich sofort in der eigenen Programmierpraxis anwenden lassen, und ist damit ein nützlicher Leitfaden für Anfänger wie erfahrene Programmierer.
Was sind die wichtigsten Erkenntnisse aus Clean Code?
- Aussagekräftige Namen: Das Buch betont, wie wichtig Namen für Variablen, Funktionen und Klassen sind, die ihre Absicht erkennen lassen und so Lesbarkeit und Wartbarkeit des Codes verbessern.
- Kleine Funktionen: Funktionen sollten klein sein und sich auf eine einzige Aufgabe konzentrieren. Das Befolgen des Prinzips „Eine Sache tun“ erhöht die Klarheit und verringert die Komplexität.
- Fehlerbehandlung: Martin empfiehlt, bei der Fehlerbehandlung Ausnahmen statt Rückgabecodes zu verwenden. Dadurch bleibt die Hauptlogik des Codes sauber und übersichtlich.
Was sind die besten Zitate aus Clean Code, und was bedeuten sie?
- „Sauberer Code ist eine Frage der Disziplin.“: Dieses Zitat betont, dass das Schreiben sauberen Codes konsequente Anstrengung und die Einhaltung bewährter Vorgehensweisen erfordert und nicht allein vom Glück oder Talent abhängt.
- „Kommentare machen schlechten Code nicht wett.“: Damit wird der Gedanke hervorgehoben, dass keine noch so ausführlichen Kommentare die mangelnde Klarheit und Struktur schlecht geschriebenen Codes ausgleichen können.
- „Hinterlasse den Zeltplatz sauberer, als du ihn vorgefunden hast.“: Diese Metapher ermutigt Entwickler, die Codebasis mit jeder Änderung zu verbessern, damit der Code auf Dauer sauber und wartbar bleibt.
Wie definiert Clean Code sauberen Code?
- Lesbar und verständlich: Sauberer Code ist leicht zu lesen und zu verstehen, sodass andere Entwickler seinen Zweck und seine Funktion schnell erfassen können.
- Minimale Komplexität: Er sollte möglichst wenig komplex sein; jede Funktion und Klasse konzentriert sich auf eine einzige Verantwortung, was Tests und Wartung erleichtert.
- Gut strukturiert: Sauberer Code ist gut strukturiert und folgt einheitlichen Formatierungs- und Namenskonventionen, die seine Klarheit erhöhen und die kognitive Belastung der Leser verringern.
Was ist die Pfadfinderregel in Clean Code?
- Kontinuierliche Verbesserung: Die Pfadfinderregel besagt, dass Entwickler „den Zeltplatz sauberer hinterlassen sollen, als sie ihn vorgefunden haben“. Das heißt: Wenn du an Code arbeitest, solltest du stets versuchen, ihn zu verbessern.
- Kleine Änderungen zählen: Das kann so einfach sein wie eine Variable zur besseren Verständlichkeit umzubenennen oder eine kleine Funktion zu refaktorieren. Auch das trägt dazu bei, die Codebasis insgesamt sauberer zu machen.
- Berufliche Verantwortung: Wer diese Regel befolgt, zeigt eine professionelle Haltung zu Codequalität und Wartung und fördert eine Kultur der kontinuierlichen Verbesserung im Team.
Was ist das Single-Responsibility-Prinzip (SRP) in Clean Code?
- Definition des SRP: Das SRP besagt: „Eine Klasse sollte einen und nur einen Grund haben, sich zu ändern.“ Das bedeutet, dass sich jede Klasse auf eine einzige Verantwortung oder Funktionalität konzentrieren sollte.
- Vorteile des SRP: Die Einhaltung des SRP sorgt für eine bessere Codeorganisation und erleichtert Verständnis, Tests und Wartung. Sie verringert das Risiko, dass Änderungen in einem Bereich unverbundene Teile des Codes beeinträchtigen.
- Hinweise zur Umsetzung: Martin gibt praktische Ratschläge dazu, wie sich Verantwortlichkeiten erkennen und Klassen so refaktorieren lassen, dass sie dem SRP entsprechen und der Code sauber und übersichtlich bleibt.
Wie behandelt Clean Code die Fehlerbehandlung?
- Ausnahmen verwenden: Das Buch empfiehlt, bei der Fehlerbehandlung Ausnahmen statt Rückgabecodes zu verwenden. Dadurch bleibt die Hauptlogik des Codes sauber und übersichtlich.
- Trennung der Verantwortlichkeiten: Die Fehlerbehandlung sollte von der Hauptlogik des Codes getrennt sein. So können sich Entwickler auf die zentrale Funktionalität konzentrieren, ohne durch überladene Fehlerprüfungen abgelenkt zu werden.
- Kontext bereitstellen: Ausnahmen sollten genügend Kontext liefern, damit sich Ursprung und Art des Fehlers verstehen lassen. So können Probleme leichter diagnostiziert und behoben werden.
Welche Rolle spielen Tests in Clean Code?
- Grundlage für sauberen Code: Tests gelten als wesentlicher Bestandteil des Schreibens sauberen Codes. Sie stellen sicher, dass sich der Code wie erwartet verhält, und helfen, Probleme früh im Entwicklungsprozess zu erkennen.
- Schnelle und zuverlässige Tests: Das Buch betont, dass Tests schnell und zuverlässig sein sollten, damit sie häufig ausgeführt werden. Das hilft, eine saubere Codebasis zu bewahren und das Risiko neuer Fehler zu verringern.
- Selbstvalidierende Tests: Tests sollten so gestaltet sein, dass sie sich selbst validieren, also eindeutig anzeigen, ob der Code korrekt funktioniert. Das verringert Mehrdeutigkeit und stärkt das Vertrauen in den Code.
Wie empfiehlt Clean Code, mit Abhängigkeiten umzugehen?
- Dependency-Inversion-Prinzip (DIP): Das Buch erläutert: „Module höherer Ebenen sollten nicht von Modulen niedrigerer Ebenen abhängen. Beide sollten von Abstraktionen abhängen.“ Dieses Prinzip fördert den Einsatz von Schnittstellen und abstrakten Klassen, um die Kopplung zu verringern.
- Einsatz von Dependency Injection: Martin empfiehlt Dependency Injection zur Verwaltung von Abhängigkeiten. Dadurch wird der Code flexibler und leichter testbar. Bei diesem Ansatz ist die Erstellung der Abhängigkeiten von ihrer Nutzung entkoppelt.
- Vorteile der Abhängigkeitsverwaltung: Wenn Entwickler Abhängigkeiten wirksam verwalten, können sie Systeme schaffen, die leichter zu warten und zu erweitern sind. Das führt zu saubererem und robusterem Code.
Welche häufigen Code-Smells werden in Clean Code benannt?
- Duplizierter Code: Dies ist ein wesentlicher Code-Smell, der auf einen Mangel an Abstraktion hinweist. Das Buch empfiehlt, Duplikate zu beseitigen, um die Wartbarkeit zu verbessern und Fehler zu verringern.
- Lange Methoden: Zu lange Methoden können schwer zu verstehen und zu warten sein. Das Buch schlägt vor, sie in kleinere, besser überschaubare Funktionen aufzuteilen.
- Übermäßige Kommentare: Kommentare können zwar hilfreich sein, doch übermäßig viele oder redundante Kommentare deuten oft darauf hin, dass der Code selbst nicht klar ist. Ziel sollte es sein, selbsterklärenden Code zu schreiben, der möglichst wenige Kommentare benötigt.
Wie kann ich die Prinzipien aus Clean Code in meinen eigenen Projekten anwenden?
- Mit kleinen Änderungen beginnen: Wende die Prinzipien sauberen Codes zunächst auf kleine Bereiche deiner Codebasis an. Refaktoriere jeweils eine Klasse oder Funktion, um die Lesbarkeit und Wartbarkeit zu verbessern.
- Tests zuerst schreiben: Übernimm Praktiken der testgetriebenen Entwicklung (TDD), indem du Tests schreibst, bevor du neue Funktionen implementierst. So ist dein Code stets durch Tests abgedeckt, was zur Qualitätssicherung beiträgt.
- Regelmäßig refaktorieren: Mache Refactoring zu einem festen Bestandteil deines Entwicklungsprozesses. Suche kontinuierlich nach Möglichkeiten, die Code-Struktur zu verbessern und Duplikate zu beseitigen, damit deine Codebasis sauber und effizient bleibt.
PDF herunterladen
EPUB herunterladen
.epub eignet sich ideal zum Lesen auf Smartphones, Tablets und E-Readern.