Kostenlos testen
Beliebt Neu Genres Autoren
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Suche läuft...
SoBrief
Clean Code

Clean Code

Mach deinen Code leichter änderbar, ohne jede Funktionserweiterung in eine riskante Neuentwicklung zu verwandeln.
von Robert C. Martin 2007 464 Seiten
4.35
23.000+ Bewertungen
Anhören
Immersiv
V2.3
Amazon Kindle Audible
3 Tage Vollzugriff testen
Schalten Sie Audioinhalte & mehr frei!
Weiter

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Zusammenfassung in 30 Sekunden
Die Softwarewartung macht mindestens 80 Prozent der Entwicklungsarbeit aus. Eine lesbare Struktur hilft Teams daher, ein Produkt immer wieder anzupassen. Präzise Namen, fokussierte Funktionen und klare Klassenverantwortlichkeiten verringern den Aufwand, Änderungen zu verstehen. Automatisierte Tests machen Neugestaltungen sicherer, während kleine, überprüfte Änderungen das Risiko begrenzen. In einer Fallstudie stieg die Testabdeckung von etwa der Hälfte der ausführbaren Anweisungen auf 92 Prozent und deckte Fehler bei Datumsberechnungen auf. Die Einschränkung gemeinsam genutzten Zustands hilft, Nebenläufigkeitsfehler zu verhindern.
Enthält Spoiler

Zuletzt aktualisiert:

Problem melden

Rezensionsübersicht

4.35 von 5
Durchschnitt von 23.000+ Bewertungen von Goodreads und Amazon.

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.

Ihre Bewertung:
4.63
516 Bewertungen
Möchten Sie das vollständige Buch lesen?

Glossar

Single-Responsibility-Prinzip

ein Hauptgrund für Änderungen

Eine 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 begrenzen

Eine 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 bereitstellen

Eine 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 Tests

Eine 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 darstellen

Eine 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 API

Kleine, 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äten

Ein 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.

Über den Autor

Robert Cecil Martin, bekannt als Uncle Bob, ist ein renommierter Softwareentwickler und Verfechter agiler Entwicklungsmethoden. Als Präsident von Object Mentor Inc. leitet er ein Beratungsteam, das sich auf objektorientiertes Design, Patterns, UML und agile Methoden spezialisiert hat. Martins Fachkenntnisse erstrecken sich auf verschiedene Programmiersprachen und Methoden, darunter C++ und eXtreme Programming. Er war Chefredakteur des C++ Report und ist ein gefragter Redner auf internationalen Konferenzen. Martin hat großen Einfluss auf die Softwareentwicklungsgemeinschaft; seine Lehren und Bücher prägen bewährte Vorgehensweisen für sauberen Code und professionelles Softwarehandwerk.

PDF herunterladen

Lade das kostenlose PDF herunter, um die Zusammenfassung von Clean Code für später zu speichern. Du kannst es ausdrucken oder offline lesen, wann immer du möchtest.
Download PDF

EPUB herunterladen

Lade das kostenlose EPUB herunter, um die Zusammenfassung von Clean Code auf deinem E-Reader oder in einer Lese-App zu lesen. Das digitale Buchformat .epub eignet sich ideal zum Lesen auf Smartphones, Tablets und E-Readern.
Download EPUB
Möchten Sie das vollständige Buch lesen?
Folgen
Anhören
Start
Swipe
Biblio
App
3 Tage Vollzugriff testen
Anhören, speichern und mehr
Funktionen vergleichen Kostenlos Pro
📖 Zusammenfassungen lesen
Unbegrenzt Zusammenfassungen lesen. Kostenlose Nutzer erhalten 3 pro Monat
🎧 Zusammenfassungen anhören
Unbegrenzt Zusammenfassungen in 40 Sprachen anhören
—
❤️ Unbegrenzte Lesezeichen
Kostenlose Nutzer sind auf 4 begrenzt
—
📜 Unbegrenzter Verlauf
Kostenlose Nutzer sind auf 4 begrenzt
—
📥 Unbegrenzte Downloads
Kostenlose Nutzer sind auf 1 begrenzt
—
Risikofreier Zeitplan
Heute: Sofortzugang erhalten
Vollständige Zusammenfassungen von über 26.000 Büchern anhören. Das sind über 12.000 Stunden Audio!
Tag 2: Erinnerung an Testphase
Wir senden Ihnen eine Benachrichtigung, dass Ihre Testphase bald endet.
Tag 3: Ihr Abonnement beginnt
Die Abbuchung erfolgt am 24. Nov.,
vorher jederzeit kündbar.
Consume 2.8× More Books
2.8× weitere Bücher Hören Lesen
Unsere Nutzer lieben uns
600,000+ Leser
Trustpilot Rating
TrustPilot
4.6 Hervorragend
Diese Seite ist ein absoluter Gamechanger. Ich habe noch nie so schnell Buchzusammenfassungen gelesen. Sehr, sehr empfehlenswert.
— Dave G
Das Geld und die Zeit absolut wert und wirklich gut gemacht. Eine solche Qualität von Zusammenfassungen habe ich auf anderen Websites noch nie gesehen. Sehr hilfreich!
— Em
Sehr empfehlenswert!! Fantastischer Service. Perfekt für alle, die mehr als einen Teaser möchten, aber nicht alle Details eines vollständigen Hörbuchs brauchen.
— Greg M
62 % sparen
Jährlich
$119.88 $44.99/Jahr/J.
$3.75/Mon.
Monatlich
$9.99/Mon.
3-tägige kostenlose Testphase starten
3 Tage kostenlos, dann $44.99/Jahr. Jederzeit kündbar.
Unlock a world of fiction & nonfiction books
26.000+ Bücher zum Preis von 2 Büchern
Lesen Sie jedes Buch in 10 Minuten
Entdecken Sie neue Bücher wie bei Tinder
Fordern Sie jedes Buch an, das noch nicht zusammengefasst ist
Lesen Sie mehr Bücher als jeder, den Sie kennen
Die Nr. 1 App für Buchliebhaber
Lifelike & immersive summaries
30-Tage-Geld-zurück-Garantie
Zusammenfassungen als EPUB oder PDF herunterladen
Jederzeit mit wenigen Klicks kündbar

Warum nur eine Zusammenfassung?

Scanner
Barcode zum Scannen finden

⭐
⭐
⭐
Wir haben ein besonderes Geschenk für Sie
Öffnen
38% Rabatt
RABATT FÜR DICH
⭐
⭐
⭐
$79.99
$49.99/Jahr
Nur $4.16 pro Monat
Weiter
Mit 2 Taps starten, ganz einfach kündigen
Einstellungen
Allgemein
Widget
Wird geladen...