O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Langlebige Software-Architekturen

Book Description

  • einfache und einleuchtende Strukturierung aller wichtigen Grundkonzepte im Bereich Softwarearchitektur, die die typischen Fehler in der Softwarearchitektur von großen Softwaresystemen aufzeigen und sinnvolle Lösungen vermitteln* viele Beispiele aus realen Architekturanalysen bzw. aus dem Projektalltag

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