Langlebige Software-Architekturen

Table of contents

1. Cover
2. Titel
3. Impressum
4. Geleitwort
5. Vorwort
6. Inhaltsverzeichnis
7. Kapitel 1: Einleitung
   1. 1.1 Softwarearchitektur
   2. 1.2 Langlebigkeit
   3. 1.3 Technische Schulden
      1. 1.3.1 »Programmieren kann jeder!«
      2. 1.3.2 Komplexität und Größe
      3. 1.3.3 Die Architekturerosion steigt unbemerkt
      4. 1.3.4 Für Qualität bezahlen wir nicht extra!
      5. 1.3.5 Arten von technischen Schulden
   4. 1.4 Was ich mir alles anschauen durfte
   5. 1.5 Wer sollte dieses Buch lesen?
   6. 1.6 Wegweiser durch das Buch
8. Kapitel 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
9. Kapitel 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
10. Kapitel 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 Technische Schulden im Lebenszyklus
11. Kapitel 5: Kognitive Psychologie und Architekturprinzipien
    1. 5.1 Modularität
       1. 5.1.1 Chunking
       2. 5.1.2 Übertragung auf Entwurfsprinzipien
          1. 5.1.2.1 Einheiten
          2. 5.1.2.2 Schnittstellen
          3. 5.1.2.3 Kopplung
    2. 5.2 Musterkonsistenz
       1. 5.2.1 Aufbau von Schemata
       2. 5.2.2 Übertragung auf Entwurfsprinzipien
    3. 5.3 Hierarchisierung
       1. 5.3.1 Bildung von Hierarchien
       2. 5.3.2 Übertragung auf Entwurfsprinzipien
    4. 5.4 Zyklen = misslungene Modularität + Muster
    5. 5.5 Konsequenzen für die Architekturanalyse
12. Kapitel 6: Architekturstile gegen technische Schulden
    1. 6.1 Regeln von Architekturstilen
    2. 6.2 Trennung von fachlichen und technischen Bausteinen
    3. 6.3 Schichtenarchitekturen
       1. 6.3.1 Technische Schichtung
       2. 6.3.2 Fachliche Schichtung
       3. 6.3.3 Infrastrukturschicht
       4. 6.3.4 Integration von fachlichen Schichten
    4. 6.4 Microservices
    5. 6.5 Mustersprachen
       1. 6.5.1 WAM-Mustersprache
       2. 6.5.2 DDD-Mustersprache
       3. 6.5.3 Typische Framework-Muster
    6. 6.6 Langlebigkeit und Architekturstile
13. Kapitel 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?
       1. 7.4.1 Die Basistherapie
       2. 7.4.2 Die Nebenwirkungen
       3. 7.4.3 Feldstudien am lebenden Patienten
    5. 7.5 Die Schatzsuche
    6. 7.6 Der Kampf mit dem Monolithen
14. Kapitel 8: Mustersprachen – der architektonische Schatz!
    1. 8.1 Die Ausgrabungsarbeiten
    2. 8.2 Aus der Schatztruhe
    3. 8.3 Den Goldanteil bestimmen
    4. 8.4 Jahresringe
15. Kapitel 9: Chaos in Schichten – der tägliche Schmerz
    1. 9.1 Bewertung des Durcheinanders
       1. 9.1.1 Ausmaß der Unordnung
          1. 9.1.1.1 Architekturstile und Zyklen
          2. 9.1.1.2 Programmzeilen in Zyklen
          3. 9.1.1.3 Dependency Injection und Zyklen
       2. 9.1.2 Umfang und Verflochtenheit
       3. 9.1.3 Reichweite in der Architektur
    2. 9.2 Das große Wirrwarr
       1. 9.2.1 Der Schwarze-Loch-Effekt
       2. 9.2.2 Der Befreiungsschlag
       3. 9.2.3 Technische Schichtung als Waffe
       4. 9.2.4 Mustersprache als Leuchtturm
    3. 9.3 Uneven Modules
16. Kapitel 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?
17. Kapitel 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
       1. 11.5.1 Java-Epsilon
       2. 11.5.2 C#-Epsilon 1
       3. 11.5.3 C#-Epsilon 2
    6. 11.6 Das ABAP-System Lambda
18. Kapitel 12: Fazit: der Weg zu langlebigen Architekturen
19. Anhang
    1. A Analysewerkzeuge
       1. A.1 Lattix
       2. A.2 Sonargraph Architect
       3. A.3 Sotograph und SotoArc
       4. A.4 Structure101
20. Literatur
21. Index
22. Fußnoten