Files
MatsuneMikuroiandClaude Fable 5.1 f047b9c7ae Parts V to IX in the book, extension 2.9.1, Demo topics
Add chapters 05-08 to the three language profiles: the published book
stopped at Part IV because only 00-04 were listed.

Rename the MQTT topic root Tutorial/ to Demo/ in Part IX (code and
output included).

Shared notes extension 2.9.1: dependency folders are named after the
extension version, so browsers stop serving stale scripts after an
update.

Full rebuild of _book/ (HTML and PDF, three languages); remove the stray
site_libs/ that the last Deploy commit had added at the project root.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-10-16 09:44:27 +02:00

573 lines
79 KiB
JSON
Raw Permalink Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
[
{
"objectID": "index.html",
"href": "index.html",
"title": "Prozesssteuerung",
"section": "",
"text": "Über diese Notizen\nDiese Notizen verfolgen ein kleines Programm durch eine lange Reihe von Neubauten, vom direkten Methodenaufruf bis zu einer ereignisgetriebenen Architektur über MQTT. Jeder Neubau lässt das Programm genau das tun, was es vorher tat, und ändert, wer von wem weiss.\nDas gebaute Programm ändert sich nie: Sie tippen eine Zeile, sie kommt um 13 Buchstaben verschoben zurück.\nWas sich ändert, ist alles ringsherum. Dasselbe System wird immer wieder neu gebaut, und jeder Neubau stellt drei Fragen, in dieser Reihenfolge:\nJedes Mal, wenn ein Schritt fertig ist, kommt hier eine Zusammenfassung hinzu; das Buch wächst also im Tempo der Arbeit. Jede Zusammenfassung sagt, was der Schritt getan hat, was beim Ausführen beobachtet wurde und was sich architektonisch verschoben hat — meist ein Stück Wissen, das den Besitzer gewechselt hat.\nNach Material von Reto Konig, Universität Freiburg.",
"crumbs": [
"[About these notes]{.en}[À propos de ces notes]{.fr}[Über diese Notizen]{.de}"
]
},
{
"objectID": "index.html#sec-diagrams",
"href": "index.html#sec-diagrams",
"title": "Prozesssteuerung",
"section": "Wie die Abbildungen zu lesen sind",
"text": "Wie die Abbildungen zu lesen sind\nJede Abbildung existiert einmal als Zeichnung und dreimal als Sprache. In der Webfassung hat eine Abbildung mit Nachrichtenfluss eine kleine Leiste darunter: Abspielen schickt eine Nachricht durch die ganze Kette, Ein Sprung rückt einen einzigen Schritt vor, Zurücksetzen stellt alles zurück. Kästen leuchten auf, wenn die Nachricht sie erreicht; so ist zu sehen, welche Komponente wartet und welche arbeitet.\nIm PDF und in einem Browser ohne JavaScript ist dasselbe Bild da — nur unbewegt. Nichts in diesen Notizen hängt von der Animation ab.",
"crumbs": [
"[About these notes]{.en}[À propos de ces notes]{.fr}[Über diese Notizen]{.de}"
]
},
{
"objectID": "00-orientation.html",
"href": "00-orientation.html",
"title": "1  Schritt 0 — Worum es geht",
"section": "",
"text": "1.1 Die drei Fragen\nSchritt 0 enthält keinen Code. Er nennt das Thema: nicht ROT13, sondern die Architektur darum herum. Die Funktionalität bleibt über 81 Schritte fast unverändert — genau das macht die Veränderungen ringsherum sichtbar.\nZwei Regeln werden hier gesetzt und gelten bis zum Schluss:\nDeshalb beginnt der Aufbau nicht mit MQTT und auch nicht mit dynamischen Abonnements. Zuerst entsteht ein System mit absichtlich unbequemen Vermittlern, wird in Betrieb genommen, und erst dann wird gefragt, ob sie ihren Platz verdient haben.\nDie zweite Regel betrifft das Vokabular: Intent, Status/State und Event werden erst benannt, nachdem sie benutzt wurden. Sie erscheinen etwa ab Schritt 42, nicht früher.\nDie geplante Route, von Schritt 0 an:\nDer Wortlaut der drei Fragen ist wichtig, und man ersetzt ihn leicht durch eine schwächere Fassung:\n„Kennen“ ist nicht „kommunizieren“: zwei Komponenten können den ganzen Tag Nachrichten austauschen, ohne dass eine die andere nennt. „Über die Verdrahtung entscheiden“ ist nicht „verbinden“: der Teil, der Nachrichten weiterleitet, muss nicht der Teil sein, der die Route gewählt hat. Beide Unterscheidungen werden später konkret — die erste schon in Schritt 1, die zweite in Teil III.",
"crumbs": [
"<span class='chapter-number'>1</span>  <span class='chapter-title'>[Step 0 — What this is about]{.en}[Étape 0 — De quoi il s'agit]{.fr}[Schritt 0 — Worum es geht]{.de}</span>"
]
},
{
"objectID": "00-orientation.html#sec-three-questions",
"href": "00-orientation.html#sec-three-questions",
"title": "1  Schritt 0 — Worum es geht",
"section": "",
"text": "So gefragt\nEine schwächere Fassung\n\n\n\n\nWer kennt wen?\nwer mit wem kommuniziert\n\n\nWer besitzt was?\nwelche Daten jeder Teil hält\n\n\nWer entscheidet über die Verdrahtung?\nwelcher Teil alles verbindet",
"crumbs": [
"<span class='chapter-number'>1</span>  <span class='chapter-title'>[Step 0 — What this is about]{.en}[Étape 0 — De quoi il s'agit]{.fr}[Schritt 0 — Worum es geht]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html",
"href": "01-part-i-calls.html",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "",
"text": "2.1 Schritt 1 — Ganz unten: einfach aufrufen\nDie Schritte 1 bis 10 bleiben in einer JVM. Das System wird dreimal gebaut: als direkte Aufrufe, als drei Fähigkeiten, die einander nicht kennen wollen, und als dieselben Fähigkeiten, von Vermittlern zusammengeklebt. Nichts ist bisher verteilt, und genau das ist der Punkt: das Einzige, was sich ändert, ist wer wen kennt.\nProceduralRot13.java ist das ganze System in einer kompakten Quelldatei: eine Schleife, die eine Zeile liest, und eine Anweisung, die den rotierten Text ausgibt.\nIO.readln() steht in einer eigenen Zeile, rot13(text) aber ist kein eigener Schritt: es wird innerhalb des Arguments von IO.println aufgerufen. Weder rot13 noch IO.println weiss etwas vom anderen. Wer beide kennt, ist main(): es nennt sie und legt ihre Reihenfolge fest.\nWas main() über rot13 weiss: dass es existiert, wie man es aufruft (ein blosser Name, beide liegen in derselben implizit erzeugten Klasse), welches Argument es nimmt, was es zurückgibt, dass es jetzt sofort verfügbar ist und dass die Ausführung nach der Rückkehr weiterläuft. Nicht bekannt ist, wie rot13 implementiert ist — das Einzige, was es ignorieren darf.\nDie Verfügbarkeitsgarantie lohnt eine eigene Erwähnung, denn sie verschwindet später: main() und rot13 sind zwei Methoden einer bereits geladenen Klasse, aufgerufen im selben Thread, im selben Prozess. Nichts muss zuerst starten, keine Nachricht reist irgendwohin, kein Empfänger muss abonniert sein.\nBeobachtet: eine getippte Zeile erscheint rotiert; Ctrl+D beendet das Programm still, weil IO.readln() null zurückgibt und main() zurückkehrt.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-1",
"href": "01-part-i-calls.html#sec-step-1",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "",
"text": "void main() {\n while (true) {\n var text = IO.readln();\n\n if (text == null)\n return;\n\n IO.println(rot13(text));\n }\n}\n\n\n\n\n\n\n\n\n\n\nAbbildung 2.1: Die prozedurale Fassung. Die Verdrahtung steht im Code: main() nennt alle drei Teile und legt ihre Reihenfolge fest.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-2",
"href": "01-part-i-calls.html#sec-step-2",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.2 Schritt 2 — Drei egoistische Fähigkeiten",
"text": "2.2 Schritt 2 — Drei egoistische Fähigkeiten\nEine egoistische Komponente sagt: ich weiss, was ich kann, welche Daten ich annehme und welche ich erzeuge — und den Geschäftsprozess um mich herum möchte ich lieber nicht kennen. Konkret: ConsoleIn darf kein rot13(...) enthalten, und ROT13 kein consoleOut(...).\nDas Entfernen dieser Aufrufe schafft sofort ein Problem, das sich als Frage stellen lässt: wenn niemand niemanden kennt, wer macht daraus ein System? Zu beachten ist, was die Frage nicht sagt: das Wissen ist nicht verschwunden, es muss woandershin. Es fehlen zwei Verbindungen, nicht eine — ConsoleIn ↔︎ ROT13 und ROT13 ↔︎ ConsoleOut.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-3",
"href": "01-part-i-calls.html#sec-step-3",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.3 Schritt 3 — Jeder Fähigkeit ein Postfach geben",
"text": "2.3 Schritt 3 — Jeder Fähigkeit ein Postfach geben\nDer kleinste Mechanismus für die fehlenden Verbindungen: eine Nachricht und eine benannte Warteschlange.\nrecord Message(String type, String value) {}\n\nMap&lt;String, BlockingQueue&lt;Message&gt;&gt; mailboxes = new ConcurrentHashMap&lt;&gt;();\n\nBlockingQueue&lt;Message&gt; mailbox(String name) {\n return mailboxes.computeIfAbsent(name, _ -&gt; new LinkedBlockingQueue&lt;&gt;());\n}\nDas sind bewusst Postfächer (mailboxes) und keine Topics, und der Unterschied ist wichtig: rufen zwei Leser take() auf demselben Postfach auf, konkurrieren sie — jede Nachricht geht an genau einen von ihnen und wird nicht an beide kopiert. Ein Topic in Publish/Subscribe gäbe jedem Abonnenten seine eigene Kopie. Ein Leser pro Nachricht genügt vorläufig, und die Einschränkung bleibt absichtlich bestehen: sie macht später sichtbar, was Publish/Subscribe wirklich hinzufügt.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-steps-4-6",
"href": "01-part-i-calls.html#sec-steps-4-6",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.4 Schritte 4–6 — Die drei Fähigkeiten werden egoistisch",
"text": "2.4 Schritte 4–6 — Die drei Fähigkeiten werden egoistisch\nJede Fähigkeit berührt nur noch ihre eigenen Postfachnamen:\n\n\n\nFähigkeit\nliest\nschreibt\n\n\n\n\nConsoleIn\ndie Tastatur\nconsoleIn.outbox\n\n\nROT13\nrot13.inbox\nrot13.outbox\n\n\nConsoleOut\nconsoleOut.inbox\ndie Konsole\n\n\n\nKeine Fähigkeit enthält den Namen einer anderen, und genau das ist das Ergebnis: drei schön isolierte Fähigkeiten, die zusammen absolut nichts tun. Nichts bewegt eine Nachricht von consoleIn.outbox nach rot13.inbox oder von rot13.outbox nach consoleOut.inbox.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-7",
"href": "01-part-i-calls.html#sec-step-7",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.5 Schritt 7 — Auftritt des Vermittlers",
"text": "2.5 Schritt 7 — Auftritt des Vermittlers\nDer kleinstmögliche Klebstoff: eine Schleife, die aus einem Postfach nimmt und in ein anderes legt, ohne etwas über das Durchlaufende zu wissen.\nvoid mediate(String from, String to) {\n while (true)\n mailbox(to).put(mailbox(from).take());\n}\nmain() startet fünf virtuelle Threads: die drei Fähigkeiten plus zwei Vermittler, deren Routen als Argumente übergeben werden — consoleIn.outbox → rot13.inbox und rot13.outbox → consoleOut.inbox.\nBeobachtet: Hello World hinein, Uryyb Jbeyq heraus, genau wie in Schritt 1. Aber Ctrl+D beendet das Programm nicht mehr. Der Thread von ConsoleIn kehrt zurück (er schleift nicht), und die vier anderen Threads hängen blockiert in take() an leeren Postfächern, ohne CPU zu verbrauchen. Am Leben hält den Prozess tatsächlich die letzte Zeile von main(), Thread.currentThread().join(): der Haupt-Thread wartet auf sich selbst, was nie enden kann. Virtuelle Threads sind Daemon-Threads; die vier wartenden Threads allein hätten die JVM also nicht am Laufen gehalten.\n\n\n\n\n\n\nAbbildung 2.2: Die vermittelte Fassung in einer JVM. In der Webfassung schickt Abspielen eine Nachricht durch alle acht Sprünge.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-8",
"href": "01-part-i-calls.html#sec-step-8",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.6 Schritt 8 — Nochmals fragen: wer kennt wen?",
"text": "2.6 Schritt 8 — Nochmals fragen: wer kennt wen?\nKennt ConsoleIn ROT13? Nein. Kennt ROT13 ConsoleIn oder ConsoleOut? Nein. Ist die Topologie verschwunden? Nein — sie steckt in den zwei mediate(...)-Aufrufen innerhalb von main().\nDas ist das erste grosse Ergebnis:\n\nEntkopplung lässt Wissen oft nicht verschwinden. Sie verschiebt Wissen dorthin, wo es hingehört.\n\nDie Fähigkeit „ROT13 transformiert Text” gehört zu ROT13. Die Topologie ConsoleIn → ROT13 → ConsoleOut gehört zur Systemkomposition. Geändert hat sich seit Schritt 1 nicht, dass die Verdrahtung main() verlassen hat — sie ist noch dort —, sondern dass sie nicht mehr innerhalb einer Fähigkeit steht. Sie ist jetzt Daten: zwei Paare von Postfachnamen. Umverdrahten berührt diese zwei Zeilen und keine einzige Fähigkeit.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-9",
"href": "01-part-i-calls.html#sec-step-9",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.7 Schritt 9 — Warum virtuelle Threads?",
"text": "2.7 Schritt 9 — Warum virtuelle Threads?\nFünf Schleifen warten nun unbegrenzt: die Tastatur, rot13.inbox, consoleOut.inbox und die Quellen der zwei Vermittler. Virtuelle Threads sind einfach der billige Java-Weg, fünf Wartevorgänge gleichzeitig in einer JVM laufen zu lassen.\nSie sind eine Implementierungsbequemlichkeit, keine Architektur. Die Architektur — wer wen kennt und wo die Verdrahtung liegt — steckt in den Postfachnamen, nicht in den Threads. Der Beleg für die Trennung: dieselbe Architektur läuft in Schritt 11 als getrennte Prozesse, ohne geteilte Threads zwischen den Teilen.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-10",
"href": "01-part-i-calls.html#sec-step-10",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.8 Schritt 10 — Die Dienste egoistisch halten",
"text": "2.8 Schritt 10 — Die Dienste egoistisch halten\nDie naheliegende Abkürzung: der erste Vermittler kopiert Nachrichten nur unverändert — warum ihn also nicht löschen und ROT13 direkt take() auf consoleIn.outbox machen lassen?\nWeil ROT13 dann den Namen consoleIn.outbox enthielte, also wüsste, dass ConsoleIn existiert und wohin es veröffentlicht. Die Topologie wanderte in ROT13 hinein, und ROT13 wäre keine egoistische Fähigkeit mehr. Der Test, der das konkret macht: die Eingabe komme künftig von einer neuen Fähigkeit FileIn, die in fileIn.outbox veröffentlicht.\n\n\n\n\n\n\n\n\n\nmit Vermittler\nmit der Abkürzung\n\n\n\n\nwas sich ändert\nein Argument des Vermittlers\nrunRot13 selbst\n\n\nwer berührt wird\nkeine Fähigkeit\nROT13, dessen Aufgabe unverändert blieb\n\n\n\nDer Preis gehört klar gesagt: dieses Design mag indirekt wirken — sogar etwas eigenartig. Es gibt einen anderen Weg, Dienste egoistisch zu halten, ohne Vermittler im Pfad jeder Nachricht; er kommt später.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-part-i-result",
"href": "01-part-i-calls.html#sec-part-i-result",
"title": "2  Teil I — Mit dem beginnen, was man schon kennt",
"section": "2.9 Was Teil I verschoben hat",
"text": "2.9 Was Teil I verschoben hat\n\n\n\n\n\n\n\n\nStufe\nwo die Topologie liegt\nwer umverdrahten kann\n\n\n\n\nSchritt 1\nim Code der Fähigkeit (IO.println(rot13(text)))\nwer diesen Code ändert\n\n\nSchritte 7–8\nin main(), als Paare von Postfachnamen\nwer main() ändert\n\n\n\nFunktionalität: unverändert. Codezeilen: mehr. Teile, die einander kennen: keine. Das ist der Tauschhandel, den alles Folgende immer wieder prüft.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html",
"href": "02-part-ii-processes.html",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "",
"text": "3.1 Schritt 11 — Die Komponenten trennen\nDie Schritte 11 bis 18 nehmen die Architektur aus Teil I und verteilen sie auf fünf Betriebssystemprozesse auf einem Rechner. Die Fähigkeiten behalten ihre Postfachnamen; nur der Transport darunter wechselt, von Java-Objekten zu Dateien in Verzeichnissen. Das erste wirklich verteilte Problem tritt hier auf, und es hat nichts mit ROT13 zu tun.\nDrei Prozesse können keine BlockingQueue teilen: jeder java-Befehl startet seine eigene JVM mit eigenem Speicher, die mailboxes-Map existierte also dreimal, und jede Kopie sähe nur ihre eigenen Nachrichten. Ein externer Transport ist nötig.\nTCP würde gehen, MQTT würde gehen. Absichtlich fällt die Wahl auf die primitivste Möglichkeit, das Dateisystem, mit einer einzeiligen Begründung: weil man es sehen kann. Nachrichten werden Dateien, die man mit ls auflisten und mit cat lesen kann, während das System läuft. Primitiv heisst hier nicht schlechter; Teil VIII kommt darauf zurück, was das Dateisystem wirklich gut und wirklich schlecht kann.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-steps-12-13",
"href": "02-part-ii-processes.html#sec-steps-12-13",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.2 Schritte 12–13 — Ein Verzeichnis wird zum Postfach",
"text": "3.2 Schritte 12–13 — Ein Verzeichnis wird zum Postfach\nDie Zuordnung ist eine Zeile lang:\ndirectory = mailbox file = message\npublish = create file receive = watch directory\nmessageBoard/\n├── consoleIn/outbox/\n├── rot13/inbox/\n├── rot13/outbox/\n└── consoleOut/inbox/\nDer Message-Record erhält einen optionalen Zeitstempel, und das Dateiformat bleibt zwei Zeilen plus eine optionale dritte:\nTEXT\nHello World\nTIMESTAMP: 2026-09-22T10:42:12.123Z\nEine handgeschriebene Nachricht darf den Zeitstempel weglassen. Die Marke TIMESTAMP: verhindert, dass eine Inhaltszeile, die zufällig wie ein Datum aussieht, für Metadaten gehalten wird; in diesem winzigen Format ist eine letzte Zeile, die mit TIMESTAMP: beginnt, reserviert.\nJackson könnte hier eingeführt werden und wird es absichtlich nicht. Der Sinn eines lächerlich einfachen Formats ist, dass fast nichts die Architektur verdeckt — die ganze Nachricht ist in jedem Texteditor lesbar, was die Aufmerksamkeit darauf hält, wer mit wem spricht.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-14",
"href": "02-part-ii-processes.html#sec-step-14",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.3 Schritt 14 — Das erste Problem verteilter Systeme: die Veröffentlichung",
"text": "3.3 Schritt 14 — Das erste Problem verteilter Systeme: die Veröffentlichung\nEin Leser, der ein Verzeichnis beobachtet, kann eine Datei entdecken, bevor der Schreiber sie fertig geschrieben hat. Daher ein Veröffentlichungsprotokoll:\n\neine private temporäre Datei erzeugen;\ndie vollständige Nachricht schreiben;\nsie schliessen;\nsie atomar auf ihren endgültigen .msg-Namen umbenennen;\nKonsumenten reagieren nur auf endgültige Dateien.\n\nFiles.writeString(temporary, content);\nFiles.move(temporary, published, StandardCopyOption.ATOMIC_MOVE);\nBeide Hälften sind nötig. Das Umbenennen ist atomar — ein Leser sieht entweder keine .msg-Datei oder die vollständige —, aber es schützt nichts, wenn Leser auch .tmp-Dateien aufgreifen. .tmp und .msg bleiben im selben Verzeichnis, damit der Verschiebevorgang kein Dateisystem überschreitet, wo die Atomarität verloren ginge.\n\nSchreiben und Veröffentlichen sind nicht dieselbe Operation.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-15",
"href": "02-part-ii-processes.html#sec-step-15",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.4 Schritt 15 — Ein Postfach mit WatchService beobachten",
"text": "3.4 Schritt 15 — Ein Postfach mit WatchService beobachten\nJavas eigener Dateisystem-Beobachter liefert die Konsumentenhälfte: ein Verzeichnis für ENTRY_CREATE registrieren, in watcher.take() blockieren und jeden Dateinamen ignorieren, der nicht auf .msg endet.\nDas ergibt auch ein sehr einfaches Einspeisewerkzeug. Mit ActuatorService als laufendem Konsumenten:\nprintf 'TEXT\\nHello from a file' &gt; messageBoard/consoleOut/inbox/manual.tmp\nmv messageBoard/consoleOut/inbox/manual.tmp messageBoard/consoleOut/inbox/manual.msg\nBeobachtet: beim Auftauchen der .tmp-Datei geschieht nichts; die Zeile erscheint in dem Moment, in dem das Umbenennen den .msg-Namen erzeugt. Beide erlaubten Formate funktionieren, mit und ohne abschliessenden Zeitstempel.\nDie architektonische Lehre lautet producer → filesystem → consumer: der Konsument konnte einen Menschen, der mv tippt, nicht von einem echten Dienst unterscheiden. Er kennt sein eigenes Eingangspostfach, nicht den, der hineinschreibt. Der Egoismus hat die Prozessgrenze überlebt.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-steps-16-17",
"href": "02-part-ii-processes.html#sec-steps-16-17",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.5 Schritte 16–17 — Dienste und Vermittler werden Prozesse",
"text": "3.5 Schritte 16–17 — Dienste und Vermittler werden Prozesse\nDie drei Fähigkeiten werden drei Programme, und der Vermittler eine vierte Art Programm:\n\n\n\n\n\n\n\n\n\nProgramm\nspielt\nliest\nschreibt\n\n\n\n\nSensorService.java\nConsoleIn\ndie Tastatur\nconsoleIn/outbox\n\n\nProcessorService.java\nROT13\nrot13/inbox\nrot13/outbox\n\n\nActuatorService.java\nConsoleOut\nconsoleOut/inbox\ndie Konsole\n\n\nMediator.java &lt;from&gt; &lt;to&gt;\nder Klebstoff\n&lt;from&gt;\n&lt;to&gt;\n\n\n\nDer Vermittler ist generisch: seine Route ist nicht einkompiliert, sie kommt als zwei Startargumente. Doch eine Asymmetrie sollte man im Kopf behalten: die drei Fähigkeiten erhalten ihre Arbeit als Nachrichten in einem Postfach, der Vermittler dagegen seine Route als Startkonfiguration — und er hat keinen Namen und kein eigenes Steuerpostfach, in das jemand schreiben könnte.\nPraktische Folge: Argumente werden einmal gelesen, das Ändern der Route eines laufenden Vermittlers heisst also: anhalten und neu starten. Eine Konfigurationsdatei wäre nicht anders — auch sie wird beim Start gelesen. Dieser Punkt bleibt absichtlich offen, bis die Kosten der verteilten Vermittler zu spüren waren.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-18",
"href": "02-part-ii-processes.html#sec-step-18",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.6 Schritt 18 — Die vollständig externe lokale Fassung ausführen",
"text": "3.6 Schritt 18 — Die vollständig externe lokale Fassung ausführen\nFünf Terminals, fünf Prozesse, ein lokales Dateisystem dazwischen:\njava SensorService.java # terminal 1\njava Mediator.java consoleIn/outbox rot13/inbox # terminal 2\njava ProcessorService.java # terminal 3\njava Mediator.java rot13/outbox consoleOut/inbox # terminal 4\njava ActuatorService.java # terminal 5\nBeobachtet: Hello World, in Terminal 1 getippt, erschien als Uryyb Jbeyq in Terminal 5. Die drei mittleren Terminals zeigten nichts Neues — jeder Vermittler gibt beim Start eine Zeile „Mediating: …” aus, und ProcessorService gibt überhaupt nichts aus. Danach enthielt jedes der vier Postfachverzeichnisse eine .msg-Datei: dieselbe Zeile, entlang der Kette kopiert.\nNachzählen: fünf Prozesse für das, was Schritt 1 in einer Anweisung tat. Jetzt ist nicht der Moment zu optimieren: bequem soll es noch nicht sein.\n\n\n\n\n\n\nAbbildung 3.1: Die fünf Prozesse und die vier Postfachverzeichnisse. In der Webfassung folgt Abspielen einer Textzeile von der Tastatur zur Konsole.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-part-ii-result",
"href": "02-part-ii-processes.html#sec-part-ii-result",
"title": "3  Teil II — Die Prozessgrenze überschreiten",
"section": "3.7 Was Teil II verschoben hat",
"text": "3.7 Was Teil II verschoben hat\n\n\n\n\n\n\n\n\nStufe\nwo die Topologie liegt\nwer umverdrahten kann\n\n\n\n\nSchritt 1\nim Code der Fähigkeit\nwer diesen Code ändert\n\n\nSchritte 7–8\nin main(), als Postfachnamen\nwer main() ändert\n\n\nSchritt 18\nin den zwei Befehlszeilen Mediator.java &lt;from&gt; &lt;to&gt;\nwer die Prozesse startet\n\n\n\nDie Topologie hat den Quellcode nun ganz verlassen: keine .java-Datei enthält die Route. Sie steckt in dem, was der Bediener getippt hat — damit ist derzeit ein Mensch der Orchestrator. Was die Fünf-Prozess-Fassung einbringt, ist echt: die Verdrahtung kann sich ändern, ohne ein Programm anzufassen. Was sie kostet, ist ebenso echt: fünf Prozesse, vier Kopien jeder Nachricht und ein Programm, das bei Ctrl+D nicht mehr stehen bleibt.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html",
"href": "03-part-iii-distributed.html",
"title": "4  Teil III — Es wirklich verteilen",
"section": "",
"text": "4.1 Syncthing repliziert; es liefert nicht aus\nFünf Prozesse auf einem Rechner teilen immer noch ein Dateisystem. Die Schritte 19 bis 27 verteilen sie auf zwei Maschinen, replizieren das Nachrichtenbrett mit Syncthing zwischen ihnen, messen die Kosten und zerbrechen dann absichtlich einen Vermittler. Am Ende ist der Preis der Vermittler eine Zahl und keine Meinung.\nSyncthing hält ein Verzeichnis zwischen Maschinen repliziert. Mehr wird hier nicht verlangt. Es weiss nichts von Intent, Status, Event, ROT13 oder Vermittlern, und es kennt keinen Konsumenten: keine Abonnements, keine Topics, keine Lieferzusagen, keine Vorstellung davon, dass jemand wartet.\nDer Auslöser bleibt unser eigener. Jeder Dienst betreibt seinen eigenen WatchService auf einem lokalen Verzeichnis; Syncthing lässt die Dateien dort nur erscheinen. Deshalb musste keiner der drei Dienste eine Zeile ändern, als das System verteilt wurde.\nDaraus folgen zwei Dinge, die später als Beobachtung und nicht als Warnung auftreten:",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-syncthing-not-a-broker",
"href": "03-part-iii-distributed.html#sec-syncthing-not-a-broker",
"title": "4  Teil III — Es wirklich verteilen",
"section": "",
"text": "Replikation ist asynchron — das Umbenennen .tmp → .msg ist auf jeder Maschine einzeln atomar, und nichts verspricht Reihenfolge oder Atomarität zwischen Maschinen;\ndas Dateisystem ist ein ernstzunehmender Transport mit eigenen Stärken: Dateien dürfen gross sein, Replikate überleben einen Neustart, und jede Nachricht lässt sich mit cat lesen.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-one-layer",
"href": "03-part-iii-distributed.html#sec-one-layer",
"title": "4  Teil III — Es wirklich verteilen",
"section": "4.2 Eine Schicht auf einmal prüfen",
"text": "4.2 Eine Schicht auf einmal prüfen\nBevor irgendein Java-Programm den replizierten Ordner berührte, lief der langweiligste denkbare Test: hello.txt auf einer Maschine schreiben, prüfen, dass es auf der anderen erscheint, es löschen, prüfen, dass die Löschung zurückkommt. Beide Richtungen funktionierten.\nDiese Reihenfolge ist wichtig. Als der verteilte Lauf später scheiterte, war die Frage „Replikation oder mein Programm?” für den Transport schon beantwortet, und die Suche konnte eine Schicht höher beginnen.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-keystroke-cost",
"href": "03-part-iii-distributed.html#sec-keystroke-cost",
"title": "4  Teil III — Es wirklich verteilen",
"section": "4.3 Was ein Tastendruck kostet",
"text": "4.3 Was ein Tastendruck kostet\nMit dem Sensor auf einer Maschine und den Vermittlern, ROT13 und dem Aktor auf der anderen erzeugte eine getippte Zeile vier .msg-Dateien, eine pro Postfach:\n\n\n\nPostfach\nInhalt\nZeitstempel darin\n\n\n\n\nconsoleIn/outbox\nHello World\n23:02:05.315\n\n\nrot13/inbox\nHello World\n23:02:05.315\n\n\nrot13/outbox\nUryyb Jbeyq\n23:02:13.471\n\n\nconsoleOut/inbox\nUryyb Jbeyq\n23:02:13.471\n\n\n\nDie wiederholten Zeitstempel belegen, dass zwei dieser vier Veröffentlichungen reine Kopien sind: die Vermittler veröffentlichen die Nachricht unverändert erneut, Zeitstempel eingeschlossen. Sie berechnen identity(x) = x, als eigene verteilte Prozesse.\nDie Zeiten, gemessen an den Änderungszeiten der vier Dateien auf einer Maschine, damit keine Uhrendifferenz hineinspielt: die Datei des Sensors erscheint um 01:02:05.432, die drei anderen um 01:02:13.460, .504 und .532 — 8,10 s später und innerhalb von 72 ms zueinander. Die eigentliche Arbeit der Kette dauerte also Millisekunden; die acht Sekunden sind Syncthings Verbreitung. Dieselbe Kette, vollständig auf einer Maschine, braucht etwa 24 ms.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-break-a-mediator",
"href": "03-part-iii-distributed.html#sec-break-a-mediator",
"title": "4  Teil III — Es wirklich verteilen",
"section": "4.4 Einen Vermittler zerbrechen",
"text": "4.4 Einen Vermittler zerbrechen\nHalten Sie den ersten Vermittler an und tippen Sie zwei Zeilen. ConsoleIn lebt, ROT13 lebt, ConsoleOut lebt, Syncthing lebt — und der Geschäftsfluss ist tot. Die zwei Zeilen stapeln sich in consoleIn/outbox; weiter kommt nichts. Die Vermittler gehören zur Verfügbarkeitskette.\nStarten Sie den Vermittler neu. Nichts wird ausgeliefert. FileMessageBoard.watch registriert ein Verzeichnis für ENTRY_CREATE und blockiert in watcher.take(); es listet nie, was schon da ist. Die zwei Dateien liegen weiter auf der Platte, in beiden Replikaten — es ging also nichts verloren. Kein Gedächtnis hat das Abonnement.\nDiese Unterscheidung lohnt sich: die Nachrichten überlebten, die Auslieferung nicht. Ein Broker antwortet darauf mit Sitzungszustand und retained messages; im eigenen Code wäre es eine Zeile — die vorhandenen .msg-Dateien auflisten, bevor die Beobachtungsschleife beginnt — die das Material bewusst noch nicht schreibt.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-configurable-mediator",
"href": "03-part-iii-distributed.html#sec-configurable-mediator",
"title": "4  Teil III — Es wirklich verteilen",
"section": "4.5 Der Vermittler wird ein gewöhnlicher Dienst",
"text": "4.5 Der Vermittler wird ein gewöhnlicher Dienst\nBevor die Vermittler verschwinden, fällt eine Asymmetrie weg: die Dienste erhalten ihre Arbeit als Nachrichten, der Vermittler erhielt seine Route als Shell-Argumente. Er bekommt daher nur einen Namen, ConfigurableMediator mediator1, aus dem er ein dauerhaftes Steuerpostfach ableitet, mediators/mediator1/inbox, und die Route kommt als Nachricht:\nROUTE\nconsoleIn/outbox\nrot13/inbox\nfrom und to reisen absichtlich in einer Nachricht: als zwei hielte der Vermittler kurz eine neue Quelle mit dem alten Ziel und leitete an die falsche Stelle weiter. Eine Route ist ein Fakt, und ein Fakt gehört in eine Nachricht.\nEin kurzlebiger Orchestrator veröffentlicht beide Routen und endet, damit die Topologie an einer Stelle sichtbar ist und nicht im Datenpfad liegt. Startet man ihn nach den Diensten und hat vorher eine Zeile getippt, zeigen sich beide Hälften auf einmal: die frühe Zeile bleibt liegen, die späte läuft durch.\nWas besser wird: der Vermittler hat eine Identität, nimmt Konfiguration über sein eigenes Postfach, behält eine generische Fähigkeit und bezieht seine Topologie von einem Orchestrator. Was nicht besser wird: der Datenpfad. Er bleibt event → Vermittler → kopiertes event, weiter ein Prozess in der Verfügbarkeitskette, der jede Nachricht ohne Bedeutungsgewinn kopiert. Und diese Fassung nimmt genau eine Route an: waitForRoute(...) kehrt zurück, dann betritt der Vermittler watch(route.from(), …) und liest sein Steuerpostfach nie wieder. Umverdrahten im Betrieb wird nicht versprochen, weil ein blockierendes watch nicht gleichzeitig ein Steuerpostfach und eine Quelle bedienen kann — der Grund für die Abonnement-Hilfe später.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-part-iii-result",
"href": "03-part-iii-distributed.html#sec-part-iii-result",
"title": "4  Teil III — Es wirklich verteilen",
"section": "4.6 Was Teil III verschoben hat",
"text": "4.6 Was Teil III verschoben hat\n\n\n\n\n\n\n\n\nStufe\nwo die Topologie liegt\nim Datenpfad?\n\n\n\n\nSchritt 18\ndie Befehlszeilen des Bedieners\ndie Vermittler sind es\n\n\nSchritt 27\nein Orchestrator, als Intent veröffentlicht\ndie Vermittler sind es weiterhin\n\n\n\nDie Frage, mit der der Teil schliesst, ist daher scharf und nicht rhetorisch: warum kann der Dienst, der sich für die Daten interessiert, sie nicht selbst hören?",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html",
"href": "04-part-iv-rewind.html",
"title": "5  Teil IV — Zurückspulen",
"section": "",
"text": "5.1 Die naheliegende Abkürzung und ihre Falle\nDie Schritte 28 bis 34 kehren absichtlich zu einer JVM zurück. Ohne Replikationsverzögerung und ohne fünf Terminals kann sich nur ändern, wer wen kennt — die Idee lässt sich also in Sekunden ausprobieren statt in einer verteilten Fehlersuche.\nWenn der erste Vermittler nur Nachrichten kopiert: löschen wir ihn und lassen ROT13 die Quelle selbst lesen:\nDer Vermittler ist weg. Doch die wiederkehrende Frage: ROT13 enthält jetzt den Namen von ConsoleIns Postfach. Die Topologie ist aus dem Vermittler in den Dienst gewandert. Im Wortlaut des Materials: „Wir haben den Vermittler entfernt … und die Topologie zurück in den Dienst gelegt. Hoppla.”",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-the-trap",
"href": "04-part-iv-rewind.html#sec-the-trap",
"title": "5  Teil IV — Zurückspulen",
"section": "",
"text": "listen(\"consoleIn.outbox\");",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-capability-vs-topology",
"href": "04-part-iv-rewind.html#sec-capability-vs-topology",
"title": "5  Teil IV — Zurückspulen",
"section": "5.2 Fähigkeit ist nicht Topologie",
"text": "5.2 Fähigkeit ist nicht Topologie\nROT13 darf zwei Dinge wissen: ich kann Text transformieren und ich kann auf kompatible Textnachrichten hören. Es darf nicht wissen: meine Eingabe kommt immer aus consoleIn.outbox — das ist Deployment-Topologie.\nDer Name ist daher nicht einkompiliert, er kommt zur Laufzeit:\nTOPIC consoleIn.outbox\nROT13 lernt seine Verdrahtung aus Daten. Wer sie sendet, ist wichtig: in DynamicQueueRot13.java veröffentlicht main() beide TOPIC-Nachrichten — ein Konfigurator ausserhalb des Datenpfads, in der Rolle des früheren Orchestrators. ConsoleIn kann es nicht sein: sagte ConsoleIn ROT13, was es abonnieren soll, müsste es wissen, dass ROT13 existiert — die Topologie wäre nur in eine andere Fähigkeit gewandert.",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-dynamic-mechanics",
"href": "04-part-iv-rewind.html#sec-dynamic-mechanics",
"title": "5  Teil IV — Zurückspulen",
"section": "5.3 Was sich im Code ändert",
"text": "5.3 Was sich im Code ändert\nlisten(...) ist nichts Exotisches: ein virtueller Thread, der wiederholt take() auf einer derselben Warteschlangen aufruft. subscribe(...) startet einen solchen Thread pro abonniertem Namen. Die Folge ist in den Postfächern sichtbar:\n\nROT13 nimmt direkt aus consoleIn.outbox — dem Namen, den es erhalten hat;\nrot13.inbox ist kein Nutzlast-Postfach mehr. Es trägt Steuernachrichten, und ROT13s Schleife liest es, um zu entscheiden, ob eine Nachricht ein anzuwendendes TOPIC ist.\n\nNichts schreibt mehr in rot13.inbox, um Daten zu bewegen. Das Postfach verschwand nicht; es wechselte die Aufgabe, von Nutzlast zu Intent.\nEine Beobachtung aus dem Lauf: nach Ctrl+D endet die Ausgabe, das Programm bleibt aber am Leben. Unterbrochen wurde nichts — runConsoleIn kehrt am Eingabeende zurück, der Produzent ist also weg, während beide Abonnenten-Threads in take() auf Quellen warten, die nie wieder veröffentlichen. Die JVM lebt weiter, weil main mit Thread.currentThread().join() endet. „Der Fluss stoppte” muss immer darauf zurückgeführt werden, welcher Beteiligte stoppte.",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-route-topic-intent",
"href": "04-part-iv-rewind.html#sec-route-topic-intent",
"title": "5  Teil IV — Zurückspulen",
"section": "5.4 ROUTE und TOPIC sind Intent",
"text": "5.4 ROUTE und TOPIC sind Intent\nZwei Tests für TOPIC consoleIn.outbox. Beschreibt es etwas, das geschehen ist? Nein. Etwas, das gerade gilt? Nein. Es sagt beginne hier zu hören — gewünschtes Verhalten, also Intent. Das ROUTE des Vermittlers ist dieselbe Art Nachricht: leite von hier nach dort weiter.\nEine Falle, die benannt gehört, weil sie in einer Verteidigung verlockt: ein Intent zu veröffentlichen ist natürlich etwas, das geschehen ist. Die Einordnung folgt dem, was die Nachricht sagt, nicht ihrer Existenz.\nUnd eine Bedingung, die wiederkommt: die dynamische Fassung ist nicht automatisch besser. Sie ergibt nur Sinn, wenn der Konsument den Nachrichtenvertrag des Produzenten wirklich versteht.\nSTATISCH VERMITTELT DYNAMISCH DIREKT\nProduzent → Vermittler → Konsument Intent → (Produzent ──► Konsument)",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "05-part-v-subscriptions.html",
"href": "05-part-v-subscriptions.html",
"title": "6  Teil V — Die dynamische Idee über Prozesse hinweg wiederholen",
"section": "",
"text": "6.1 Ein blockierendes watch genügt nicht\nDie Schritte 35 bis 38 holen die Abonnement-Idee aus der einzelnen JVM heraus. Die Dienste werden wieder getrennte Programme, aber anstelle von Vermittlern, die Dateien kopieren, beobachtet jeder Dienst das Postfach, das ihm gesagt wurde. Eine Annahme des ersten Dateisystem-Helfers übersteht den Umzug nicht, und genau deren Korrektur ist das Thema dieses Teils.\nFileMessageBoard.watch(topic, receiver) registriert ein Verzeichnis und blockiert für immer. Das genügte, solange jeder Prozess ein festes Postfach beobachtete. Ein dynamisch verdrahteter Dienst braucht mehr:\nDie alte Signatur kann das nicht ausdrücken, und die Folge war schon vorher sichtbar: der konfigurierbare Vermittler nahm genau eine ROUTE an, denn sobald er seine Quelle beobachtete, wurde er für sein eigenes Steuerpostfach taub. Die Grenze war nie, wessen Verzeichnis es ist — sondern eines, festes, für immer.",
"crumbs": [
"<span class='chapter-number'>6</span>  <span class='chapter-title'>[Part V — Replay the dynamic idea across processes]{.en}[Partie V — Rejouer l'idée dynamique entre processus]{.fr}[Teil V — Die dynamische Idee über Prozesse hinweg wiederholen]{.de}</span>"
]
},
{
"objectID": "05-part-v-subscriptions.html#sec-watch-limit",
"href": "05-part-v-subscriptions.html#sec-watch-limit",
"title": "6  Teil V — Die dynamische Idee über Prozesse hinweg wiederholen",
"section": "",
"text": "dauerhaft das eigene Steuerpostfach beobachten\nUND\nzur Laufzeit ein beobachtetes Verzeichnis hinzufügen\nUND\nes möglicherweise später entfernen",
"crumbs": [
"<span class='chapter-number'>6</span>  <span class='chapter-title'>[Part V — Replay the dynamic idea across processes]{.en}[Partie V — Rejouer l'idée dynamique entre processus]{.fr}[Teil V — Die dynamische Idee über Prozesse hinweg wiederholen]{.de}</span>"
]
},
{
"objectID": "05-part-v-subscriptions.html#sec-filesubscriptions",
"href": "05-part-v-subscriptions.html#sec-filesubscriptions",
"title": "6  Teil V — Die dynamische Idee über Prozesse hinweg wiederholen",
"section": "6.2 Der Helfer: FileSubscriptions",
"text": "6.2 Der Helfer: FileSubscriptions\nEin WatchService kann viele Verzeichnisse bedienen. register(...) gibt einen WatchKey zurück, der eines davon bezeichnet, watcher.take() liefert den Schlüssel mit Ereignissen, und key.cancel() meldet ihn ab. Der Helfer hält beide Richtungen, Name → Schlüssel und Schlüssel → Name, damit ein Ereignis auf das Postfach zurückgeführt werden kann, aus dem es kam.\nEreignisse erreichen keinen Callback direkt. Sie gehen in eine Warteschlange, gelesen mit take(), und tragen\nrecord IncomingMessage(String mailbox, Message message) {}\nDafür zwei Gründe; die Ankunftsreihenfolge ist nur der dritte. Erstens muss der beobachtende Thread für jedes abonnierte Verzeichnis ansprechbar bleiben: ein Callback, der transformiert, veröffentlicht oder blockiert, hielte die Beobachtung aller anderen auf. Zweitens reist der Postfachname mit der Nachricht, sodass eine Schleife im Dienst deren Bedeutung bestimmen kann — Steuerpostfach, also ein anzuwendender Intent; abonnierte Quelle, also zu transformierende Daten — und dieselbe Schleife darf Abonnements hinzufügen oder entfernen, weil sie nicht in einem Callback feststeckt.",
"crumbs": [
"<span class='chapter-number'>6</span>  <span class='chapter-title'>[Part V — Replay the dynamic idea across processes]{.en}[Partie V — Rejouer l'idée dynamique entre processus]{.fr}[Teil V — Die dynamische Idee über Prozesse hinweg wiederholen]{.de}</span>"
]
},
{
"objectID": "05-part-v-subscriptions.html#sec-two-publications",
"href": "05-part-v-subscriptions.html#sec-two-publications",
"title": "6  Teil V — Die dynamische Idee über Prozesse hinweg wiederholen",
"section": "6.3 Zwei Veröffentlichungen statt vier",
"text": "6.3 Zwei Veröffentlichungen statt vier\nStarten Sie SensorService, DynamicProcessorService und DynamicActuatorService — ohne Vermittler — und lassen Sie dann Configure.java die zwei TOPIC-Nachrichten veröffentlichen. Eine danach getippte Zeile hinterlässt genau zwei Anwendungsveröffentlichungen im Brett:\n\n\n\n\n\n\n\n\nPostfach\nInhalt\nwas es ist\n\n\n\n\nconsoleIn/outbox\nTEXT hello\ndie Eingabe\n\n\nrot13/outbox\nTEXT uryyb\ndas Ergebnis\n\n\nrot13/inbox\nTOPIC consoleIn/outbox\nIntent, einmal veröffentlicht\n\n\nconsoleOut/inbox\nTOPIC rot13/outbox\nIntent, einmal veröffentlicht\n\n\n\nconsoleOut/inbox enthält keine Nutzlast: ConsoleOut nimmt direkt aus rot13/outbox. Sein Postfach wechselte die Aufgabe, von Nachrichten zu Verdrahtung.\nEine Zeile, die vor dem Lauf von Configure.java getippt wurde, bleibt für immer in consoleIn/outbox. Ein Abonnement, das noch nicht existiert, verpasst, was ihm vorausging — dieselbe Lehre wie beim neu gestarteten Vermittler, der nichts auslieferte.\n\n\n\nFassung\nAnwendungsveröffentlichungen\nProzesse im Datenpfad\n\n\n\n\nvermittelt (Schritt 18)\n4\n5\n\n\nkonfigurierbarer Vermittler (Schritt 27)\n4\n5\n\n\ndynamisch (Schritt 38)\n2\n3",
"crumbs": [
"<span class='chapter-number'>6</span>  <span class='chapter-title'>[Part V — Replay the dynamic idea across processes]{.en}[Partie V — Rejouer l'idée dynamique entre processus]{.fr}[Teil V — Die dynamische Idee über Prozesse hinweg wiederholen]{.de}</span>"
]
},
{
"objectID": "06-part-vi-vocabulary.html",
"href": "06-part-vi-vocabulary.html",
"title": "7  Teil VI — Über Syncthing wiederholen und die Nachrichten benennen",
"section": "",
"text": "7.1 Der verteilte dynamische Lauf\nDie Schritte 39 bis 47 verteilen die dynamische Fassung auf zwei Maschinen, sagen genau, was „direkt” bedeutet, und geben dann — erst jetzt, nachdem die Ideen benutzt wurden — den drei Nachrichtenarten ihre Namen: Intent, Status, Event.\nSensor auf einer Maschine, ROT13 und der Aktor auf der anderen, nirgends ein Vermittler. Nachdem die zwei TOPIC-Intents repliziert waren, erzeugte eine getippte Zeile das Ergebnis auf der anderen Maschine — und das Brett zeigt die Kosten:\nSpannend war die Zeit. Die Eingabe wurde um 02:35:12 veröffentlicht, die Ergebnisse erschienen auf der ersten Maschine um 04:11:28,797 und ,893 — 96 ms auseinander, lange nach der Eingabe. Syncthing war über Nacht überlastet; der Stapel kam, als die Warteschlange abfloss. Die Kette war durchgehend korrekt; die Latenz des Transports steuert die Architektur nicht. Zum Vergleich: 24 ms für dieselbe Kette auf einer Maschine.",
"crumbs": [
"<span class='chapter-number'>7</span>  <span class='chapter-title'>[Part VI — Replay it over Syncthing, and name the messages]{.en}[Partie VI — Rejouer sur Syncthing, et nommer les messages]{.fr}[Teil VI — Über Syncthing wiederholen und die Nachrichten benennen]{.de}</span>"
]
},
{
"objectID": "06-part-vi-vocabulary.html#sec-distributed-dynamic",
"href": "06-part-vi-vocabulary.html#sec-distributed-dynamic",
"title": "7  Teil VI — Über Syncthing wiederholen und die Nachrichten benennen",
"section": "",
"text": "consoleIn/outbox: die Eingabe;\nrot13/outbox: das Ergebnis, geschrieben von dem Dienst, der es erzeugt hat;\nconsoleOut/inbox: nur Intent, wo die vermittelte Fassung eine vollständige Kopie jeder Nachricht hielt.",
"crumbs": [
"<span class='chapter-number'>7</span>  <span class='chapter-title'>[Part VI — Replay it over Syncthing, and name the messages]{.en}[Partie VI — Rejouer sur Syncthing, et nommer les messages]{.fr}[Teil VI — Über Syncthing wiederholen und die Nachrichten benennen]{.de}</span>"
]
},
{
"objectID": "06-part-vi-vocabulary.html#sec-direct-precisely",
"href": "06-part-vi-vocabulary.html#sec-direct-precisely",
"title": "7  Teil VI — Über Syncthing wiederholen und die Nachrichten benennen",
"section": "7.2 Was „direkt” genau bedeutet",
"text": "7.2 Was „direkt” genau bedeutet\nZwei Sprünge, die gleich aussehen, sind architektonisch Gegensätze:\n\nein Transportsprung — Syncthing auf jeder Seite, möglicherweise ein Relay dazwischen — fügt keinen Beteiligten hinzu, der die Topologie kennt, und nichts reagiert darauf. Liefen die Pakete über einen anderen Kontinent, widerspräche das keiner Aussage hier.\nein architektonischer Sprung — ein Vermittler, der consoleIn/outbox → rot13/inbox kopiert — fügt eine Komponente hinzu, die beide Namen kennen muss, in der Verfügbarkeitskette steht und die Nachricht erneut veröffentlicht.\n\nDie vertretbare Aussage lautet daher: ROT13 reagiert auf ConsoleIns Veröffentlichung, ohne eine unserer Komponenten dazwischen und ohne ConsoleIns Identität zu enthalten. Nicht: die Daten gehen direkt von A nach B. Die Architektur bestimmt, auf welche Nachrichten ein Dienst reagiert, nicht die Wegewahl des Transports.",
"crumbs": [
"<span class='chapter-number'>7</span>  <span class='chapter-title'>[Part VI — Replay it over Syncthing, and name the messages]{.en}[Partie VI — Rejouer sur Syncthing, et nommer les messages]{.fr}[Teil VI — Über Syncthing wiederholen und die Nachrichten benennen]{.de}</span>"
]
},
{
"objectID": "06-part-vi-vocabulary.html#sec-ise",
"href": "06-part-vi-vocabulary.html#sec-ise",
"title": "7  Teil VI — Über Syncthing wiederholen und die Nachrichten benennen",
"section": "7.3 Intent, Status, Event",
"text": "7.3 Intent, Status, Event\nDrei Nachrichtenarten, benannt erst nach ihrem Gebrauch:\n\n\n\n\n\n\n\n\n\nsagt\nunsere Beispiele\n\n\n\n\nE — Event\netwas ist geschehen\nTEXT hello als ConsoleIn/E/text; TEXT uryyb als ROT13/E/crypted\n\n\nS — Status/State\netwas ist gerade wahr\nROT13/S/subscriptions — von unserem System noch nicht veröffentlicht\n\n\nI — Intent\nwas geschehen soll\nTOPIC consoleIn/outbox, ROUTE … …\n\n\n\nVergangenheitsform ist ein nützlicher Hinweis für Events. Für Intent lautet der Test zwei Fragen: berichtet die Nachricht etwas Geschehenes? Nein. Etwas gerade Wahres? Nein. Dann verlangt sie Verhalten.\nEine Falle: einen Intent zu veröffentlichen ist natürlich etwas Geschehenes. Eingeordnet wird nach dem, was die Nachricht sagt, nicht nach ihrer Existenz — sonst wird alles zum Event und das Vokabular nützt nichts mehr.\nStatus verdient eine eigene Anmerkung, denn der Instinkt ist, ihn zu erfragen: „welche Abonnements hast du?” Doch Fragen ist ein Aufruf, und ein Aufruf verlangt, dass der Fragende die Komponente kennt, sie als laufend weiss und wartet. Status wird veröffentlicht: ROT13 veröffentlicht ROT13/S/subscriptions, sobald sich seine Verdrahtung ändert, und wer will, liest es. Der Leser braucht dann ein Topic, keine Komponente, und ROT13 erfährt nie, wer es prüft. Jede Art beantwortet eine andere Frage:\n\nein Event nützt nur, wenn man zuhörte — unsere liegengebliebenen Nachrichten, dreimal;\nein Status ist, was ein Neuankömmling braucht: der aktuelle Wert, ohne Geschichte nachzuspielen;\nein Intent verlangt eine Änderung.\n\nUnd Kommandos sind nicht verboten. ROT13/I mit ACTION Hello zu senden ist kommandoartig, und das Urteil des Materials lautet „Fine.” Die Komponente übt ihre Fähigkeit aus und veröffentlicht ihre Events und ihren Status. Der empfohlene Fluss ist Intent → Komponente → State + Events.",
"crumbs": [
"<span class='chapter-number'>7</span>  <span class='chapter-title'>[Part VI — Replay it over Syncthing, and name the messages]{.en}[Partie VI — Rejouer sur Syncthing, et nommer les messages]{.fr}[Teil VI — Über Syncthing wiederholen und die Nachrichten benennen]{.de}</span>"
]
},
{
"objectID": "06-part-vi-vocabulary.html#sec-one-writer",
"href": "06-part-vi-vocabulary.html#sec-one-writer",
"title": "7  Teil VI — Über Syncthing wiederholen und die Nachrichten benennen",
"section": "7.4 Die Ein-Schreiber-Regel",
"text": "7.4 Die Ein-Schreiber-Regel\n\nJede schreibbare Ressource hat genau eine Schreibautorität.\n\nNicht zu verwechseln mit der UUID im Dateinamen. Die UUID verhindert, dass zwei Veröffentlichungen denselben physischen Namen wählen; die Schreibautorität sagt, welche Komponente eine logische Event- oder Status-Ressource besitzt. Zwei Schreiber kollidieren nie bei einem Dateinamen — genau deshalb wird das Problem leicht übersehen.\nWas ein zweiter Schreiber kostet: der Postfachname war der einzige Herkunftsnachweis, also bedeutet rot13/outbox nicht mehr „ROT13 hat dies transformiert”, und ein Abonnent kann dem Vertrag nicht mehr trauen, auf dem er aufbaut. Für Status ist es schlimmer — zwei Komponenten, die je den aktuellen Wert eines Faktes zu veröffentlichen behaupten, widersprechen sich, ohne Reihenfolgegarantie zwischen Maschinen, die entscheiden könnte. Bei append-only Events koexistieren viele Veröffentlichungen absichtlich; die Frage ist semantischer Besitz, nicht Kollision. Treten zwei Autoritäten auf, frage nach dem Warum, statt zum Lock zu greifen.",
"crumbs": [
"<span class='chapter-number'>7</span>  <span class='chapter-title'>[Part VI — Replay it over Syncthing, and name the messages]{.en}[Partie VI — Rejouer sur Syncthing, et nommer les messages]{.fr}[Teil VI — Über Syncthing wiederholen und die Nachrichten benennen]{.de}</span>"
]
},
{
"objectID": "07-part-vii-mediation.html",
"href": "07-part-vii-mediation.html",
"title": "8  Teil VII — Die zwei architektonischen Ideen zusammenführen",
"section": "",
"text": "8.1 Ein Transformator verdient seine Existenz\nZwei Vermittler wurden entfernt und der Gewinn gemessen. Die Schritte 48 bis 52 beantworten die naheliegende nächste Frage: ist Vermittlung damit falsch? Nein — und die entscheidende Unterscheidung ist scharf genug, um sie auf einen fremden Entwurf anzuwenden.\nEntfernt wurde ein Vermittler, der A → A berechnete: eine teure Identitätsfunktion in der Verfügbarkeitskette, die jede Nachricht ohne Bedeutungsgewinn kopierte.\nNun ein Produzent, der {\"value\":\"Hello\"} veröffentlicht, und ein Konsument, der eine Anzeigestruktur erwartet. Ein TextToDisplayTransformer dazwischen leistet Schematransformation, semantische Anpassung, möglicherweise Einheitenumrechnung, möglicherweise Aggregation. Das ist Arbeit, die keine der beiden Seiten besitzen sollte: ROT13 hat nicht über Terminalfarben zu entscheiden, und die Konsole hat die Nutzlastform von ROT13 nicht zu verstehen.\nDie Grenze zieht die Vertragskompatibilität, nicht die Frage, ob etwas hinzukommt. Ein Vermittler, der Celsius in Fahrenheit umrechnet, ändert statt hinzuzufügen und hat seinen Platz verdient; einer, der einer schon verstandenen Nachricht einen Zeitstempel anhängt, hat etwas hinzugefügt und bleibt verdächtig. Die Frage ist immer: könnte der Konsument die Nachricht des Produzenten so lesen, wie sie ist?",
"crumbs": [
"<span class='chapter-number'>8</span>  <span class='chapter-title'>[Part VII — Now merge the two architectural ideas]{.en}[Partie VII — Fusionner les deux idées architecturales]{.fr}[Teil VII — Die zwei architektonischen Ideen zusammenführen]{.de}</span>"
]
},
{
"objectID": "07-part-vii-mediation.html#sec-transformer",
"href": "07-part-vii-mediation.html#sec-transformer",
"title": "8  Teil VII — Die zwei architektonischen Ideen zusammenführen",
"section": "",
"text": "Versteht ein Konsument die Veröffentlichung eines Produzenten semantisch, genügt direktes Abonnieren oft. Sind die Verträge inkompatibel, führe einen Transformator ein, der eine echte Anpassung leistet.\nEin Vermittler, der nur kompatible Daten weiterleitet, ist verdächtig. Ein Vermittler, der nötige Semantik hinzufügt, hat seine Existenz verdient.",
"crumbs": [
"<span class='chapter-number'>8</span>  <span class='chapter-title'>[Part VII — Now merge the two architectural ideas]{.en}[Partie VII — Fusionner les deux idées architecturales]{.fr}[Teil VII — Die zwei architektonischen Ideen zusammenführen]{.de}</span>"
]
},
{
"objectID": "07-part-vii-mediation.html#sec-egoistic-transformer",
"href": "07-part-vii-mediation.html#sec-egoistic-transformer",
"title": "8  Teil VII — Die zwei architektonischen Ideen zusammenführen",
"section": "8.2 Auch der Transformator ist egoistisch",
"text": "8.2 Auch der Transformator ist egoistisch\nIn die Kette eingefügt, abonniert der Transformator rot13/outbox und veröffentlicht in sein eigenes Ausgangspostfach; ConsoleOut abonniert dann dieses statt das von ROT13. Was das an Code kostet: nichts. ConsoleOut erhält einen anderen Intent — TOPIC display/outbox statt TOPIC rot13/outbox — und die Kette ist umverdrahtet. ROT13 erfährt nie, dass der Transformator existiert; der Transformator nie, dass ConsoleOut existiert.\nWarum nicht direkt in consoleOut/inbox veröffentlichen und ein Postfach sparen? Vier Gründe:\n\nWissen — er enthielte ConsoleOuts Namen, also Topologie in einem Dienst, der Rückfall von Schritt 28;\nBesitz — dieses Postfach ist ConsoleOuts Steuerkanal, geschrieben vom Konfigurator; Nutzlast vom Transformator gäbe ihm zwei Autoritäten;\nReichweite — sein eigenes Ausgangspostfach kann ein Logger, eine Webansicht oder ein zweites Display kostenlos lesen, während ein Eingangspostfach genau einen Konsumenten bedient;\nVeränderbarkeit — ein Aggregator lässt sich danach durch einen anderen Intent einfügen, ohne eine Komponente zu ändern.",
"crumbs": [
"<span class='chapter-number'>8</span>  <span class='chapter-title'>[Part VII — Now merge the two architectural ideas]{.en}[Partie VII — Fusionner les deux idées architecturales]{.fr}[Teil VII — Die zwei architektonischen Ideen zusammenführen]{.de}</span>"
]
},
{
"objectID": "07-part-vii-mediation.html#sec-complete-filesystem",
"href": "07-part-vii-mediation.html#sec-complete-filesystem",
"title": "8  Teil VII — Die zwei architektonischen Ideen zusammenführen",
"section": "8.3 Die vollständige Dateisystem-Architektur",
"text": "8.3 Die vollständige Dateisystem-Architektur\nJedes Postfach mit genau einem Schreiber:\n\n\n\n\n\n\n\nPostfach\neinziger Schreiber\n\n\n\n\nconsoleIn/outbox\nSensorService\n\n\nrot13/outbox\nProcessorService\n\n\ndisplay/outbox\nder Transformator\n\n\njedes Steuerpostfach\nder Konfigurator — die eine bestimmte Intent-Autorität\n\n\ndas Terminal\nActuatorService, der kein Postfach schreibt\n\n\n\nEgoistische Fähigkeiten, Intent aus einer Autorität, ein Transformator nur dort, wo Verträge sich unterscheiden, ein Schreiber pro Ressource, und die Topologie nirgends in den Fähigkeiten. Das ist der Entwurf, den das Dateisystem gut genug war zu lehren — und der nächste Teil fragt, wofür das Dateisystem selbst nicht mehr gut genug ist.",
"crumbs": [
"<span class='chapter-number'>8</span>  <span class='chapter-title'>[Part VII — Now merge the two architectural ideas]{.en}[Partie VII — Fusionner les deux idées architecturales]{.fr}[Teil VII — Die zwei architektonischen Ideen zusammenführen]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html",
"href": "08-part-ix-mqtt.html",
"title": "9  Teil IX — MQTT",
"section": "",
"text": "9.1 Was das Dateisystem gelehrt hat und wofür es nicht taugt\nDas Dateisystem lehrte Veröffentlichungsgrenzen, Verzeichnisse als Adressen, Beobachtung, unabhängige Prozesse, unabhängige Sprachen, Synchronisationslatenz, Verdrahtung zur Laufzeit, State, Intent, Events, Vermittlerkosten, Dienstbesitz und Transformatordienste. Es war ein guter Lehrer und ist kein eleganter Nachrichten-Broker: am Ende war die Architektur sauber und der Transport ein Haufen .tmp-Dateien, atomarer Verschiebungen, erneuter Scans, geteilter Pfade und Replikationsverzögerung.\nDie Schlussfolgerung ist nicht „Dateien schlecht, MQTT gut”. Das Dateisystem hat einen Vorteil, den MQTT nicht erreicht — es speichert routinemässig Gigabytes bis Terabytes, während Broker und Clients für kleine Nachrichten gebaut sind, und das Stückeln einer riesigen Nutzlast über MQTT heisst, ein Dateitransferprotokoll in einem Nachrichtenprotokoll zu erfinden. Also:\nEin repliziertes Dateisystem gibt zudem jeder Maschine eine lokale Kopie, eine echte Stärke — doch Replikation ist kein Backup: Löschungen und Beschädigungen replizieren mit, sofern nicht eine Versionierung ältere Kopien bewahrt.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-filesystem-verdict",
"href": "08-part-ix-mqtt.html#sec-filesystem-verdict",
"title": "9  Teil IX — MQTT",
"section": "",
"text": "Nachrichten für Koordination und Ereignisse. Für grosse Daten ein passender Datei- oder Objektspeicher. Eine Nachricht kann Ort, Identität und Metadaten dieser Daten tragen statt der Terabytes selbst.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-mqtt-mapping",
"href": "08-part-ix-mqtt.html#sec-mqtt-mapping",
"title": "9  Teil IX — MQTT",
"section": "9.2 MQTT sollte vertraut wirken",
"text": "9.2 MQTT sollte vertraut wirken\n\n\n\nDateisystem / Syncthing\nMQTT\n\n\n\n\nWurzel des synchronisierten Nachrichtenbretts\nBroker / Namensraum\n\n\nVerzeichnispfad\nTopic\n\n\n.msg-Datei\nVeröffentlichung\n\n\nDateiinhalt\nNutzlast\n\n\nWatchService\nAbonnement\n\n\ndynamisches Verzeichnis\nTopic / Filter\n\n\nSteuerverzeichnis\nI\n\n\nZustandsverzeichnis\nS/…\n\n\nEreignisverzeichnis\nE/…\n\n\n\nDie gewünschte Reaktion des Materials: „Ach. Diese Architektur kennen wir schon.” MQTT ist ein Transportwechsel, keine architektonische Aussage.\nZwei Dinge, die ein Verzeichnis nicht konnte, in einer Minute auf der Kommandozeile sichtbar. Eine Veröffentlichung vor der Existenz eines Abonnenten erreicht ihn nie — die Lehre der liegengebliebenen Nachrichten zum dritten Mal, nun mit einer Antwort, die das Dateisystem nie hatte. Und ein Filter wie test/# passt auf test/a und test/a/b/c, nicht aber auf testing/x, weil # auf Ebenen arbeitet, nicht auf Zeichenpräfixen; test/+ passte nur eine Ebene tief.\nDie tiefere Korrektur: ein Topic ist kein Behälter. Es gibt kein Objekt namens test/a auf dem Broker. Ein Topic ist ein Routing-Schlüssel, den jede Veröffentlichung trägt und der gegen die Filter derjenigen geprüft wird, die in diesem Moment abonniert haben. Verzeichnisse halten Nachrichten; Topics vergleichen sie. Ein Abonnement deckt daher Topics ab, die noch nicht existieren — wo ein Nachrichtenbrett ein neues Verzeichnis und eine neue Registrierung brauchte.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-paho",
"href": "08-part-ix-mqtt.html#sec-paho",
"title": "9  Teil IX — MQTT",
"section": "9.3 Die Bibliothek, die Client-ID und die Broker-Adresse",
"text": "9.3 Die Bibliothek, die Client-ID und die Broker-Adresse\nJava hat keinen MQTT-Client in der Standardbibliothek, also kommt Paho jetzt — nach dem Bedarf, wie der Vermittler in Schritt 7 und Jackson in Schritt 64. Vier Dinge braucht man: verbinden, veröffentlichen, abonnieren, Rückruf. Das Verbinden ist absichtlich unspektakulär: „Hier ist architektonisch nichts geschehen. Wir haben unseren Prozess nur an den Transport angeschlossen.”\nZwei Details des Verbindens haben Gewicht:\n\ndie Client-ID ist nicht bloss ein Eindeutigkeitsmerkmal. Der Broker erkennt daran einen zurückkehrenden Client und hält Sitzungszustand für ihn: Abonnements, bei QoS &gt; 0 eingereihte Nachrichten und die Verknüpfung mit seinem Last Will. Ein Verzeichnis wusste nie, wer es beobachtete — genau deshalb spielte ein neu gestarteter Beobachter nichts nach.\ndie Broker-Adresse ist Deployment-Konfiguration: jedes Programm liest System.getProperty(\"mqtt.broker\", \"tcp://localhost:1883\"). Sie ist auch die einzige Konfiguration, die nicht als Intent kommen kann, denn Intent reist durch den Broker. Topologie lässt sich veröffentlichen; die Adresse des Veröffentlichenden nicht.\n\nAbonnieren kostet ein Paket, und der Broker führt die Abonnementliste. Es gibt keinen Standardweg, ihn zu fragen, was ein anderer Client abonniert hat — daher S/subscriptions: die eigene Erklärung einer Komponente über ihre Verdrahtung, veröffentlicht, damit die Architektur weiss, was der Transport privat hält. Nur ihr Eigentümer darf sie veröffentlichen, nach der Ein-Schreiber-Regel, denn nur er weiss, was er angenommen hat.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-structured-intent",
"href": "08-part-ix-mqtt.html#sec-structured-intent",
"title": "9  Teil IX — MQTT",
"section": "9.4 Strukturierter Intent und zwei Mapper",
"text": "9.4 Strukturierter Intent und zwei Mapper\nTOPIC some/path hat ein Feld und eine Bedeutung. Es kann nicht sagen, welche Art Intent vorliegt, keinen zweiten Parameter tragen, nicht verschachteln, nicht erweitert werden; und ein Empfänger hat nichts, wogegen er prüfen könnte. Reicherer Intent braucht Struktur:\nsubscribe:\n topic: Demo/ConsoleIn/U/alice/E/text\nErst dann hat eine Serialisierungsbibliothek eine klare Aufgabe. JsonTools hält zwei Mapper, und die Asymmetrie ist Absicht:\n\ndas Lesen nutzt eine YAML-Factory mit abgeschaltetem FAIL_ON_UNKNOWN_PROPERTIES — JSON ist eine Teilmenge von YAML, handgetippter Intent wird akzeptiert, und ein neuerer Konfigurator darf Felder senden, die ein älterer Dienst ignoriert;\ndas Schreiben nutzt strenges JSON mit INDENT_OUTPUT, die veröffentlichten Nutzlasten sind also streng und lesbar.\n\nTolerant hinein, streng hinaus. Ein einziger Mapper müsste auf eines davon verzichten.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-duise",
"href": "08-part-ix-mqtt.html#sec-duise",
"title": "9  Teil IX — MQTT",
"section": "9.5 DUISE und das Umverdrahten im Betrieb",
"text": "9.5 DUISE und das Umverdrahten im Betrieb\nDas Namensschema erhält endlich seinen Namen: Description (welche Verträge dieser Dienst versteht und veröffentlicht), Unit (welche Instanz), Intent (gewünschtes Verhalten), Status (was jetzt gilt), Event (was geschehen ist).\nDemo/ROT13/U/alice/{I, S/online, S/subscriptions/text, E/crypted}\nU/&lt;unit&gt; brauchte das Dateisystem nie: jede Maschine hatte ihr eigenes Replikat desselben relativen Pfades, Instanzidentität war implizit. MQTT hat einen gemeinsamen Namensraum, ein Topic muss also sagen, welche Kopie. U/alice in einer Fähigkeit festzuschreiben ist daher schlimmer, als consoleIn.outbox es je war: es bindet das Build an ein Deployment. Per Intent konfiguriert, dient ein Build allen — daher die drei Unit-Namen als Argumente von MqttConfigure. Die Unit-Namen sind die Topologie.\nUmverdrahten, am laufenden System beobachtet: einen neuen Intent mit anderer Quelle veröffentlichen, und der Dienst kündigt die alte, abonniert die neue und veröffentlicht S/subscriptions passend neu. Kein Neustart, keine Änderung. Schickt man stattdessen einen ungültigen Filter — Demo/#/E/text, wo # nicht die letzte Ebene ist — weist MqttTools.isValidFilter ihn ab; das alte Abonnement bleibt, und der Status sagt weiter die Wahrheit.\nDiese Abweisung legt eine echte Lücke offen, die man benennen und nicht verstecken sollte: sie wird nur lokal protokolliert. Der Konfigurator erfährt nicht, ob sein Intent angewandt oder abgelehnt wurde, und ein Monitor kann „abgelehnt” nicht von „noch nicht verarbeitet” unterscheiden. In diesem Entwurf erfährt ein Sender das Ergebnis, indem er den Status liest und mit seiner Anfrage vergleicht. Abweisungen als Event zu veröffentlichen oder ein Letzter-Fehler-Status würden die Lücke schliessen; beides steht nicht im Material — es ist eine zu begründende Entwurfsentscheidung.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-retained-and-will",
"href": "08-part-ix-mqtt.html#sec-retained-and-will",
"title": "9  Teil IX — MQTT",
"section": "9.6 Was ein neuer Abonnent erfährt und was ein Toter zugibt",
"text": "9.6 Was ein neuer Abonnent erfährt und was ein Toter zugibt\nDrei Sekunden Demo/# abonnieren, ohne dass etwas veröffentlicht wird, ergibt dies:\nDemo/ROT13/U/nitro5/S/online {\"value\":true}\nDemo/ROT13/U/nitro5/S/subscriptions/text \"Demo/ConsoleIn/U/nitro5/E/text\"\nDemo/ConsoleOut/U/nitro5/S/online {\"value\":true}\nDemo/ConsoleOut/U/nitro5/S/subscriptions/text \"Demo/ROT13/U/nitro5/E/crypted\"\nEin Spätankömmling erfährt augenblicklich die gesamte aktuelle Verdrahtung des Systems, ohne jemanden zu fragen und ohne dass eine Komponente von einem Monitor weiss. Das ist retained Status. Keine Events kommen an, denn Events werden nicht retained veröffentlicht — „retained State, nicht retained Events”. Es ist auch die richtige Antwort auf den Reflex, einen Dienst zu fragen, was er tut: niemand fragt; der Dienst erklärt es einmal, und der Broker bewahrt es für jeden, der kommt.\nRetained Status allein würde allerdings lügen. Beendet man einen Dienst mit Ctrl+C, bleibt sein S/online = true für immer beim Broker. Daher der Last Will, bei der Verbindung registriert:\nvar will = new MqttMessage(\"{\\\"value\\\":false}\".getBytes(UTF_8), 1, true, new MqttProperties());\noptions.setWill(lastWillTopic, will);\nDer Will ist retained, ersetzt also beim Veröffentlichen durch den Broker das veraltete true. Die Komponente, die ausfällt, ist nicht die, die den Ausfall meldet — die einzige Anordnung, die funktionieren kann. Ein Vorbehalt: ein sauberes DISCONNECT löst keinen Will aus; ein gut erzogener Dienst veröffentlicht daher beim Beenden selbst online=false, und der Will deckt die hässlichen Tode.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-coupling-remains",
"href": "08-part-ix-mqtt.html#sec-coupling-remains",
"title": "9  Teil IX — MQTT",
"section": "9.7 Was den Transport überlebte und welche Kopplung bleibt",
"text": "9.7 Was den Transport überlebte und welche Kopplung bleibt\nDie untere Hälfte der Tabelle Dateisystem→MQTT ist der Punkt: I, S, E, egoistische Dienste, Topologie zur Laufzeit und „Transformator wenn nötig” sind unverändert. Die Architektur überlebte den Transportwechsel, und das ist der stärkste verfügbare Beleg, dass sie nie am Transport hing.\nLose Kopplung heisst nicht, dass nichts etwas weiss. Notwendig bleibt die Einigkeit über: Nachrichtensyntax, Nachrichtensemantik, Topic-Verträge, Intent, Besitz, Bedeutung von State und Bedeutung von Events. Ziel ist nicht, Kopplung zu beseitigen, sondern unnötiges Wissen zu beseitigen. Konkret muss hier jeder Dienst genau einen fremden Event-Vertrag verstehen — ROT13 den E/text von ConsoleIn, ConsoleOut den E/crypted von ROT13 — plus das Intent-Schema, das er auf seinem eigenen I annimmt. Diese Liste ist das unverzichtbare Minimum.\nDavon getrennt: der Broker ist eine geteilte Infrastrukturabhängigkeit; alle brauchen seine Adresse, und ohne ihn läuft nichts. Real, aber anderer Art als das Wissen einer Komponente über eine andere.\nDie Prüfliste aus Schritt 78 ist das Werkzeug, das bleibt. Zwölf Fragen, von denen diese sechs das Argument dieses Systems tragen:\n\n\n\n\n\n\n\nFrage\nAntwort hier\n\n\n\n\nenthält eine Fähigkeit eine festgeschriebene Produzentenidentität?\nnein — sie kommt als Intent\n\n\nwelche fremden Verträge muss sie verstehen?\nje einen Event-Vertrag, plus ihr eigenes Intent-Schema\n\n\nwo ist die Topologie definiert?\nim Konfigurator, ausserhalb des Datenpfads\n\n\nkann sich die Topologie ohne Neukompilieren ändern?\nja — am laufenden System gezeigt\n\n\nkönnte der Transport ersetzt werden?\nja — gezeigt: Dateisystem, dann MQTT\n\n\nleistet jeder Vermittler etwas, das Vermittlung braucht?\nja, trivial: TEXT → TEXT braucht keine, und es gibt keinen\n\n\n\nDie Mahnung des Materials gilt: die Antworten müssen nicht alle „nein” lauten. Sie müssen absichtlich sein.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-whole-journey",
"href": "08-part-ix-mqtt.html#sec-whole-journey",
"title": "9  Teil IX — MQTT",
"section": "9.8 Der ganze Weg",
"text": "9.8 Der ganze Weg\nDas Programm hat sich nie geändert: eine Zeile geht hinein, dieselbe kommt um 13 Buchstaben verschoben heraus. Geändert hat sich, elfmal, wie die Teile verbunden sind und wer das Wissen über diese Verbindung hält.\n\n\n\n\n\n\n\n\n\nStufe\nwie die Teile verbunden sind\nwo die Topologie liegt\nim Datenpfad ausser den Fähigkeiten\n\n\n\n\n1 prozedural\ndirekte Aufrufe\nim Code der Fähigkeit\n—\n\n\n2 egoistische Dienste\ngar nicht verbunden\nnirgends — das ist das Problem\n—\n\n\n3 statische Vermittlung, eine JVM\nPostfächer, von Vermittlern kopiert\ndie Vermittler, gestartet in main()\nzwei Vermittler\n\n\n4 statische Vermittlung, Dateisystem\nVerzeichnisse, von Vermittlerprozessen kopiert\ndie Befehlszeilen des Bedieners\nzwei Vermittlerprozesse\n\n\n5 statische Vermittlung, Syncthing\nreplizierte Verzeichnisse\ndie Befehlszeilen des Bedieners\nzwei Vermittlerprozesse, dazu Replikationsverzögerung\n\n\n6 benannte, konfigurierbare Vermittler\nROUTE-Intent von einem Orchestrator\nder Orchestrator, ausserhalb des Pfads\nweiterhin die Vermittler\n\n\n7 dynamisch, eine JVM\ndie Dienste hören selbst, gesteuert durch TOPIC-Intent\nder Konfigurator\nnichts\n\n\n8 dynamisch, Dateisystem\ndasselbe, über Verzeichnisse\nder Konfigurator\nnichts\n\n\n9 dynamisch, Syncthing\ndasselbe, über replizierte Verzeichnisse\nder Konfigurator\nnichts — nur Transportsprünge\n\n\n10 Verträge\nkompatibel: direkt; inkompatibel: ein Transformator\nder Konfigurator\nein Transformator, nur wo Verträge sich unterscheiden\n\n\n11 MQTT\nTopics auf einem Broker\nder Konfigurator\nnichts — der Broker ist Transport\n\n\n\nDie dritte Spalte von oben nach unten gelesen: die Topologie wandert nach aussen, Stufe um Stufe, bis keine Fähigkeit mehr etwas davon hält. Die letzte gelesen: der Preis dieser Wanderung fällt in Stufe 7 auf null und bleibt dort, während darunter dreimal der Transport wechselt. Dieselbe Architektur, besserer Transport.",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "08-part-ix-mqtt.html#sec-sentences",
"href": "08-part-ix-mqtt.html#sec-sentences",
"title": "9  Teil IX — MQTT",
"section": "9.9 Die Sätze, die man behalten sollte",
"text": "9.9 Die Sätze, die man behalten sollte\n\n„Event-driven” beschreibt, wie Information und Steuerung fliessen.\nLose Kopplung beschreibt, wie viel die Beteiligten voneinander wissen müssen.\nVeröffentliche, was geschehen ist.\nErkläre, was du willst.\nVeröffentliche deinen eigenen Zustand.\nHalte Fähigkeiten egoistisch.\nHalte die Topologie aus den Fähigkeiten heraus.\nBezahle keinen Vermittler, der nicht wirklich vermittelt.\n\nUnd wann immer eine Architektur verwirrend wird, zurück zur ersten Frage dieses Buches: wer kennt wen?",
"crumbs": [
"<span class='chapter-number'>9</span>  <span class='chapter-title'>[Part IX — MQTT]{.en}[Partie IX — MQTT]{.fr}[Teil IX — MQTT]{.de}</span>"
]
},
{
"objectID": "glossary.html",
"href": "glossary.html",
"title": "Glossar",
"section": "",
"text": "Jeder Begriff unten wird dort definiert, wo er zum ersten Mal gebraucht wird, und von jeder späteren Erwähnung aus verlinkt. Der Pfeil eines Eintrags führt dorthin zurück.",
"crumbs": [
"Anhang",
"[Glossary]{.en}[Glossaire]{.fr}[Glossar]{.de}"
]
}
]