Modulare Software-Architektur nach dem Blackbox-Prinzip

Wie Sie Module schneiden, Schnittstellen stabil halten und Erweiterungen über Plugins und Formate ermöglichen
Aktualisiert:
Abstract
- #Software-Architektur
- #Modularisierung
- #Blackbox-Prinzip
- #Plugin-Architektur
- #Format-Design
- #API-Design
- #Kopplung und Kohäsion
- #Systemarchitektur
- #Langfristige Wartbarkeit
- #Evolutionäre Architektur
Was ein Modul nach außen verrät, entscheidet, wie lange sich eine Software noch ändern lässt
Angenommen, ein Team entwickelt seit zehn Jahren eine Software für die Einsatzplanung in Pflegediensten. Der ursprüngliche Entwickler ist längst weg, die Datenbank wurde zweimal gewechselt, und nun soll eine mobile App hinzukommen. Ob das ein Projekt von drei Wochen oder von einem Jahr wird, hängt kaum von der Programmiersprache ab. Es hängt davon ab, wie viel die einzelnen Teile der Software voneinander wissen.
Die Idee, Software in Bausteine zu zerlegen, deren Inneres niemanden etwas angeht, ist alt. Der Informatiker David Parnas beschrieb sie 1972 als Geheimnisprinzip (Information Hiding): Ein Modul soll genau eine Entwurfsentscheidung verbergen, die sich ändern könnte. Das Blackbox-Prinzip greift diesen Gedanken auf und macht ihn zum Maßstab für die gesamte Architektur, von der Aufteilung eines Programms bis zur Gestaltung von Dateiformaten und Plugin-Schnittstellen.
Was eine Blackbox ausmacht
Ein Modul ist eine Blackbox, wenn andere Teile des Systems es ausschließlich über eine dokumentierte Schnittstelle benutzen. Wie es intern arbeitet, welche Datenstrukturen es verwendet und welche Bibliotheken es einbindet, bleibt verborgen. Solange die Schnittstelle gleich bleibt, darf das Innere jederzeit neu geschrieben werden.
Das klingt selbstverständlich, wird im Alltag aber ständig unterlaufen. Typische Lecks sind:
- ein Modul, das direkt auf die Datenbanktabellen eines anderen zugreift, statt dessen Funktionen aufzurufen,
- Rückgabewerte, die interne Objekte oder Datenbankentitäten unverändert nach außen geben,
- Konfigurationswerte oder globale Variablen, über die Module heimlich miteinander kommunizieren,
- Fehlermeldungen, die Details der Implementierung preisgeben, auf die sich Aufrufer dann verlassen.
Jedes dieser Lecks schafft eine unsichtbare Abhängigkeit. Ändert sich das Innere, bricht Code an einer Stelle, mit der niemand gerechnet hat.
In TypeScript lässt sich eine Blackbox-Schnittstelle zum Beispiel so beschreiben:
// Öffentliche Schnittstelle des Moduls „Einsatzplanung“
export interface Einsatz {
id: string;
mitarbeiterId: string;
beginn: Date;
ende: Date;
}
export interface Einsatzplanung {
planeEinsatz(
mitarbeiterId: string,
beginn: Date,
ende: Date,
): Promise<Einsatz>;
einsaetzeAm(tag: Date): Promise<readonly Einsatz[]>;
storniere(einsatzId: string): Promise<void>;
}
Ob dahinter eine relationale Datenbank, ein externer Dienst oder für Tests eine einfache Liste im Speicher steckt, erfahren die Aufrufer nicht. Genau das macht den Austausch möglich.
Kopplung und Kohäsion: die beiden Messgrößen
Ob eine Modularisierung gelungen ist, lässt sich an zwei Begriffen ablesen. Kopplung beschreibt, wie stark Module voneinander abhängen. Kohäsion beschreibt, wie eng die Teile innerhalb eines Moduls zusammengehören. Ziel ist eine geringe Kopplung nach außen und eine hohe Kohäsion nach innen.
Ein Beispiel aus dem Webshop: Ein Modul „Hilfsfunktionen“, das Preisrundung, E-Mail-Versand und Datumsformatierung bündelt, hat eine geringe Kohäsion. Fast jedes andere Modul hängt davon ab, und jede Änderung betrifft alle. Ein Modul „Preisberechnung“, das Rabatte, Steuern und Rundung kapselt und nur einen Endpreis liefert, hat dagegen eine hohe Kohäsion und eine schmale Schnittstelle.
Eine praktische Faustregel lautet: Was sich gemeinsam ändert, gehört zusammen. Wenn eine fachliche Änderung regelmäßig fünf Module berührt, ist der Schnitt falsch. Die SOLID-Prinzipien formulieren ähnliche Regeln auf der Ebene einzelner Klassen; wie viel davon in heutigen Webprojekten trägt, untersucht der Beitrag zu den SOLID-Prinzipien in moderner Webentwicklung.
Module richtig schneiden
Nach Verantwortung, nicht nach Technik
Viele Systeme werden technisch geschnitten: hier die Controller, dort die Datenbankklassen, daneben die Hilfsfunktionen. Langlebiger ist ein Schnitt nach fachlicher Verantwortung, also etwa Kundenverwaltung, Einsatzplanung und Abrechnung. Jedes Modul enthält dann alles, was es für seine Aufgabe braucht, und gibt nur das Nötige nach außen.
Schichten innerhalb eines Systems
Auch Schichten sind Blackboxes, wenn sie richtig gebaut sind. Ein Videoschnittprogramm kann zum Beispiel unten eine Plattformschicht haben, die Fenster, Dateien und Grafikkarte des Betriebssystems abstrahiert. Darauf setzen eine Zeichen- und Textschicht, dann Bedienelemente und schließlich die eigentliche Anwendung auf. Jede Schicht bietet der nächsten eine einfachere, stabilere Sicht. Wird das Programm auf ein neues Betriebssystem portiert, muss im Idealfall nur die unterste Schicht neu geschrieben werden.
Externe Abhängigkeiten einpacken
Fremde Bibliotheken und Dienste sind die häufigsten Quellen ungewollter Änderungen. Eine dünne eigene Schicht um sie herum, oft Wrapper oder Adapter genannt, begrenzt den Schaden. Wechselt etwa der Anbieter für den SMS-Versand, betrifft das nur den Adapter, nicht die zwanzig Stellen, an denen Erinnerungen verschickt werden. Das lohnt sich vor allem für Abhängigkeiten, die schwer zu ersetzen oder deren Zukunft ungewiss ist, nicht für jede kleine Hilfsbibliothek.
Die Größe eines Moduls
Eine gängige Empfehlung lautet, Module so zu schneiden, dass eine Person sie vollständig verstehen und verantworten kann. Das ist weniger eine Regel über Zeilenzahlen als über kognitive Last: Wer ein Modul ändert, sollte nicht erst drei Kollegen fragen müssen. Zu kleine Module verlagern die Komplexität dagegen in ein Geflecht aus Schnittstellen. Eine feste Größenvorgabe gibt es nicht.
Schnittstellen entwerfen, die lange halten
Die Schnittstelle ist der teuerste Teil eines Moduls, denn sie lässt sich nur mit Aufwand ändern. Ein paar Grundsätze helfen:
- Klein anfangen: Jede veröffentlichte Funktion ist ein Versprechen. Was nicht nach außen gegeben wurde, kann später frei geändert werden.
- Fachlich benennen:
storniere(einsatzId)sagt mehr und verrät weniger alsupdateStatus(id, 3). - Früh vollständig denken: Es hilft, die Schnittstelle so zu entwerfen, wie sie später gebraucht wird, auch wenn die erste Implementierung noch einfach ist. Andere Teams können dann schon dagegen entwickeln, während das Innere reift.
- Erweitern statt brechen: Neue optionale Parameter und neue Funktionen sind harmlos. Geänderte Bedeutungen bestehender Felder sind es nicht. Für unvermeidliche Brüche helfen Versionierung, eine Übergangsphase, in der alte Funktionen als veraltet markiert sind, und eine klar kommunizierte Abschaltung.
Für Netzwerkschnittstellen gelten dieselben Regeln. Dort hat sich bewährt, den Vertrag maschinenlesbar zu beschreiben, etwa mit der OpenAPI-Spezifikation für HTTP-Schnittstellen. Daraus lassen sich Dokumentation, Tests und Client-Code ableiten, und Änderungen am Vertrag fallen im Review auf.
Plugin-Architekturen: erweitern, ohne den Kern anzufassen
Eine Plugin-Architektur treibt das Blackbox-Prinzip einen Schritt weiter. Ein stabiler Kern definiert Datenstrukturen und Erweiterungspunkte, Plugins liefern konkrete Funktionen. Ein Plugin meldet beim Start über Metadaten an, was es kann, etwa welche Dateitypen es öffnet oder welche Effekte es anbietet, und der Kern bindet es ein, ohne seinen Code zu kennen.
Technisch geschieht das je nach Umgebung über dynamisch geladene Bibliotheken, über Pakete, die zur Laufzeit registriert werden, oder über getrennte Prozesse, die per Nachricht kommunizieren. Seit einigen Jahren kommt WebAssembly als Ausführungsformat für Plugins hinzu, weil es Erweiterungen in einer abgeschotteten Umgebung laufen lässt. Welcher Weg passt, hängt davon ab, wie sehr der Kern den Plugins vertrauen kann: Eigene Erweiterungen dürfen im selben Prozess laufen, Erweiterungen Dritter sollten isoliert werden.
Plugins lohnen sich, wenn Funktionen optional sind, wenn verschiedene Kunden verschiedene Ausbaustufen nutzen oder wenn Dritte erweitern sollen. Sie haben aber ihren Preis. Der Kern muss Erweiterungspunkte vorausdenken, und jeder Erweiterungspunkt ist eine Schnittstelle, die nicht mehr leichtfertig geändert werden kann.
Primitive und Formate als Fundament
Die richtige Grundeinheit wählen
Viele langlebige Systeme beruhen auf einer einzigen, gut gewählten Grundeinheit, einem sogenannten Primitiv. Bei Unix ist es die Datei, durch die auch Geräte angesprochen werden, unter Linux zudem Prozessinformationen. Ein Videoeditor arbeitet mit Clips auf einer Zeitleiste. Eine Pflegesoftware könnte jede Leistung, jeden Messwert und jede Medikamentengabe als Ereignis mit Zeitpunkt, Person und Typ abbilden.
Die Wahl des Primitivs bestimmt, welche Auswertungen leicht und welche schwer werden. Ereignisse lassen sich zum Beispiel nach Patientin, nach Tag oder nach Station sortieren, ohne dass die Speicherung sich ändern muss. Wer stattdessen für jede Sicht eine eigene Datenstruktur baut, vervielfacht Synchronisations- und Konsistenzprobleme.
Formate sind Schnittstellen
Dateiformate, Nachrichtenformate, Netzwerkprotokolle und APIs sind im Kern dasselbe: Verträge darüber, wie Informationen aussehen. Dabei lohnt es sich, Struktur und Bedeutung zu trennen. JSON legt fest, wie Daten verschachtelt werden, aber nicht, was ein Feld bedeutet. Das Einheitensystem legt fest, was ein Meter ist, aber nicht, wie man ihn speichert. Ein gutes Format beschreibt beides ausdrücklich, etwa mit einem Schema und einer Beschreibung der Felder samt Einheiten.
Erfolgreiche Formate sind außerdem sparsam. Erlaubt ein Format zwei Wege, dasselbe auszudrücken, müssen alle Programme, die es lesen, beide beherrschen. Klare Festlegungen und ausdrücklich geprüfte Einschränkungen machen Implementierungen einfacher und weniger fehleranfällig.
Ein Beispiel aus verteilten Systemen
In verteilten Echtzeitsystemen, etwa in Fahrzeugen, Maschinen oder der Luftfahrt, hat sich ein Publish-Subscribe-Muster bewährt: Eine maßgebliche Instanz sammelt Sensordaten und verteilt sie an Abonnenten, die nur die Werte erhalten, die sie brauchen. Weil die Abonnenten nur das Format der Daten kennen, kann die Datenquelle im Hintergrund redundant ausgelegt werden, ohne dass sich an den Empfängern etwas ändert.
Werkzeuge, die Modularität absichern
Grenzen, die nur in einem Architekturdiagramm existieren, weichen im Alltag auf. Absichern lassen sie sich auf mehreren Wegen:
- Technische Sichtbarkeitsregeln: Paket- und Modulsysteme moderner Sprachen, Workspaces in Monorepos oder Exportregeln in Build-Werkzeugen verhindern, dass interne Teile von außen importiert werden.
- Architekturtests: Werkzeuge wie ArchUnit für Java oder dependency-cruiser für JavaScript und TypeScript prüfen in der CI-Pipeline, ob verbotene Abhängigkeiten entstanden sind.
- Kleine Testanwendungen: Ein Minimalprogramm, das alle Funktionen einer Schnittstelle einmal aufruft, dient als lebende Dokumentation und als Prüfstein beim Portieren.
- Aufzeichnen und Abspielen: Werden echte Eingaben, etwa Nachrichten oder Sensordaten, aufgezeichnet, lassen sich Module isoliert mit realistischen Daten testen.
Langlebigkeit als Architekturziel
Wer Software für viele Jahre plant, sollte auch Technologieentscheidungen danach treffen. Weit verbreitete, gut standardisierte Sprachen, Formate und Protokolle überdauern Moden eher als junge Frameworks. Das heißt nicht, dass nur alte Technik infrage kommt. Es heißt, dass schwer austauschbare Teile besonders konservativ gewählt und hinter eigenen Schnittstellen gekapselt werden sollten.
Ebenso wichtig ist die Fähigkeit zur schrittweisen Veränderung. Neue Anforderungen kommen als neue Module oder als Erweiterungen bestehender Schnittstellen hinzu, alte Clients funktionieren weiter. Ein System, das sich nur in einem großen Schritt erneuern lässt, hat seine Modularität bereits verloren.
Was das für Ihr Projekt bedeutet
Das Blackbox-Prinzip ist kein Architekturstil, den man einmal einführt, sondern eine Haltung bei jeder Entscheidung: Was muss die Umgebung über diesen Baustein wissen, und was nicht? Für die meisten Teams liegt der größte Hebel nicht in neuen Frameworks, sondern darin, bestehende Grenzen sichtbar zu machen und automatisch zu prüfen. Überschätzt wird dagegen die Verteilung: Ein Modul wird nicht dadurch zur Blackbox, dass es als eigener Dienst läuft. Eine undichte Schnittstelle bleibt undicht, auch über das Netzwerk.
Wie sich Modularität in die großen Muster von Schichten über Hexagonal bis Microservices einordnet, zeigt der Überblick über die wichtigsten Software-Architekturmuster. Warum versteckte Abhängigkeiten so viel Komplexität erzeugen, behandelt der Beitrag zu Software-Komplexität und ihren Ursachen. Wenn Sie Schnittstellen zwischen Ihren Systemen neu ordnen möchten, finden Sie auf der Seite zu API-Integration und Backend-Entwicklung unsere Unterstützung bei Entwurf und Umsetzung.
Häufige Fragen zur modularen Architektur
Woran erkennt man falsch geschnittene Module?
Ein deutliches Signal ist, wenn fachliche Änderungen regelmäßig mehrere Module gleichzeitig betreffen oder wenn Teams sich ständig abstimmen müssen, bevor sie etwas ändern dürfen. Auch zirkuläre Abhängigkeiten zwischen Modulen sind ein Warnzeichen.
Wann ist eine Plugin-Architektur übertrieben?
Wenn es keine optionalen Funktionen gibt, keine Dritten erweitern und alle Teile ohnehin gemeinsam ausgeliefert werden. Dann reichen gut geschnittene Module mit klaren Schnittstellen, und der Aufwand für Erweiterungspunkte und Plugin-Verwaltung entfällt.
Braucht Modularität Microservices?
Nein. Modularität ist eine Eigenschaft des Entwurfs, nicht der Auslieferung. Ein modularer Monolith mit durchgesetzten Grenzen ist oft wartbarer als viele kleine Dienste, die eng aneinander gekoppelt sind.
Wie lassen sich nötige Änderungen an einer Schnittstelle einführen?
Führen Sie die neue Variante neben der alten ein, markieren Sie die alte als veraltet und nennen Sie einen Zeitpunkt für die Abschaltung. Automatisierte Tests gegen beide Varianten und Hinweise im Build helfen, Aufrufer rechtzeitig umzustellen.
Kategorien
Schlagworte