Be Software Architecture Wise
Be Wise Apps

Read in English · Leer en español · Lire en français

Kapitel 3 von 12 · Mittelstufe

Designprinzipien und Grundlagen

Jede Architektur baut auf denselben wenigen Ideen über Struktur auf: wie man ein System in Teile zerlegt, wie viel diese Teile voneinander wissen sollten, in welche Richtung ihre Abhängigkeiten zeigen sollten und wie man das Ganze so einfach hält, wie das Problem es erlaubt. Dieses Kapitel vermittelt diese Ideen auf jeder Ebene, von einer Python-Klasse über eine Komponente bis zu einer ganzen Flotte von Services: Modularität, Kopplung und Kohäsion, Information Hiding, Abhängigkeitsmanagement, SOLID, Connascence, das Gesetz von Conway, Einfachheit und die Metriken, mit denen man Struktur misst. Es eignet sich für Entwicklerinnen und Entwickler, die präzise über Design nachdenken wollen, und für Architekturfachleute, die ein gemeinsames Vokabular für Reviews brauchen.

Videoeinführung in Kapitel 3

6 Min. · auf Englisch gesprochen, mit Untertiteln
Nur anhören (Audio)
Transkript lesen

Willkommen zu Kapitel 3: Designprinzipien und Grundlagen. Jede Architektur baut auf denselben wenigen Ideen über Struktur auf. Wie man ein System in Teile zerlegt, wie viel diese Teile voneinander wissen sollten, wohin ihre Abhängigkeiten zeigen sollten und wie man das Ganze so einfach hält, wie das Problem es erlaubt. Dieses Kapitel vermittelt diese Ideen.

Kapitel 2 hat die Qualitäten beschrieben, die eine Architektur liefern muss. Die meisten davon, allen voran die Änderbarkeit, hängen weniger von einer bestimmten Technologie ab als von der Struktur. Ein Team kann das angesagteste Framework wählen und trotzdem ein System bekommen, in dem jede Änderung zehn Stellen berührt. Diese Prinzipien sind alte Ideen. Information Hiding stammt aus dem Jahr neunzehnhundertzweiundsiebzig, das Gesetz von Conway aus dem Jahr neunzehnhundertachtundsechzig. Sie haben überdauert, weil sie etwas beschreiben, das sich nicht ändert: Die Kosten einer Änderung hängen davon ab, wie weit sie sich ausbreiten muss. Geändert hat sich die Ebene. Das Prinzip, das Ihnen rät, die Felder einer Klasse privat zu halten, rät Ihnen auch, die Datenbank eines Service privat zu halten. Deshalb zeigt jeder Abschnitt jede Idee zweimal: in einem kleinen Stück Code und auf der Ebene von Komponenten und Services.

Dieses Kapitel eignet sich für Entwicklungsteams, die präzise über Design nachdenken wollen. Es eignet sich auch für Architekturfachleute, die ein gemeinsames Vokabular für Design-Reviews brauchen. Es hilft, kurze Python-Beispiele lesen zu können. Es baut auf den Qualitätsmerkmalen aus Kapitel 2 auf, die diese Prinzipien erreichen helfen. Es lohnt sich, Abschnitt null Punkt drei über das Organisieren von Code und Abschnitt zwei Punkt sechs über das Design für Veränderung gelesen zu haben. Und es führt zu Kapitel 4, das zeigt, wie man eine Struktur so beschreibt, dass andere sie verstehen und hinterfragen können.

Die ersten vier Abschnitte legen die Grundlagen. Abschnitt drei Punkt eins fragt, was ein Modul ist und wo seine Grenzen verlaufen sollten. David Parnas zeigte, dass eine Zerlegung nach Verarbeitungsschritten scheitert und eine Zerlegung nach wahrscheinlichen Änderungen gelingt. Abschnitt drei Punkt zwei liefert Ihnen das Vokabular, um Grenzen zu beurteilen: die klassischen Stufen von Kopplung und Kohäsion und die Arten von Kopplung, die nur zwischen Services auftreten. Abschnitt drei Punkt drei betrachtet die Schnittstelle selbst: Information Hiding, Verträge, Abstraktionen, die lecken, und warum sich am Ende jemand auf jedes sichtbare Verhalten einer populären Schnittstelle verlässt. Abschnitt drei Punkt vier wendet sich der Richtung zu: wohin Abhängigkeiten zeigen sollten, wie man Stabilität misst, wie man Zyklen auflöst und wie man all das automatisch prüft.

