Besser coden: Best Practices für Clean Code. Das ideale Buch für die professionelle Softwareentwicklung

1 Verhindern Sie den Weltuntergang!
	1.1 Vorwort
	1.2 Schöne neue Welt
	1.3 Was läuft falsch?
	1.4 Weltuntergang verhindern – aber wie?
2 Konventionen
	2.1 Vereinbarungen im Team
		2.1.1 Erlaubte und verbotene Abweichungen
		2.1.2 IDE, Formatierung und Code Style
	2.2 Wenn die Variable »a« sagt (und sonst nichts)
		2.2.1 Eindeutige Bezeichner
		2.2.2 Richtige Sprache
		2.2.3 // Diese Zeile ist kein Kommentar
		2.2.4 Ungarische Notation
		2.2.5 Groß, klein, camelCase und diese verflixten case-sensitiven Dateisysteme
	2.3 Code-Fokus
		2.3.1 Zuständig laut Formular: God.class
		2.3.2 Spezialisierte Funktionen
	2.4 Checkliste
3 Willkommen im Team!
	3.1 Check this out: Subversion
		3.1.1 Überblick
		3.1.2 Subversion-Server
		3.1.3 Subversion-Clients
		3.1.4 Der Trunk
		3.1.5 Branches und Tags
	3.2 Teamwork integriert: Git
		3.2.1 Überblick und Historie
		3.2.2 Von Subversion zu Git
		3.2.3 Bitbucket oder GitHub
	3.3 »Guckstu!«
		3.3.1 Vier Augen sehen mehr als zwei
		3.3.2 Milchmädchenrechnung
		3.3.3 Was ist ein Code Review?
		3.3.4 Ad hoc oder Bürokratie
	3.4 Doppelt hält besser: Pair Programming
		3.4.1 Pilot und Co-Pilot
		3.4.2 Grenzen des Pair Programming
	3.5 Wer macht wann was?
		3.5.1 Unter dem Wasserfall
		3.5.2 Kanban
		3.5.3 Scrum
4 Gut, besser, 91,2 %: Software-Qualität messen
	4.1 Muss funktionieren!
		4.1.1 Elemente einer Anforderung
		4.1.2 Bewertung von Anforderungen
		4.1.3 Systematische Störungen
	4.2 Muss schön sein!
		4.2.1 Performance
		4.2.2 Wartbarkeit
		4.2.3 Benutzbarkeit
		4.2.4 Sicherheit
		4.2.5 Skalierbarkeit
		4.2.6 Portierbarkeit und Kompatibilität
	4.3 ISO 25010 und andere Buzzword-Sammlungen
		4.3.1 ISO 25010
		4.3.2 IEEE 730 und andere
5 Jeder ist Architekt
	5.1 Normalisierte Daten
		5.1.1 Einstellungen in der Datenbank
		5.1.2 Eine Geld-Klasse
		5.1.3 Zu spät!
	5.2 Alles ist ein Objekt, aber welches?
		5.2.1 OOP-Paradigmen
		5.2.2 POJOs und DTOs
	5.3 Entwurfsmuster
		5.3.1 Fabrikmethoden/Fabrik-Klassen (»factory method«/»factory class«)
		5.3.2 Singleton
		5.3.3 Erbauer (»builder«)
		5.3.4 Adapter (»wrapper«)
		5.3.5 Brücke und Proxy (»bridge«/»proxy«)
		5.3.6 Beobachter (»observer«, »listener«, »publisher«, »subscriber«)
		5.3.7 Besucher (»visitor«)
		5.3.8 Iterator (»cursor«)
		5.3.9 Befehl (»command«)
		5.3.10 Zustand (»state«)
	5.4 Was ist eigentlich ein »Item«?
		5.4.1 Hierarchische Datenmodelle
		5.4.2 Dokumentdatenbanken
		5.4.3 Domänenspezifische Sprachen
	5.5 Effiziente Software
		5.5.1 Speicherverbrauch
		5.5.2 Rechenzeit
		5.5.3 Effizienz versus Verständlichkeit
	5.6 Do- und Don’t-Merksatz-Akronyme
		5.6.1 KISS
		5.6.2 POITROAE
		5.6.3 YAGNI
		5.6.4 SMART
		5.6.5 SOLID
		5.6.6 CRUD
	5.7 Neue Räder extra teuer!
		5.7.1 Universal-Bibliotheken
		5.7.2 Spezial-Bibliotheken
		5.7.3 Veraltet oder stabil wie ein Fels?
	5.8 Meins! (Wirklich?)
		5.8.1 GNU General Public License
		5.8.2 Apache-Lizenz 2.0
		5.8.3 MIT-Lizenz
		5.8.4 BSD-Lizenz
