Purchase access. Login

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

Deutsche Ausgabe

Robert C. Martin

Cite this publication as

Robert C. Martin, Clean Code - Refactoring, Patterns, Testen und Techniken für (2013), mitp-Verlag, Frechen, ISBN: 9783826696381

Tracked since 05/2018

1167
downloads

Description / Abstract

h2>* Kommentare, Formatierung, Strukturierung* Fehler-Handling und Unit-Tests* Zahlreiche Fallstudien, Best Practices, Heuristiken und Code Smells
Clean Code - Refactoring, Patterns, Testen und Techniken für sauberen Code
Aus dem Inhalt:* Lernen Sie, guten Code von schlechtem zu unterscheiden* Sauberen Code schreiben und schlechten Code in guten umwandeln* Aussagekräftige Namen sowie gute Funktionen, Objekte und Klassen erstellen* Code so formatieren, strukturieren und kommentieren, dass er bestmöglich lesbar ist* Ein vollständiges Fehler-Handling implementieren, ohne die Logik des Codes zu verschleiern* Unit-Tests schreiben und Ihren Code testgesteuert entwickeln
Selbst schlechter Code kann funktionieren. Aber wenn der Code nicht sauber ist, kann er ein Entwicklungsunternehmen in die Knie zwingen. Jedes Jahr gehen unzählige Stunden und beträchtliche Ressourcen verloren, weil Code schlecht geschrieben ist. Aber das muss nicht sein.

Mit Clean Code präsentiert Ihnen der bekannte Software-Experte Robert C. Martin ein revolutionäres Paradigma, mit dem er Ihnen aufzeigt, wie Sie guten Code schreiben und schlechten Code überarbeiten. Zusammen mit seinen Kollegen von Object Mentor destilliert er die besten Praktiken der agilen Entwicklung von sauberem Code zu einem einzigartigen Buch. So können Sie sich die Erfahrungswerte der Meister der Software-Entwicklung aneignen, die aus Ihnen einen besseren Programmierer machen werden - anhand konkreter Fallstudien, die im Buch detailliert durchgearbeitet werden.

Sie werden in diesem Buch sehr viel Code lesen. Und Sie werden aufgefordert, darüber nachzudenken, was an diesem Code richtig und falsch ist. Noch wichtiger: Sie werden herausgefordert, Ihre professionellen Werte und Ihre Einstellung zu Ihrem Beruf zu überprüfen.

Clean Code besteht aus drei Teilen:Der erste Teil beschreibt die Prinzipien, Patterns und Techniken, die zum Schreiben von sauberem Code benötigt werden.

Der zweite Teil besteht aus mehreren, zunehmend komplexeren Fallstudien. An jeder Fallstudie wird aufgezeigt, wie Code gesäubert wird - wie eine mit Problemen behaftete Code-Basis in eine solide und effiziente Form umgewandelt wird.

Der dritte Teil enthält den Ertrag und den Lohn der praktischen Arbeit: ein umfangreiches Kapitel mit Best Practices, Heuristiken und Code Smells, die bei der Erstellung der Fallstudien zusammengetragen wurden. Das Ergebnis ist eine Wissensbasis, die beschreibt, wie wir denken, wenn wir Code schreiben, lesen und säubern.

Dieses Buch ist ein Muss für alle Entwickler, Software-Ingenieure, Projektmanager, Team-Leiter oder Systemanalytiker, die daran interessiert sind, besseren Code zu produzieren.
Über den Autor:
Robert C. »Uncle Bob« Martin entwickelt seit 1970 professionell Software. Seit 1990 arbeitet er international als Software-Berater. Er ist Gründer und Vorsitzender von Object Mentor, Inc., einem Team erfahrener Berater, die Kunden auf der ganzen Welt bei der Programmierung in
und mit C++, Java, C#, Ruby, OO, Design Patterns, UML sowie Agilen Methoden und eXtreme Programming helfen.

Description

Robert C. »Uncle Bob« Martin entwickelt seit 1970 professionell Software. Seit 1990 arbeitet er international als Software-Berater. Er ist Gründer und Vorsitzender von Object Mentor, Inc., einem Team erfahrener Berater, die Kunden auf der ganzen Welt bei der Programmierung in und mit C++, Java, C#, Ruby, OO, Design Patterns, UML sowie Agilen Methoden und eXtreme Programming helfen.

Table of content

  • 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

More of this series

    Related titles

      More of this author(s)