Clean Code - Refactoring, Patterns, Testen und Techniken für sauberen Code - Deutsche Ausgabe

Cover

Titel

Impressum

Inhaltsverzeichnis

Vorwort

Einführung

Kapitel 1: Sauberer Code

1.1 Code, Code und nochmals Code

1.2 Schlechter Code

1.3 Die Lebenszykluskosten eines Chaos

1.4 Denkschulen

1.5 Wir sind Autoren

1.6 Die Pfadfinder-Regel

1.7 Vorläufer und Prinzipien

1.8 Zusammenfassung

Kapitel 2: Aussagekräftige Namen

2.1 Einführung

2.2 Zweckbeschreibende Namen wählen

2.3 Fehlinformationen vermeiden

2.4 Unterschiede deutlich machen

2.5 Aussprechbare Namen verwenden

2.6 Suchbare Namen verwenden

2.7 Codierungen vermeiden

2.8 Mentale Mappings vermeiden

2.9 Klassennamen

2.10 Methodennamen

2.11 Vermeiden Sie humorige Namen

2.12 Wählen Sie ein Wort pro Konzept

2.13 Keine Wortspiele

2.14 Namen der Lösungsdomäne verwenden

2.15 Namen der Problemdomäne verwenden

2.16 Bedeutungsvollen Kontext hinzufügen

2.17 Keinen überflüssigen Kontext hinzufügen

2.18 Abschließende Worte

Kapitel 3: Funktionen

3.1 Klein!

3.2 Eine Aufgabe erfüllen

3.3 Eine Abstraktionsebene pro Funktion

3.4 Switch-Anweisungen

3.5 Beschreibende Namen verwenden

3.6 Funktionsargumente

3.7 Nebeneffekte vermeiden

3.8 Anweisung und Abfrage trennen

3.9 Ausnahmen sind besser als Fehler-Codes

3.10 Don’t Repeat Yourself

3.11 Strukturierte Programmierung

3.12 Wie schreibt man solche Funktionen?

3.13 Zusammenfassung

3.14 SetupTeardownIncluder

Kapitel 4: Kommentare

4.1 Kommentare sind kein Ersatz für schlechten Code

4.2 Erklären Sie im und durch den Code

4.3 Gute Kommentare

4.4 Schlechte Kommentare

Kapitel 5: Formatierung

5.1 Der Zweck der Formatierung

5.2 Vertikale Formatierung

5.3 Horizontale Formatierung

5.4 Team-Regeln

5.5 Uncle Bobs Formatierungsregeln

Kapitel 6: Objekte und Datenstrukturen

6.1 Datenabstraktion

6.2 Daten/Objekt-Anti-Symmetrie

6.3 Das Law of Demeter

6.4 Datentransfer-Objekte

6.5 Zusammenfassung

Kapitel 7: Fehler-Handling

7.1 Ausnahmen statt Rückgabe-Codes

7.2 Try-Catch-Finally-Anweisungen zuerst schreiben

7.3 Unchecked Exceptions

7.4 Ausnahmen mit Kontext auslösen

7.5 Definieren Sie Exception-Klassen mit Blick auf die Anforderungen des Aufrufers

7.6 Den normalen Ablauf definieren

7.7 Keine Null zurückgeben

7.8 Keine Null übergeben

7.9 Zusammenfassung

Kapitel 8: Grenzen

8.1 Mit Drittanbieter-Code arbeiten

8.2 Grenzen erforschen und kennen lernen

8.3 log4j kennen lernen

8.4 Lern-Tests sind besser als kostenlos

8.5 Code verwenden, der noch nicht existiert

8.6 Saubere Grenzen

Kapitel 9: Unit-Tests

9.1 Die drei Gesetze der TDD

9.2 Tests sauber halten

9.3 Saubere Tests

9.4 Ein assert pro Test

9.5 F.I.R.S.T.

9.6 Zusammenfassung

Kapitel 10: Klassen

10.1 Klassenaufbau

10.2 Klassen sollten klein sein!

10.3 Änderungen einplanen

Kapitel 11: Systeme

11.1 Wie baut man eine Stadt?

11.2 Konstruktion und Anwendung eines Systems trennen

11.3 Aufwärtsskalierung

11.4 Java-Proxies

11.5 Reine Java-AOP-Frameworks

11.6 AspectJ-Aspekte

11.7 Die Systemarchitektur testen

11.8 Die Entscheidungsfindung optimieren

11.9 Standards weise anwenden, wenn sie nachweisbar einen Mehrwert bieten

11.10 Systeme brauchen domänenspezifische Sprachen

11.11 Zusammenfassung

Kapitel 12: Emergenz

12.1 Saubere Software durch emergentes Design

12.2 Einfache Design-Regel 1: Alle Tests bestehen

12.3 Einfache Design-Regeln 2-4: Refactoring

12.4 Keine Duplizierung

12.5 Ausdrucksstärke

12.6 Minimale Klassen und Methoden

12.7 Zusammenfassung

Kapitel 13: Nebenläufigkeit

13.1 Warum Nebenläufigkeit?

13.2 Herausforderungen

13.3 Prinzipien einer defensiven Nebenläufigkeitsprogrammierung

13.4 Lernen Sie Ihre Library kennen

13.5 Lernen Sie Ihre Ausführungsmodelle kennen

13.6 Achten Sie auf Abhängigkeiten zwischen synchronisierten Methoden

13.7 Halten Sie synchronisierte Abschnitte klein

13.8 Korrekten Shutdown-Code zu schreiben, ist schwer

13.9 Threaded-Code testen

13.10 Zusammenfassung

Kapitel 14: Schrittweise Verfeinerung

14.1 Args-Implementierung

14.2 Args: der Rohentwurf

14.3 String-Argumente

14.4 Zusammenfassung

Kapitel 15: JUnit im Detail

15.1 Das JUnit-Framework

15.2 Zusammenfassung

Kapitel 16: Refactoring von SerialDate

16.1 Zunächst bring es zum Laufen!

16.2 Dann mach es richtig!

16.3 Zusammenfassung

Kapitel 17: Smells und Heuristiken

17.1 Kommentare

17.2 Umgebung

17.3 Funktionen

17.4 Allgemein

17.5 Java

17.6 Namen

17.7 Tests

17.8 Zusammenfassung

Anhang A: Nebenläufigkeit II

A.1 Client/Server-Beispiel

A.2 Mögliche Ausführungspfade

A.3 Lernen Sie Ihre Library kennen

A.4 Abhängigkeiten zwischen Methoden können nebenläufigen Code beschädigen

A.5 Den Durchsatz verbessern

A.6 Deadlock

A.7 Multithreaded-Code testen

A.8 Threadbasierten Code mit Tools testen

A.9 Zusammenfassung

A.10 Tutorial: kompletter Beispielcode

Anhang B: org.jfree.date.SerialDate

Anhang C: Literaturverweise

Epilog

Stichwortverzeichnis