6 Erst mal testen
	6.1 Gute und schlechte Unit-Tests
		6.1.1 Einfache Unit-Tests
		6.1.2 Whitebox-Tests
		6.1.3 Ping-Pong
		6.1.4 Testabdeckung
	6.2 Testbar und nicht so gut testbar
		6.2.1 Getrieben von Tests
		6.2.2 Gut testbar
		6.2.3 Nicht so gut testbar
		6.2.4 Unmöglich testbar
	6.3 Umgekehrt wird ein Schuh draus
		6.3.1 Inversion of Control
		6.3.2 Dependency Injection mit Spring Boot
	6.4 Alles einzeln testen
		6.4.1 Unit-Tests mit JMockit
	6.5 Millionen Mausklicks
		6.5.1 UI-Tests mit Selenium
		6.5.2 UI-Tests unter Android
7 Continuous Integration
	7.1 Digitaler Bauunternehmer
	7.2 Java-Builds mit Maven
		7.2.1 Dependency Management via Maven Central
		7.2.2 Dependency Scopes
		7.2.3 Applikationspakete bauen
		7.2.4 Empfehlenswerte Maven-Plug-ins
	7.3 Gradle en vogue
		7.3.1 Gradle vs. Maven
		7.3.2 Hilfreiche Gradle-Plug-ins
		7.3.3 Gradle und Android Studio
	7.4 Jenkins, stets zu Ihren Diensten!
		7.4.1 Jenkins einrichten
		7.4.2 Ein Jenkins-Projekt konfigurieren
		7.4.3 Jenkins-Plug-ins für jeden Zweck
	7.5 Continuous Integration in der Cloud
		7.5.1 Docker-Container bauen
		7.5.2 GitHub Actions aktivieren
		7.5.3 Continuous Integration mit GitLab
	7.6 Nicht nur eine Frage des Stils
		7.6.1 Checkstyle
		7.6.2 FindBugs
	7.7 NuGet für .NET und MS Azure
		7.7.1 Abhängigkeiten verwalten mit NuGet
		7.7.2 Eigene NuGet-Pakete erzeugen
		7.7.3 Entwickeln in der Cloud mit Azure
8 Dokumentation, Kommentare & Tools
	8.1 Kommentare sind wie Tooltipps
		8.1.1 Notwendige und unnötige Kommentare
		8.1.2 Witzige Kommentare
		8.1.3 Wann und wo?
	8.2 Dokumentiert sich von allein
		8.2.1 Javadoc
		8.2.2 Doxygen
		8.2.3 Visual Studio
		8.2.4 Spezielle Kommentare
	8.3 Teamwork online
		8.3.1 Trac
		8.3.2 Redmine
		8.3.3 JIRA und Confluence
		8.3.4 Azure DevOps
