223 lines
28 KiB
JSON
223 lines
28 KiB
JSON
[
|
||
{
|
||
"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<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();\n\nBlockingQueue<Message> mailbox(String name) {\n return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());\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' > 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 <from> <to>\nder Klebstoff\n<from>\n<to>\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 <from> <to>\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": "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}"
|
||
]
|
||
}
|
||
] |