Dieses Diagramm aus Abschnitt drei Punkt zwei zeigt das Vokabular in einem echten Refactoring bei der Arbeit. Links sehen Sie das Design vorher: ein Bestellmodul und ein Abrechnungsmodul. Das Bestellmodul ruft das Abrechnungsmodul direkt auf und übergibt ein Flag, das eines von zwei Verhalten auswählt. Das Bestellmodul muss also dieses Flag kennen und kann keine Bestellung annehmen, wenn die Abrechnung langsam ist oder ausfällt. Schlimmer noch: Beide Module nutzen dieselbe Bestelltabelle. Jede Änderung an ihrem Aufbau, ihren Statuscodes oder ihren Mehrwertsteuerregeln muss in beiden Modulen gleichzeitig erfolgen. Rechts sehen Sie das Design nachher. Das Bestellmodul veröffentlicht ein OrderPlaced-Ereignis an einen Message Broker, das genau die Fakten enthält, die die Abrechnung braucht. Die Abrechnung abonniert es, und jeder Service besitzt seine eigenen Daten. Die Kopplung ist nicht verschwunden: Die Abrechnung hängt weiterhin von der Bedeutung dieses Ereignisses ab. Aber sie ist jetzt explizit, schmal und versioniert, und genau das bedeutet lose Kopplung in der Praxis.

Die zweiten vier Abschnitte bauen auf diesen Grundlagen auf. Abschnitt drei Punkt fünf behandelt die fünf SOLID-Prinzipien, jeweils im Code und zwischen Services gezeigt, zusammen mit der Kritik, die sie bei mechanischer Anwendung auf sich ziehen. Abschnitt drei Punkt sechs führt Connascence ein, ein feineres Maß für Kopplung, mit klaren Regeln, wie man sie schwächer und lokaler macht. Abschnitt drei Punkt sieben weitet den Blick auf die Organisation: das Gesetz von Conway, die Belege dafür und die Arithmetik der Kommunikationspfade. Abschnitt drei Punkt acht schließt mit Einfachheit und Messung: der Komplexität, die zum Problem gehört, und der, die wir selbst hinzufügen, dem Preis offener Optionen und den Grenzen aller Metriken.

Hier ist das Gesetz von Conway in einem Bild. Links sehen Sie eine Organisation. Ein Checkout-Team und ein Katalogteam müssen für jede Schemaänderung über ein gemeinsames Team von Datenbankadministratoren gehen. Rechts sehen Sie das System, das sie bauen: einen Checkout-Service und einen Katalogservice, die beide eine gemeinsame Datenbank lesen und schreiben. Die Struktur des Systems bildet die Struktur der Kommunikation nach. Wenn Sie also ein System entwerfen, entwerfen Sie auch, wer mit wem reden muss, und umgekehrt gilt das genauso.

Zusammen gelesen ergeben die acht Abschnitte ein einziges Argument. Änderungen sind der dominierende Kostenfaktor von Software, also ist eine gute Struktur eine, in der wahrscheinliche Änderungen lokal bleiben. Jedes Prinzip in diesem Kapitel ist ein Weg, das zu erreichen. Deshalb geraten die Prinzipien auch manchmal in Konflikt, und keines gilt absolut. Die professionelle Fähigkeit besteht darin, für eine in diesem System wahrscheinliche Änderung zu fragen, wie weit sie sich ausbreiten müsste und welches Prinzip diese Strecke am günstigsten verkürzt.

Wenn Design neu für Sie ist, lesen Sie die Abschnitte der Reihe nach. Jeder beginnt mit einer kurzen Erklärung aus dem Alltag. Das ganze Kapitel zu lesen dauert etwa drei Stunden. Wenn Sie erfahren sind, beginnen Sie vielleicht lieber mit den ausgearbeiteten Beispielen, etwa dem Onlineshop in Abschnitt drei Punkt eins oder der Metrikberechnung in Abschnitt drei Punkt vier. Sie sind dafür gedacht, dass man darüber streitet. Jeder Abschnitt endet mit einigen Fragen zur Selbstkontrolle. Beantworten Sie sie im Kopf, bevor Sie nachsehen. Wenn Sie so weit sind, machen Sie den optionalen Kapiteltest: zwanzig Multiple-Choice-Fragen und zwei schriftliche Antworten in etwa fünfundvierzig Minuten. Die Bestehensgrenze liegt bei achtzig Prozent.

