Langlebige Software-Architekturen, 3rd Edition

Table of contents

1. Cover
2. Über den Autor
3. Titel
4. Impressum
5. Geleitwort
6. Vorwort zur 3. Auflage
7. Vorwort zur 2. Auflage
8. Vorwort zur 1. Auflage
9. Inhaltsverzeichnis
10. 1 Einleitung
    1. 1.1 Softwarearchitektur
    2. 1.2 Langlebigkeit
    3. 1.3 Technische Schulden
    4. 1.3.1 »Programmieren kann jeder!«
    5. 1.3.2 Komplexität und Größe
    6. 1.3.3 Die Architekturerosion steigt unbemerkt
    7. 1.3.4 Für Qualität bezahlen wir nicht extra!
    8. 1.3.5 Arten von technischen Schulden
    9. 1.4 Was ich mir alles anschauen durfte
    10. 1.5 Wer sollte dieses Buch lesen?
    11. 1.6 Wegweiser durch das Buch
11. 2 Aufspüren von technischen Schulden
    1. 2.1 Begriffsbildung für Bausteine
    2. 2.2 Soll- und Ist-Architektur
    3. 2.3 Verbesserung am lebenden System
    4. 2.4 False Positives und generierter Code
    5. 2.5 Spickzettel zum Sotographen
12. 3 Architektur in Programmiersprachen
    1. 3.1 Java-Systeme
    2. 3.2 C#-Systeme
    3. 3.3 C++-Systeme
    4. 3.4 ABAP-Systeme
    5. 3.5 PHP-Systeme
    6. 3.6 TypeScript-Systeme
13. 4 Architekturanalyse und -verbesserung
    1. 4.1 Entwickler und Architektur
    2. 4.2 Architekturarbeit ist eine Holschuld
    3. 4.3 Live-Workshop zur Architekturverbesserung
    4. 4.4 Der Umgang mit den Vätern und Müttern
    5. 4.5 Modularity Maturity Index (MMI)
    6. 4.6 Technische Schulden im Lebenszyklus
14. 5 Kognitive Psychologie und Architekturprinzipien
    1. 5.1 Modularität
    2. 5.1.1 Chunking
    3. 5.1.2 Übertragung auf Entwurfsprinzipien
    4. 5.1.2.1 Einheiten
    5. 5.1.2.2 Schnittstellen
    6. 5.1.2.3 Kopplung
    7. 5.2 Musterkonsistenz
    8. 5.2.1 Aufbau von Schemata
    9. 5.2.2 Übertragung auf Entwurfsprinzipien
    10. 5.3 Hierarchisierung
    11. 5.3.1 Bildung von Hierarchien
    12. 5.3.2 Übertragung auf Entwurfsprinzipien
    13. 5.4 Zyklen = misslungene Modularität + Muster
    14. 5.5 Konsequenzen für die Architekturanalyse
15. 6 Architekturstile gegen technische Schulden
    1. 6.1 Regeln von Architekturstilen
    2. 6.2 Trennung von fachlichen und technischen Bausteinen
    3. 6.3 Schichtenarchitekturen
    4. 6.3.1 Technische Schichtung
    5. 6.3.2 Fachliche Schichtung
    6. 6.3.3 Infrastrukturschicht
    7. 6.3.4 Integration von fachlichen Schichten
    8. 6.4 Hexagonal, Onion und Clean Architecture
    9. 6.5 Microservices und Domain-Driven Design
    10. 6.6 Mustersprachen
    11. 6.6.1 WAM-Mustersprache
    12. 6.6.2 DDD-Mustersprache
    13. 6.6.3 Typische Framework-Muster
    14. 6.7 Langlebigkeit und Architekturstile
16. 7 Muster in Softwarearchitekturen
    1. 7.1 Abbildung der Soll-Architektur auf die Ist-Architektur
    2. 7.2 Die ideale Struktur: fachlich oder technisch?
    3. 7.3 Schnittstellen von Bausteinen
    4. 7.4 Interfaces – das architektonische Allheilmittel?
    5. 7.4.1 Die Basistherapie
    6. 7.4.2 Die Nebenwirkungen
    7. 7.4.3 Feldstudien am lebenden Patienten
    8. 7.4.4 Der Kampf mit dem Monolithen
    9. 7.5 Der Wunsch nach Microservices
    10. 7.5.1 Früh übt sich
    11. 7.5.2 Der Knackpunkt: das Domänenmodell
17. 8 Mustersprachen – der architektonische Schatz!
    1. 8.1 Die Schatzsuche
    2. 8.2 Die Ausgrabungsarbeiten
    3. 8.3 Aus der Schatztruhe
    4. 8.4 Den Goldanteil bestimmen
    5. 8.5 Jahresringe
    6. 8.6 Unklare Muster führen zu Zyklen
18. 9 Chaos in Schichten – der tägliche Schmerz
    1. 9.1 Bewertung des Durcheinanders
    2. 9.1.1 Ausmaß der Unordnung
    3. 9.1.1.1 Architekturstile und Zyklen
    4. 9.1.1.2 Programmzeilen in Zyklen
    5. 9.1.1.3 Dependency Injection und Zyklen
    6. 9.1.2 Umfang und Verflochtenheit
    7. 9.1.3 Reichweite in der Architektur
    8. 9.2 Das große Wirrwarr
    9. 9.2.1 Der Schwarze-Loch-Effekt
    10. 9.2.2 Der Befreiungsschlag
    11. 9.2.3 Technische Schichtung als Waffe
    12. 9.2.4 Mustersprache als Leuchtturm
    13. 9.3 Uneven Modules
19. 10 Modularität schärfen
    1. 10.1 Kohäsion von Bausteinen
    2. 10.2 Größen von Bausteinen
    3. 10.3 Größen von Klassen
    4. 10.4 Größe und Komplexität von Methoden
    5. 10.5 Lose Kopplung
    6. 10.6 Kopplung und Größe von Klassen
    7. 10.7 Wie modular sind Sie?
20. 11 Geschichten aus der Praxis
    1. 11.1 Das Java-System Alpha
    2. 11.2 Das C#-System Gamma
    3. 11.3 Das C++-System Beta
    4. 11.4 Das Java-System Delta
    5. 11.5 Das Java-System Epsilon mit C#-Satelliten
    6. 11.5.1 Java-Epsilon
    7. 11.5.2 C#-Epsilon 1
    8. 11.5.3 C#-Epsilon 2
    9. 11.6 Das ABAP-System Lambda
21. 12 Fazit: der Weg zu langlebigen Architekturen
22. Anhang
    1. A Analysewerkzeuge
    2. A.1 Lattix
    3. A.2 Sonargraph Architect
    4. A.3 Sotograph und SotoArc
    5. A.4 Structure101
23. Literatur
24. Fußnoten
25. Index