9 Betriebssicherheit
	9.1 »Es ist ein Fehler aufgetreten. Versuchen Sie es noch einmal.«
		9.1.1 Fehlercodes
		9.1.2 Ausnahmen richtig behandeln
		9.1.3 Aussagekräftige Fehlermeldungen
		9.1.4 Systematische Fehlersuche
	9.2 Festplattenweise Protokolle
		9.2.1 Logging-Frameworks
		9.2.2 Log-Levels
		9.2.3 Der langsamste Weg, nichts zu loggen
		9.2.4 Rotation und Konfiguration
		9.2.5 Schnitzeljagd
	9.3 Ungebetene Besucher
		9.3.1 Spurensuche
		9.3.2 Alle Luken dicht
		9.3.3 Starke Kryptografie
		9.3.4 Elliptische Kurven
		9.3.5 Rollen und Rechte
		9.3.6 Code Injection verhindern
		9.3.7 Hacker-Tools
10 Schrottcode pimpen
	10.1 Was macht der da?
		10.1.1 Know-how abgreifen
		10.1.2 Code-Bestandsaufnahme
	10.2 Refactoring mit Tools
		10.2.1 Methoden extrahieren
		10.2.2 Klassen extrahieren
		10.2.3 Parameterobjekte
		10.2.4 Interfaces extrahieren
		10.2.5 Weitere Refactoring-Maßnahmen
	10.3 Who sprech Svenska?
		10.3.1 HTML-Templates
		10.3.2 Datenbankschicht abtrennen
	10.4 Endlich: Tests
		10.4.1 Testfälle identifizieren
		10.4.2 Module mocken
		10.4.3 Schrittweise zu höherer Testabdeckung
11 Trollfütterung
	11.1 Umsteiger und Ahnungslose im kalten Wasser
		11.1.1 Willkommen im Kotlin-Land!
		11.1.2 Frustration frisst Freude
		11.1.3 Verantwortung delegieren, nicht Aufgaben
	11.2 Früher war alles besser, auch die Betonköpfe
		11.2.1 Ein weitsichtiger Boss
		11.2.2 Früher waren Bücher noch aus Papier
		11.2.3 Sicherheit und Transparenz
	11.3 Das Patchwork-Team
		11.3.1 Chris schießt quer
		11.3.2 Reden ist Gold
		11.3.3 Anerkennung und Kritik
	11.4 Billig im Osten
		11.4.1 Bitte recht freundlich!
		11.4.2 Differenzen
		11.4.3 Integration
	11.5 Der Hase der Produktmanagerin
		11.5.1 Störfaktoren auf dem Schreibtisch
		11.5.2 Hase und Igel
		11.5.3 Toleranz und Grenzen
	11.6 Arbeiten wie die Profis
		11.6.1 Überflieger
		11.6.2 Diagnose: Overperformer
		11.6.3 Keep it simple, Felix!
	11.7 Leuchtendes Beispiel
		11.7.1 Niemand mag Besserwisser
		11.7.2 Diagnose: das engagierte Vorbild
		11.7.3 Was nun?
12 Parallelwelten
	12.1 Parallel arbeiten
		12.1.1 Threads und ThreadPools
		12.1.2 Race Conditions
		12.1.3 Synchronisierte Zugriffe
		12.1.4 Warten macht keinen Spaß
		12.1.5 Deadlocks
	12.2 Losgelöst
		12.2.1 Publisher und Subscriber
		12.2.2 EventBus im Einsatz
	12.3 .NET async
		12.3.1 Das »async«-Sprachelement
		12.3.2 Locks
A Quizfragen
	A.1 Java-Quiz
		A.1.1 Aufwärmen
		A.1.2 Wiedervereinigung
		A.1.3 Finale
		A.1.4 Unicode
		A.1.5 Java-8-Stream
	A.2 C#-Quiz
		A.2.1 Falsches wahr werden lassen
		A.2.2 Eine Runde runden
		A.2.3 Rechnen mit »null«
		A.2.4 Gute Aufzählung
		A.2.5 Vorher – nachher – vorher
	A.3 C/C++-Quiz
		A.3.1 Rechenaufgabe
		A.3.2 Keine Zahl
		A.3.3 Kleiner oder größer
		A.3.4 Böse, böser, Buffer Overflow
		A.3.5 Das Ende der Wurst
B Lösungen der Quizfragen
Index