Das ist die Landkarte von Kapitel 3. Beginnen Sie mit Abschnitt drei Punkt eins über Modularität, wo wir sehen, wie man ein System so zerlegt, dass die erwarteten Änderungen in einem Teil bleiben. Bis gleich.

Kapitel herunterladen (PDF)In der App lesen

Auf einen Blick

Das lernen Sie

  • Das Kriterium von Parnas für die Zerlegung eines Systems in Module erklären und damit zwei mögliche Zerlegungen vergleichen.
  • Abhängigkeiten anhand der klassischen Stufen von Kopplung und Kohäsion einordnen und zeitliche, Deployment- und semantische Kopplung zwischen Services erkennen.
  • Information Hiding von Kapselung unterscheiden, eine Schnittstelle als Vertrag spezifizieren und stabile APIs entwerfen, die Leaky Abstractions und Hyrums Gesetz berücksichtigen.
  • Instabilität, Abstraktheit und den Abstand von der Hauptreihe berechnen und sie zusammen mit dem Acyclic Dependencies Principle, dem Stable Dependencies Principle und dem Stable Abstractions Principle nutzen, um Abhängigkeitsstrukturen zu verbessern.
  • Die SOLID-Prinzipien und die Kohäsionsprinzipien für Komponenten auf Klassen-, Komponenten- und Service-Ebene anwenden und erkennen, wann sie dogmatisch angewandt werden.
  • Mit Connascence Stärke, Lokalität und Grad der Kopplung beschreiben und Refactorings wählen, die sie abschwächen.
  • Das Gesetz von Conway, die Belege dafür und das Inverse Conway Maneuver erklären und die Kommunikationspfade eines Teams berechnen.
  • Essenzielle von akzidenteller Komplexität trennen, die zyklomatische Komplexität berechnen und strukturelle Regeln in Fitness Functions umsetzen, ohne in die Falle von Goodharts Gesetz zu tappen.

Bevor Sie beginnen

Kapitel 0 bis 2, insbesondere Abschnitt 0.3 (Code organisieren), Abschnitt 1.7 (technische Schulden) und Abschnitt 2.6 (Änderbarkeit). Es hilft, kurze Python-Beispiele lesen zu können.

Zeit

Etwa 3 Stunden Lesezeit; 45 Minuten für den Test.

Schlüsselbegriffe

Modularität · Information Hiding · Kopplung · Kohäsion · afferente und efferente Kopplung · Abstraktion · Design by Contract · Hyrums Gesetz · Acyclic Dependencies Principle · Instabilität und Abstraktheit · SOLID · Connascence · Gesetz von Conway · akzidentelle Komplexität

Warum Prinzipien, und warum auf jeder Ebene

Kapitel 2 hat die Qualitäten beschrieben, die eine Architektur liefern muss. Die meisten davon, allen voran die Änderbarkeit, hängen weniger von einer bestimmten Technologie ab als von der Struktur: wie ein System in Teile zerlegt ist, was jeder Teil über die anderen weiß und in welche Richtung die Abhängigkeiten zwischen ihnen verlaufen. Ein Team kann das angesagteste Framework und die beste Cloud-Plattform wählen und trotzdem bei einem System landen, in dem jede Änderung zehn Stellen berührt, weil die Teile an den falschen Stellen geschnitten wurden. Die Prinzipien in diesem Kapitel sind das gesammelte Wissen aus mehr als fünfzig Jahren darüber, wie man sie gut schneidet.

Es sind alte Ideen, und das ist eine Stärke. Information Hiding stammt aus dem Jahr 1972, Kopplung und Kohäsion aus der Arbeit am Structured Design Ende der 1960er- und in den 1970er-Jahren, das Gesetz von Conway aus dem Jahr 1968. Sie haben überdauert, weil sie etwas beschreiben, das sich nicht ändert: Die Kosten einer Änderung hängen davon ab, wie weit sich die Änderung ausbreiten muss. Geändert hat sich die Ebene, auf der Architekturfachleute sie anwenden. Dasselbe Prinzip, das Ihnen rät, die Felder einer Klasse privat zu halten, rät Ihnen, die Datenbank eines Service privat zu halten; dieselbe Überlegung, die einen Abhängigkeitszyklus zwischen zwei Paketen verbietet, verbietet zwei Services, die sich nur gemeinsam releasen lassen. Jeder Abschnitt zeigt daher jede Idee zweimal: in einem kleinen Stück Code und auf der Ebene von Komponenten und Services.

