Code That Fits in Your Head

1 - Cover [Seite 1]
2 - Titel [Seite 7]
3 - Impressum [Seite 8]
4 - Inhaltsverzeichnis [Seite 9]
5 - Vorwort des Herausgebers der englischen Ausgabe [Seite 17]
6 - Einleitung [Seite 21]
7 - Über den Autor [Seite 27]
8 - Teil I: Beschleunigung [Seite 29]
8.1 - Kapitel 1: Kunst oder Wissenschaft? [Seite 31]
8.1.1 - 1.1 Bau eines Hauses [Seite 31]
8.1.1.1 - 1.1.1 Das Problem mit Projekten [Seite 32]
8.1.1.2 - 1.1.2 Das Problem mit Phasen [Seite 33]
8.1.1.3 - 1.1.3 Abhängigkeiten [Seite 33]
8.1.2 - 1.2 Kultivieren eines Gartens [Seite 34]
8.1.2.1 - 1.2.1 Was lässt einen Garten gedeihen? [Seite 35]
8.1.3 - 1.3 Der Weg zur Ingenieurswissenschaft [Seite 35]
8.1.3.1 - 1.3.1 Software als Kunsthandwerk [Seite 35]
8.1.3.2 - 1.3.2 Heuristik [Seite 37]
8.1.3.3 - 1.3.3 Ältere Vorstellungen von Software Engineering [Seite 38]
8.1.3.4 - 1.3.4 Fortschritte beim Software Engineering [Seite 39]
8.1.4 - 1.4 Fazit [Seite 40]
8.2 - Kapitel 2: Checklisten [Seite 43]
8.2.1 - 2.1 Eine Gedächtnisstütze [Seite 43]
8.2.2 - 2.2 Checkliste für eine neue Codebasis [Seite 45]
8.2.2.1 - 2.2.1 Git verwenden [Seite 46]
8.2.2.2 - 2.2.2 Build automatisieren [Seite 47]
8.2.2.3 - 2.2.3 Alle Fehlermeldungen aktivieren [Seite 51]
8.2.3 - 2.3 Überprüfungen zu einer vorhandenen Codebasis hinzufügen [Seite 56]
8.2.3.1 - 2.3.1 Schrittweise Verbesserungen [Seite 57]
8.2.3.2 - 2.3.2 Hacken Sie Ihre Organisation [Seite 58]
8.2.4 - 2.4 Fazit [Seite 59]
8.3 - Kapitel 3: Komplexität in den Griff bekommen [Seite 61]
8.3.1 - 3.1 Ziel [Seite 61]
8.3.1.1 - 3.1.1 Nachhaltigkeit [Seite 62]
8.3.1.2 - 3.1.2 Nutzwert [Seite 63]
8.3.2 - 3.2 Warum Programmieren schwierig ist [Seite 65]
8.3.2.1 - 3.2.1 Die Gehirn-Metapher [Seite 65]
8.3.2.2 - 3.2.2 Code wird häufiger gelesen als geschrieben [Seite 66]
8.3.2.3 - 3.2.3 Verständlichkeit [Seite 67]
8.3.2.4 - 3.2.4 Geistige Arbeit [Seite 68]
8.3.3 - 3.3 Software Engineering [Seite 70]
8.3.3.1 - 3.3.1 Beziehung zur Informatik [Seite 71]
8.3.3.2 - 3.3.2 Menschenfreundlicher Code [Seite 71]
8.3.4 - 3.4 Fazit [Seite 72]
8.4 - Kapitel 4: Vertical Slice [Seite 75]
8.4.1 - 4.1 Beginnen Sie mit funktionierender Software [Seite 75]
8.4.1.1 - 4.1.1 Vom Dateneingang zur dauerhaften Datenspeicherung [Seite 76]
8.4.1.2 - 4.1.2 Minimaler Vertical Slice [Seite 77]
8.4.2 - 4.2 Laufendes Skelett [Seite 78]
8.4.2.1 - 4.2.1 Charakterisierungstest [Seite 79]
8.4.2.2 - 4.2.2 Arrange, Act, Assert [Seite 81]
8.4.2.3 - 4.2.3 Lockerung der statischen Analyse [Seite 83]
8.4.3 - 4.3 Von außen nach innen [Seite 85]
8.4.3.1 - 4.3.1 JSON entgegennehmen [Seite 87]
8.4.3.2 - 4.3.2 Eine Reservierung vornehmen [Seite 89]
8.4.3.3 - 4.3.3 Unit-Test [Seite 93]
8.4.3.4 - 4.3.4 DTO und Domänenmodell [Seite 95]
8.4.3.5 - 4.3.5 Fake-Objekt [Seite 98]
8.4.3.6 - 4.3.6 Schnittstelle für das Repository [Seite 99]
8.4.3.7 - 4.3.7 Objekte im Repository erstellen [Seite 99]
8.4.3.8 - 4.3.8 Abhängigkeiten konfigurieren [Seite 101]
8.4.4 - 4.4 Vervollständigen Sie den Slice [Seite 102]
8.4.4.1 - 4.4.1 Schema [Seite 103]
8.4.4.2 - 4.4.2 SQL-Repository [Seite 104]
8.4.4.3 - 4.4.3 Konfiguration mit der Datenbank [Seite 106]
8.4.4.4 - 4.4.4 Führen Sie einen Smoke Test durch [Seite 107]
8.4.4.5 - 4.4.5 Test der Außengrenze mit einer Fake-Datenbank [Seite 108]
8.4.5 - 4.5 Fazit [Seite 110]
8.5 - Kapitel 5: Kapselung [Seite 111]
8.5.1 - 5.1 Speichern Sie die Daten [Seite 111]
8.5.1.1 - 5.1.1 Prämisse der Priorität der Transformation [Seite 111]
8.5.1.2 - 5.1.2 Parametrisierter Test [Seite 113]
8.5.1.3 - 5.1.3 DTO ins Domänenmodell kopieren [Seite 114]
8.5.2 - 5.2 Validierung [Seite 116]
8.5.2.1 - 5.2.1 Ungültige oder fehlende Datumsangaben [Seite 117]
8.5.2.2 - 5.2.2 Rot-Grün-Refactor [Seite 119]
8.5.2.3 - 5.2.3 Natürliche Zahlen [Seite 122]
8.5.2.4 - 5.2.4 Robustheitsgrundsatz [Seite 125]
8.5.3 - 5.3 Schutz von Invarianten [Seite 128]
8.5.3.1 - 5.3.1 Immer gültig [Seite 129]
8.5.4 - 5.4 Fazit [Seite 131]
8.6 - Kapitel 6: Triangulierung [Seite 133]
8.6.1 - 6.1 Kurzzeit- und Langzeitgedächtnis [Seite 133]
8.6.1.1 - 6.1.1 Legacy Code und Gedächtnis [Seite 134]
8.6.2 - 6.2 Kapazität [Seite 136]
8.6.2.1 - 6.2.1 Überbuchung [Seite 136]
8.6.2.2 - 6.2.2 Advokat des Teufels [Seite 139]
8.6.2.3 - 6.2.3 Vorhandene Reservierungen [Seite 142]
8.6.2.4 - 6.2.4 Advokat des Teufels und Rot-Grün-Refactor [Seite 144]
8.6.2.5 - 6.2.5 Wann haben Sie hinreichend viele Tests? [Seite 147]
8.6.3 - 6.3 Fazit [Seite 147]
8.7 - Kapitel 7: Dekomposition [Seite 149]
8.7.1 - 7.1 Code Rot [Seite 149]
8.7.1.1 - 7.1.1 Schwellenwerte [Seite 150]
8.7.1.2 - 7.1.2 Zyklomatische Komplexität [Seite 152]
8.7.1.3 - 7.1.3 Die 80/24-Regel [Seite 153]
8.7.2 - 7.2 Verständlicher Code [Seite 155]
8.7.2.1 - 7.2.1 Hexagonale Blumen [Seite 155]
8.7.2.2 - 7.2.2 Kohäsion [Seite 157]
8.7.2.3 - 7.2.3 Feature-Neid [Seite 161]
8.7.2.4 - 7.2.4 Beim Verschieben verlorengegangen [Seite 162]
8.7.2.5 - 7.2.5 Parsen, nicht überprüfen [Seite 163]
8.7.2.6 - 7.2.6 Fraktale Architektur [Seite 167]
8.7.2.7 - 7.2.7 Variablen zählen [Seite 171]
8.7.3 - 7.3 Fazit [Seite 171]
8.8 - Kapitel 8: API-Design [Seite 173]
8.8.1 - 8.1 Prinzipien des API-Designs [Seite 173]
8.8.1.1 - 8.1.1 Affordanz [Seite 173]
8.8.1.2 - 8.1.2 Poka Yoke [Seite 175]
8.8.1.3 - 8.1.3 Schreiben Sie für die Leser [Seite 177]
8.8.1.4 - 8.1.4 Ziehen Sie sinnvoll benannten Code Kommentaren vor [Seite 178]
8.8.1.5 - 8.1.5 Namen ausixen [Seite 178]
8.8.1.6 - 8.1.6 Trennung von Befehlen und Abfragen [Seite 181]
8.8.1.7 - 8.1.7 Kommunikationshierarchie [Seite 184]
8.8.2 - 8.2 Beispiel für ein API-Design [Seite 185]
8.8.2.1 - 8.2.1 Maître d'hôtel [Seite 186]
8.8.2.2 - 8.2.2 Verwendung eines gekapselten Objekts [Seite 188]
8.8.2.3 - 8.2.3 Implementierungsdetails [Seite 190]
8.8.3 - 8.3 Fazit [Seite 192]
8.9 - Kapitel 9: Zusammenarbeit [Seite 195]
8.9.1 - 9.1 Git [Seite 196]
8.9.1.1 - 9.1.1 Commit-Nachrichten [Seite 196]
8.9.1.2 - 9.1.2 Continuos Integration [Seite 199]
8.9.1.3 - 9.1.3 Kleine Commits [Seite 202]
8.9.2 - 9.2 Gemeinsame Eigentümerschaft am Code [Seite 204]
8.9.2.1 - 9.2.1 Paarprogrammierung [Seite 206]
8.9.2.2 - 9.2.2 Mob-Programmierung [Seite 207]
8.9.2.3 - 9.2.3 Verzögerungen durch Code-Reviews [Seite 208]
8.9.2.4 - 9.2.4 Ablehnung von Änderungen [Seite 210]
8.9.2.5 - 9.2.5 Code-Reviews [Seite 211]
8.9.2.6 - 9.2.6 Pull-Requests [Seite 213]
8.9.3 - 9.3 Fazit [Seite 215]
9 - Teil II: Nachhaltigkeit [Seite 217]
9.1 - Kapitel 10: Erweiterung des Codes [Seite 219]
9.1.1 - 10.1 Feature-Flags [Seite 219]
9.1.1.1 - 10.1.1 Kalender-Flag [Seite 220]
9.1.2 - 10.2 Das Strangler-Pattern [Seite 225]
9.1.2.1 - 10.2.1 Strangler auf Methodenebene [Seite 227]
9.1.2.2 - 10.2.2 Strangler auf Klassenebene [Seite 230]
9.1.3 - 10.3 Versionierung [Seite 234]
9.1.3.1 - 10.3.1 Vorwarnung [Seite 235]
9.1.4 - 10.4 Fazit [Seite 236]
9.2 - Kapitel 11: Bearbeiten von Unit-Tests [Seite 237]
9.2.1 - 11.1 Refactoring von Unit-Tests [Seite 237]
9.2.1.1 - 11.1.1 Änderung des Sicherheitsnetzes [Seite 237]
9.2.1.2 - 11.1.2 Hinzufügen von neuem Testcode [Seite 238]
9.2.1.3 - 11.1.3 Refactoring von Test- und Produktionscode trennen [Seite 241]
9.2.2 - 11.2 Fehlschlagende Tests [Seite 246]
9.2.3 - 11.3 Fazit [Seite 247]
9.3 - Kapitel 12: Fehlerbehebung [Seite 249]
9.3.1 - 12.1 Verstehen [Seite 249]
9.3.1.1 - 12.1.1 Wissenschaftliche Vorgehensweise [Seite 249]
9.3.1.2 - 12.1.2 Vereinfachen [Seite 250]
9.3.1.3 - 12.1.3 Quietscheentchen-Debugging [Seite 252]
9.3.2 - 12.2 Fehler [Seite 253]
9.3.2.1 - 12.2.1 Fehler durch Tests reproduzieren [Seite 254]
9.3.2.2 - 12.2.2 Langsame Tests [Seite 257]
9.3.2.3 - 12.2.3 Nichtdeterministische Fehler [Seite 259]
9.3.3 - 12.3 Bisektion [Seite 264]
9.3.3.1 - 12.3.1 Bisektion mit Git [Seite 264]
9.3.4 - 12.4 Fazit [Seite 268]
9.4 - Kapitel 13: Trennung von Zuständigkeiten [Seite 271]
9.4.1 - 13.1 Komposition [Seite 271]
9.4.1.1 - 13.1.1 Verschachtelte Komposition [Seite 272]
9.4.1.2 - 13.1.2 Sequenzielle Komposition [Seite 275]
9.4.1.3 - 13.1.3 Referenzielle Transparenz [Seite 277]
9.4.2 - 13.2 Cross-Cutting Concerns [Seite 280]
9.4.2.1 - 13.2.1 Logging [Seite 281]
9.4.2.2 - 13.2.2 Decorator [Seite 281]
9.4.2.3 - 13.2.3 Was protokolliert werden sollte [Seite 285]
9.4.3 - 13.3 Fazit [Seite 287]
9.5 - Kapitel 14: Rhythmus [Seite 289]
9.5.1 - 14.1 Persönlicher Rhythmus [Seite 290]
9.5.1.1 - 14.1.1 Zeiteinteilung [Seite 290]
9.5.1.2 - 14.1.2 Pausieren [Seite 291]
9.5.1.3 - 14.1.3 Zeit wohlüberlegt nutzen [Seite 293]
9.5.1.4 - 14.1.4 Blindschreiben [Seite 294]
9.5.2 - 14.2 Team-Rhythmus [Seite 295]
9.5.2.1 - 14.2.1 Regelmäßige Aktualisierung der Abhängigkeiten [Seite 295]
9.5.2.2 - 14.2.2 Andere Dinge planen [Seite 297]
9.5.2.3 - 14.2.3 Gesetz von Conway [Seite 297]
9.5.3 - 14.3 Fazit [Seite 298]
9.6 - Kapitel 15: Die üblichen Verdächtigen [Seite 299]
9.6.1 - 15.1 Performance [Seite 300]
9.6.1.1 - 15.1.1 Altlast [Seite 300]
9.6.1.2 - 15.1.2 Verständlichkeit [Seite 301]
9.6.2 - 15.2 Security [Seite 303]
9.6.2.1 - 15.2.1 STRIDE [Seite 304]
9.6.2.2 - 15.2.2 Spoofing [Seite 305]
9.6.2.3 - 15.2.3 Tampering [Seite 305]
9.6.2.4 - 15.2.4 Repudiation [Seite 307]
9.6.2.5 - 15.2.5 Information Disclosure [Seite 307]
9.6.2.6 - 15.2.6 Denial of Service [Seite 309]
9.6.2.7 - 15.2.7 Elevation of Privilege [Seite 310]
9.6.3 - 15.3 Andere Verfahren [Seite 311]
9.6.3.1 - 15.3.1 Eigenschaft-basiertes Testen [Seite 311]
9.6.3.2 - 15.3.2 Verhaltensbezogene Codeanalyse [Seite 316]
9.6.4 - 15.4 Fazit [Seite 319]
9.7 - Kapitel 16: Tour [Seite 321]
9.7.1 - 16.1 Navigation [Seite 321]
9.7.1.1 - 16.1.1 Das Gesamtbild erkennen [Seite 322]
9.7.1.2 - 16.1.2 Organisation der Dateien [Seite 326]
9.7.1.3 - 16.1.3 Details aufspüren [Seite 328]
9.7.2 - 16.2 Architektur [Seite 329]
9.7.2.1 - 16.2.1 Monolith [Seite 330]
9.7.2.2 - 16.2.2 Zyklen [Seite 331]
9.7.3 - 16.3 Verwendung [Seite 334]
9.7.3.1 - 16.3.1 Aus Tests lernen [Seite 334]
9.7.3.2 - 16.3.2 Schenken Sie den Tests Beachtung [Seite 336]
9.7.4 - 16.4 Fazit [Seite 337]
10 - Anhang A: Liste der Verfahren [Seite 339]
10.1 - A.1 50/72-Regel [Seite 339]
10.2 - A.2 80/24-Regel [Seite 339]
10.3 - A.3 Abhängigkeiten regelmäßig aktualisieren [Seite 340]
10.4 - A.4 Advokat des Teufels [Seite 340]
10.5 - A.5 Arrange, Act, Assert [Seite 340]
10.6 - A.6 Ausnahmen von der Regel begründen [Seite 340]
10.7 - A.7 Bedrohungsmodell [Seite 340]
10.8 - A.8 Bisektion [Seite 341]
10.9 - A.9 Checkliste für eine neue Codebasis [Seite 341]
10.10 - A.10 Code-Reviews [Seite 342]
10.11 - A.11 Decorators für Cross-Cutting Concerns [Seite 342]
10.12 - A.12 Feature-Flag [Seite 342]
10.13 - A.13 Fehler als Tests reproduzieren [Seite 342]
10.14 - A.14 Functional Core, Imperative Shell [Seite 342]
10.15 - A.15 Kommunikationshierarchie [Seite 343]
10.16 - A.16 Namen ausixen [Seite 343]
10.17 - A.17 Parsen, nicht überprüfen [Seite 343]
10.18 - A.18 Robustheitsgrundsatz [Seite 344]
10.19 - A.19 Rot-Grün-Refactor [Seite 344]
10.20 - A.20 Refactoring von Test- und Produktionscode trennen [Seite 344]
10.21 - A.21 Semantische Versionierung [Seite 345]
10.22 - A.22 Slice [Seite 345]
10.23 - A.23 Strangler [Seite 345]
10.24 - A.24 Prämisse der Priorität der Transformation [Seite 345]
10.25 - A.25 Trennung von Befehlen und Abfragen [Seite 346]
10.26 - A.26 X-getriebene Entwicklung [Seite 346]
10.27 - A.27 Zählen der Variablen [Seite 346]
10.28 - A.28 Zyklomatische Komplexität [Seite 346]
11 - Anhang B: Bibliografie [Seite 347]
12 - Stichwortverzeichnis [Seite 357]