Wie das Kapitel aufgebaut ist

Die ersten vier Abschnitte legen die Grundlagen. Abschnitt 3.1 fragt, was ein Modul ist und wo seine Grenzen verlaufen sollten. Er zeigt an David Parnas’ KWIC-Beispiel, warum eine Zerlegung nach Verarbeitungsschritten scheitert und eine Zerlegung nach wahrscheinlichen Änderungen gelingt, und unterscheidet logische Module von den physischen Einheiten, die gebaut und deployt werden. Abschnitt 3.2 liefert das Vokabular, um Grenzen zu beurteilen: die klassischen Stufen von Kopplung und Kohäsion, afferente und efferente Kopplung sowie die Arten von Kopplung, die nur zwischen Services auftreten. Abschnitt 3.3 betrachtet die Schnittstelle selbst: Information Hiding im Vergleich zur Kapselung, Verträge, Leaky Abstractions, tiefe Module und Hyrums Gesetz. Abschnitt 3.4 wendet sich der Richtung zu: Robert C. Martins Prinzipien für Abhängigkeiten zwischen Komponenten, die Metriken Instabilität und Abstraktheit, wie man Zyklen auflöst, Schichtenbildung und wie man all das automatisch prüft.

Die zweiten vier Abschnitte bauen darauf auf. Abschnitt 3.5 behandelt die fünf SOLID-Prinzipien und die Kohäsionsprinzipien für Komponenten, jeweils im Code und zwischen Services gezeigt, zusammen mit der Kritik, die sie auf sich ziehen, wenn man sie mechanisch anwendet. Abschnitt 3.6 führt Connascence ein, ein feineres Maß für Kopplung mit klaren Regeln, wie man sie schwächer und lokaler macht. Abschnitt 3.7 weitet den Blick auf die Organisation: das Gesetz von Conway, die Belege dafür, die Arithmetik der Kommunikationspfade und das Inverse Conway Maneuver. Abschnitt 3.8 schließt mit Einfachheit und Messung: essenzielle und akzidentelle Komplexität, KISS, YAGNI und DRY richtig verstanden, der Preis dafür, Optionen offenzuhalten, Strukturmetriken wie die zyklomatische Komplexität und die Grenzen aller Metriken.

Eine Idee unter allen

Zusammen gelesen ergeben die acht Abschnitte ein einziges Argument. Änderungen sind der dominierende Kostenfaktor von Software, also ist eine gute Struktur eine, in der wahrscheinliche Änderungen lokal bleiben. Jedes Prinzip in diesem Kapitel ist ein Weg, das zu erreichen. Parnas sagt: Bringen Sie jede wahrscheinliche Änderung in einem Modul unter. Kopplung und Kohäsion sagen: Halten Sie zusammen, was sich gemeinsam ändert, und trennen Sie, was sich getrennt ändert. Information Hiding sagt: Sorgen Sie dafür, dass das, was sich ändern kann, von außen unsichtbar ist. Die Abhängigkeitsprinzipien sagen: Lassen Sie Abhängigkeiten auf das zeigen, was sich am wenigsten ändert. Connascence sagt: Halten Sie jede starke Übereinkunft zwischen zwei Codestücken so nah beieinander wie möglich. Das Gesetz von Conway ergänzt, dass Menschen Teil der Struktur sind: Eine Änderung, für die sich zwei Teams einigen müssen, ist nicht lokal, wie auch immer der Code angeordnet ist.

Dieses Argument erklärt auch, warum die Prinzipien manchmal in Konflikt geraten und warum keines absolut gilt. Das Entfernen von Duplikation kann die Kopplung erhöhen; Schnittstellen, die eine Abhängigkeit umkehren, können ein Modul flacher machen; das Aufteilen einer Komponente zugunsten der Kohäsion kann einen Netzwerksprung erzeugen. Die professionelle Fähigkeit besteht nicht darin, jedes Prinzip überall anzuwenden, sondern für eine bestimmte Änderung, die in einem bestimmten System wahrscheinlich ist, zu fragen, wie weit sie sich ausbreiten müsste und welches Prinzip diese Strecke zu den geringsten Kosten verkürzt.

Wie Sie dieses Kapitel nutzen

Wer neu im Design ist, kann die Abschnitte der Reihe nach lesen; jeder beginnt mit einer kurzen Erklärung aus dem Alltag und verweist auf Abschnitt 0.3, wo die Grundlagen zuerst eingeführt wurden. Erfahrene Fachleute möchten vielleicht mit den ausgearbeiteten Beispielen beginnen: Die Zerlegung des Onlineshops in Abschnitt 3.1, das Refactoring von Bestellung und Abrechnung in Abschnitt 3.2, die Zahlungsschnittstelle in Abschnitt 3.3 und die Metrikberechnung in Abschnitt 3.4 sind dafür gedacht, dass man darüber streitet. Die Prinzipien hier werden im ganzen restlichen Kurs verwendet: Die Architekturstile der Kapitel 5 und 6 sind weitgehend unterschiedliche Antworten auf die Fragen, wo Grenzen verlaufen und in welche Richtung Abhängigkeiten zeigen, und Kapitel 11 macht aus den hier eingeführten automatisierten Prüfungen eine Governance-Praxis mithilfe von Fitness Functions.

Die 8 Abschnitte

3.1 · Mittelstufe · 22 Min.ModularitätWas ein Modul auf jeder Ebene ist, warum wir Systeme in Module zerlegen, Parnas’ Regel, nach wahrscheinlichen Änderungen zu zerlegen, logische gegenüber Deployment-Modulen, Granularität und wie man Grenzen im Code durchsetzt.Lesen →3.2 · Mittelstufe · 24 Min.Kopplung und KohäsionDie beiden ältesten Maße guter Struktur: die klassischen Stufen von Kopplung und Kohäsion, afferente und efferente Kopplung, die zusätzlichen Formen der Kopplung in verteilten Systemen und Taktiken, sie zu lockern, mit einem durchgearbeiteten Refactoring.Lesen →3.3 · Mittelstufe · 24 Min.Information HidingWarum Module Entscheidungen verbergen sollten, wie sich Information Hiding von Kapselung unterscheidet, Schnittstellen als Verträge und Design by Contract, Leaky Abstractions, tiefe Module, Hyrums Gesetz und wie man APIs zwischen Komponenten stabil hält.Lesen →3.4 · Mittelstufe · 25 Min.AbhängigkeitenIn welche Richtung Abhängigkeiten zeigen sollten und warum: Robert C. Martins Prinzipien der azyklischen Abhängigkeiten, der stabilen Abhängigkeiten und der stabilen Abstraktionen, die Metriken Instabilität, Abstraktheit und Distanz, Zyklen auflösen, Schichtenbildung und automatisierte Abhängigkeitsprüfungen.Lesen →3.5 · Mittelstufe · 26 Min.SOLID im GroßenDie fünf SOLID-Prinzipien präzise erklärt, jedes in Python und dann auf Komponenten- und Service-Ebene gezeigt, dazu die Kohäsionsprinzipien REP, CCP und CRP, ihr Spannungsdreieck und die berechtigte Kritik an SOLID.Lesen →3.6 · Mittelstufe · 22 Min.ConnascenceMeilir Page-Jones’ Connascence benennt die verborgenen Absprachen zwischen Teilen eines Systems, ordnet sie nach Stärke und beurteilt sie nach Lokalität und Grad, von Positionsparametern bis zum Timing zwischen Services.Lesen →3.7 · Mittelstufe · 22 Min.Gesetz von ConwayMelvin Conways Beobachtung von 1968, dass Systeme die Kommunikationsstruktur der Organisationen nachbilden, die sie entwerfen, die Belege aus der Forschung, die Arithmetik der Kommunikationspfade, das Inverse Conway Maneuver und die kognitive Last des Teams.Lesen →3.8 · Mittelstufe · 25 Min.Einfachheit und MessungEssenzielle und akzidentelle Komplexität, KISS, YAGNI, DRY als Wissen statt als Text, Umkehrbarkeit als Option und wie man Struktur mit zyklomatischer Komplexität, LCOM, Change Coupling und Fitness Functions misst, ohne Goodharts Gesetz zum Opfer zu fallen.Lesen →

Kapiteltest

Prüfen Sie Ihr Verständnis von Kapitel 3

Optional: 20 Multiple-Choice-Fragen und 2 kurze schriftliche Antworten, jedes Mal neu aus einem Pool von 72 Fragen gezogen. Bestehensgrenze 80 %. Wer jeden Kapiteltest und anschließend die Abschlussbewertung besteht, erhält das Be Wise Abschlusszertifikat.

Den Test zu Kapitel 3 in der App ablegen

Weiterführende Literatur