Added course's notes

This commit is contained in:
MatsuneMikuroi committed 2026-09-25 13:33:30 +02:00
1 parent e07993262c
commit dcd2c072ae
191 files changed
+42866 -12

No files matched your search

+373
View File
@@ -0,0 +1,373 @@
# [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} {#sec-part-i}
<!-- MULTILINGUAL: see the comment at the top of index.qmd. -->
::: {.en}
Steps 1 to 10 stay inside one JVM. The system is built three times: as direct calls, as three capabilities that refuse to know each other, and as those same capabilities glued together by mediators. Nothing is distributed yet, and that is the point: the only thing that changes is who knows whom.
:::
::: {.fr}
Les étapes 1 à 10 restent dans une seule JVM. Le système est construit trois fois : en appels directs, en trois capacités qui refusent de se connaître, puis en ces mêmes capacités reliées par des médiateurs. Rien n'est encore distribué, et c'est bien l'idée : la seule chose qui change est qui connaît qui.
:::
::: {.de}
Die 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.
:::
## [Step 1 — Rock bottom: just call it]{.en}[Étape 1 — Au plus simple : appeler, point]{.fr}[Schritt 1 — Ganz unten: einfach aufrufen]{.de} {#sec-step-1}
::: {.en}
`ProceduralRot13.java` is the whole system in one compact source file: a loop that reads a line, and one statement that prints the rotated text.
```java
void main() {
while (true) {
var text = IO.readln();
if (text == null)
return;
IO.println(rot13(text));
}
}
```
`IO.readln()` stands on its own line, but `rot13(text)` is not a step of its own: it is called *inside* the argument of `IO.println`. Neither `rot13` nor `IO.println` knows anything about the other. The one that knows both is `main()`, which names them and fixes their order.
What `main()` knows about `rot13`: that it exists, how to invoke it (a bare name, both live in the same implicitly generated class), what argument it takes, what it returns, that it is available *right now*, and that execution continues after it returns. It does not know how `rot13` is implemented — that is the one thing it can ignore.
The availability guarantee is worth naming, because it disappears later: `main()` and `rot13` are two methods of one already-loaded class, called on the same thread, in the same process. Nothing has to be started first, no message travels anywhere, no listener has to be subscribed.
**Observed:** typing a line prints it rotated; `Ctrl+D` ends the program silently, because `IO.readln()` returns `null` and `main()` returns.
:::
::: {.fr}
`ProceduralRot13.java` est le système entier dans un seul fichier source compact : une boucle qui lit une ligne, et une instruction qui affiche le texte transformé.
```java
void main() {
while (true) {
var text = IO.readln();
if (text == null)
return;
IO.println(rot13(text));
}
}
```
`IO.readln()` occupe sa propre ligne, mais `rot13(text)` n'est pas une étape distincte : il est appelé *dans* l'argument de `IO.println`. Ni `rot13` ni `IO.println` ne sait quoi que ce soit de l'autre. Celui qui connaît les deux, c'est `main()`, qui les nomme et fixe leur ordre.
Ce que `main()` sait de `rot13` : qu'il existe, comment l'invoquer (un simple nom, tous deux vivent dans la même classe générée implicitement), quel argument il prend, ce qu'il retourne, qu'il est disponible *à l'instant*, et que l'exécution continue après son retour. Il ne sait pas comment `rot13` est implémenté — c'est la seule chose qu'il peut ignorer.
La garantie de disponibilité mérite d'être nommée, car elle disparaîtra plus tard : `main()` et `rot13` sont deux méthodes d'une classe déjà chargée, appelées sur le même fil, dans le même processus. Rien n'a besoin d'être démarré d'abord, aucun message ne voyage, aucun auditeur n'a besoin d'être abonné.
**Observé :** taper une ligne l'affiche transformée ; `Ctrl+D` termine le programme sans rien afficher, car `IO.readln()` retourne `null` et `main()` retourne.
:::
::: {.de}
`ProceduralRot13.java` ist das ganze System in einer kompakten Quelldatei: eine Schleife, die eine Zeile liest, und eine Anweisung, die den rotierten Text ausgibt.
```java
void main() {
while (true) {
var text = IO.readln();
if (text == null)
return;
IO.println(rot13(text));
}
}
```
`IO.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.
Was `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.
Die 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.
**Beobachtet:** eine getippte Zeile erscheint rotiert; `Ctrl+D` beendet das Programm still, weil `IO.readln()` `null` zurückgibt und `main()` zurückkehrt.
:::
![[The procedural version. The wiring is written into the code: `main()` names all three parts and fixes their order.]{.en}[La version procédurale. Le câblage est écrit dans le code : `main()` nomme les trois parties et fixe leur ordre.]{.fr}[Die prozedurale Fassung. Die Verdrahtung steht im Code: `main()` nennt alle drei Teile und legt ihre Reihenfolge fest.]{.de}](figures/direct-calls-@tr{langcode}){#fig-direct-calls .flow-figure}
## [Step 2 — Three egoistic capabilities]{.en}[Étape 2 — Trois capacités égoïstes]{.fr}[Schritt 2 — Drei egoistische Fähigkeiten]{.de} {#sec-step-2}
::: {.en}
An **egoistic** component says: I know what I can do, what data I accept and what data I produce — and I would rather not know the business process around me. Concretely, `ConsoleIn` must not contain `rot13(...)`, and `ROT13` must not contain `consoleOut(...)`.
Removing those calls immediately creates a problem, which the tutorial states as a question: if nobody knows anybody, **who makes this into a system?** Note what the question does *not* say: the knowledge is not gone, it has to go somewhere else. Two connections are missing, not one — `ConsoleIn ↔ ROT13` and `ROT13 ↔ ConsoleOut`.
:::
::: {.fr}
Un composant **égoïste** dit : je sais ce que je peux faire, quelles données j'accepte et quelles données je produis — et je préfère ne pas connaître le processus métier qui m'entoure. Concrètement, `ConsoleIn` ne doit pas contenir `rot13(...)`, et `ROT13` ne doit pas contenir `consoleOut(...)`.
Supprimer ces appels crée aussitôt un problème, que le tutoriel formule en question : si personne ne connaît personne, **qui fait de cela un système ?** Notez ce que la question ne dit pas : la connaissance n'a pas disparu, elle doit aller ailleurs. Il manque deux liaisons, pas une — `ConsoleIn ↔ ROT13` et `ROT13 ↔ ConsoleOut`.
:::
::: {.de}
Eine **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(...)`.
Das Entfernen dieser Aufrufe schafft sofort ein Problem, das das Tutorial als Frage stellt: 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`.
:::
## [Step 3 — Give every capability a mailbox]{.en}[Étape 3 — Donner une boîte aux lettres à chaque capacité]{.fr}[Schritt 3 — Jeder Fähigkeit ein Postfach geben]{.de} {#sec-step-3}
::: {.en}
The smallest mechanism for the missing connections: a message and a named queue.
```java
record Message(String type, String value) {}
Map<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();
BlockingQueue<Message> mailbox(String name) {
return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());
}
```
The tutorial insists on calling these **mailboxes**, not topics, and gives the reason: if two readers call `take()` on the same mailbox, they compete — each message goes to exactly *one* of them and is not copied to both. A topic, in Publish/Subscribe, would hand every subscriber its own copy. One reader per message is enough for now, and the limitation is kept on purpose: it is what makes it clear later what Publish/Subscribe actually adds.
:::
::: {.fr}
Le plus petit mécanisme pour les liaisons manquantes : un message et une file nommée.
```java
record Message(String type, String value) {}
Map<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();
BlockingQueue<Message> mailbox(String name) {
return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());
}
```
Le tutoriel insiste pour appeler cela des **boîtes aux lettres** (*mailboxes*) et non des sujets (*topics*), et il en donne la raison : si deux lecteurs appellent `take()` sur la même boîte, ils sont en concurrence — chaque message va à *un seul* d'entre eux et n'est pas copié aux deux. Un *topic*, en Publish/Subscribe, remettrait à chaque abonné sa propre copie. Un lecteur par message suffit pour l'instant, et la limitation est conservée volontairement : c'est elle qui rendra visible plus tard ce que Publish/Subscribe apporte réellement.
:::
::: {.de}
Der kleinste Mechanismus für die fehlenden Verbindungen: eine Nachricht und eine benannte Warteschlange.
```java
record Message(String type, String value) {}
Map<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();
BlockingQueue<Message> mailbox(String name) {
return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());
}
```
Das Tutorial nennt diese bewusst **Postfächer** (*mailboxes*) und nicht Topics, mit Begründung: 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.
:::
## [Steps 4–6 — The three capabilities become egoistic]{.en}[Étapes 4–6 — Les trois capacités deviennent égoïstes]{.fr}[Schritte 4–6 — Die drei Fähigkeiten werden egoistisch]{.de} {#sec-steps-4-6}
::: {.en}
Each capability now touches only its own mailbox names:
| Capability | reads | writes |
|---|---|---|
| ConsoleIn | the keyboard | `consoleIn.outbox` |
| ROT13 | `rot13.inbox` | `rot13.outbox` |
| ConsoleOut | `consoleOut.inbox` | the console |
No capability contains the name of another. The tutorial's own summary of the result: "three nicely isolated capabilities. And they do absolutely nothing together." Nothing moves a message from `consoleIn.outbox` to `rot13.inbox`, or from `rot13.outbox` to `consoleOut.inbox`.
:::
::: {.fr}
Chaque capacité ne touche plus que ses propres noms de boîtes :
| Capacité | lit | écrit |
|---|---|---|
| ConsoleIn | le clavier | `consoleIn.outbox` |
| ROT13 | `rot13.inbox` | `rot13.outbox` |
| ConsoleOut | `consoleOut.inbox` | la console |
Aucune capacité ne contient le nom d'une autre. Le résumé du tutoriel lui-même : « trois capacités bien isolées. Et elles ne font absolument rien ensemble. » Rien ne déplace un message de `consoleIn.outbox` vers `rot13.inbox`, ni de `rot13.outbox` vers `consoleOut.inbox`.
:::
::: {.de}
Jede Fähigkeit berührt nur noch ihre eigenen Postfachnamen:
| Fähigkeit | liest | schreibt |
|---|---|---|
| ConsoleIn | die Tastatur | `consoleIn.outbox` |
| ROT13 | `rot13.inbox` | `rot13.outbox` |
| ConsoleOut | `consoleOut.inbox` | die Konsole |
Keine Fähigkeit enthält den Namen einer anderen. Die Zusammenfassung des Tutorials selbst: „drei schön isolierte Fähigkeiten. Und sie tun zusammen absolut nichts." Nichts bewegt eine Nachricht von `consoleIn.outbox` nach `rot13.inbox` oder von `rot13.outbox` nach `consoleOut.inbox`.
:::
## [Step 7 — Enter the mediator]{.en}[Étape 7 — Entre le médiateur]{.fr}[Schritt 7 — Auftritt des Vermittlers]{.de} {#sec-step-7}
::: {.en}
The smallest possible glue: a loop that takes from one mailbox and puts into another, knowing nothing about what travels through it.
```java
void mediate(String from, String to) {
while (true)
mailbox(to).put(mailbox(from).take());
}
```
`main()` starts five virtual threads: the three capabilities, plus two mediators whose routes are given as arguments — `consoleIn.outbox → rot13.inbox` and `rot13.outbox → consoleOut.inbox`.
**Observed:** `Hello World` in, `Uryyb Jbeyq` out, exactly as in step 1. But `Ctrl+D` no longer ends the program. ConsoleIn's thread *returns* (it does not loop), and the other four threads sit blocked in `take()` on empty mailboxes, using no CPU. What actually keeps the process alive is the last line of `main()`, `Thread.currentThread().join()`: the main thread waits for itself, which can never finish. Virtual threads are daemon threads, so those four waiting threads would not have kept the JVM running on their own.
:::
::: {.fr}
La colle la plus simple possible : une boucle qui retire d'une boîte et dépose dans une autre, sans rien savoir de ce qui la traverse.
```java
void mediate(String from, String to) {
while (true)
mailbox(to).put(mailbox(from).take());
}
```
`main()` démarre cinq threads virtuels : les trois capacités, plus deux médiateurs dont les routes sont passées en arguments — `consoleIn.outbox → rot13.inbox` et `rot13.outbox → consoleOut.inbox`.
**Observé :** `Hello World` en entrée, `Uryyb Jbeyq` en sortie, exactement comme à l'étape 1. Mais `Ctrl+D` ne termine plus le programme. Le thread de ConsoleIn *retourne* (il ne boucle pas), et les quatre autres threads restent bloqués dans `take()` sur des boîtes vides, sans consommer de CPU. Ce qui maintient réellement le processus en vie, c'est la dernière ligne de `main()`, `Thread.currentThread().join()` : le thread principal s'attend lui-même, ce qui ne peut jamais aboutir. Les threads virtuels sont des threads *daemon* : ces quatre threads en attente n'auraient donc pas maintenu la JVM en vie à eux seuls.
:::
::: {.de}
Der kleinstmögliche Klebstoff: eine Schleife, die aus einem Postfach nimmt und in ein anderes legt, ohne etwas über das Durchlaufende zu wissen.
```java
void mediate(String from, String to) {
while (true)
mailbox(to).put(mailbox(from).take());
}
```
`main()` 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`.
**Beobachtet:** `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.
:::
![[The mediated version inside one JVM. In the web version, **Play** walks one message through all eight hops.]{.en}[La version médiatisée dans une seule JVM. Dans la version web, **Lancer** fait parcourir à un message les huit sauts.]{.fr}[Die vermittelte Fassung in einer JVM. In der Webfassung schickt **Abspielen** eine Nachricht durch alle acht Sprünge.]{.de}](figures/mailboxes-jvm-@tr{langcode}){#fig-mailboxes-jvm .flow-figure}
## [Step 8 — Ask again: who knows whom?]{.en}[Étape 8 — Redemander : qui connaît qui ?]{.fr}[Schritt 8 — Nochmals fragen: wer kennt wen?]{.de} {#sec-step-8}
::: {.en}
Does ConsoleIn know ROT13? No. Does ROT13 know ConsoleIn or ConsoleOut? No. Has the topology disappeared? No — it sits in the two `mediate(...)` calls inside `main()`.
This is the tutorial's first major result:
> **Decoupling often does not make knowledge disappear. It moves knowledge to where it belongs.**
The capability "ROT13 transforms text" belongs to ROT13. The topology `ConsoleIn → ROT13 → ConsoleOut` belongs to system composition. What changed since step 1 is not that the wiring left `main()` — it is still there — but that it is no longer written *inside* a capability. It is now data: two pairs of mailbox names. Rewiring touches those two lines and no capability at all.
:::
::: {.fr}
ConsoleIn connaît-il ROT13 ? Non. ROT13 connaît-il ConsoleIn ou ConsoleOut ? Non. La topologie a-t-elle disparu ? Non — elle se trouve dans les deux appels `mediate(...)` à l'intérieur de `main()`.
C'est le premier résultat majeur du tutoriel :
> **Le découplage ne fait souvent pas disparaître la connaissance. Il la déplace là où elle appartient.**
La capacité « ROT13 transforme du texte » appartient à ROT13. La topologie `ConsoleIn → ROT13 → ConsoleOut` appartient à la composition du système. Ce qui a changé depuis l'étape 1, ce n'est pas que le câblage a quitté `main()` — il y est toujours — mais qu'il n'est plus écrit *à l'intérieur* d'une capacité. C'est désormais une donnée : deux paires de noms de boîtes. Recâbler touche ces deux lignes et aucune capacité.
:::
::: {.de}
Kennt ConsoleIn ROT13? Nein. Kennt ROT13 ConsoleIn oder ConsoleOut? Nein. Ist die Topologie verschwunden? Nein — sie steckt in den zwei `mediate(...)`-Aufrufen innerhalb von `main()`.
Das ist das erste grosse Ergebnis des Tutorials:
> **Entkopplung lässt Wissen oft nicht verschwinden. Sie verschiebt Wissen dorthin, wo es hingehört.**
Die 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.
:::
## [Step 9 — Why virtual threads?]{.en}[Étape 9 — Pourquoi des threads virtuels ?]{.fr}[Schritt 9 — Warum virtuelle Threads?]{.de} {#sec-step-9}
::: {.en}
Five loops now wait indefinitely: the keyboard, `rot13.inbox`, `consoleOut.inbox` and the two mediators' sources. Virtual threads are simply the cheap Java way to let five waits happen at once inside one JVM.
They are an implementation convenience, not an architecture. The architecture — who knows whom, and where the wiring lives — is in the mailbox names, not in the threads. The tutorial's own evidence for the separation: the same architecture will run as separate processes in step 11, with no threads shared between the parts.
:::
::: {.fr}
Cinq boucles attendent désormais indéfiniment : le clavier, `rot13.inbox`, `consoleOut.inbox` et les sources des deux médiateurs. Les threads virtuels sont simplement le moyen Java peu coûteux de faire attendre cinq choses à la fois dans une seule JVM.
C'est une commodité d'implémentation, pas une architecture. L'architecture — qui connaît qui, et où vit le câblage — réside dans les noms de boîtes, pas dans les threads. La preuve que donne le tutoriel : la même architecture tournera en processus séparés à l'étape 11, sans aucun thread partagé entre les parties.
:::
::: {.de}
Fü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.
Sie 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 des Tutorials für die Trennung: dieselbe Architektur läuft in Schritt 11 als getrennte Prozesse, ohne geteilte Threads zwischen den Teilen.
:::
## [Step 10 — Keep the services egoistic]{.en}[Étape 10 — Garder les services égoïstes]{.fr}[Schritt 10 — Die Dienste egoistisch halten]{.de} {#sec-step-10}
::: {.en}
The obvious shortcut: the first mediator only copies messages unchanged, so why not delete it and let ROT13 `take()` from `consoleIn.outbox` directly?
Because ROT13 would then contain the name `consoleIn.outbox`, which means it would know that ConsoleIn exists and where it publishes. The topology would move *into* ROT13, and ROT13 would stop being an egoistic capability. The test that makes this concrete: suppose the input comes from a new `FileIn` capability publishing to `fileIn.outbox`.
| | with the mediator | with the shortcut |
|---|---|---|
| what changes | one argument of the mediator | `runRot13` itself |
| who is touched | no capability | ROT13, whose job did not change |
The tutorial is honest about the price: this design "may look indirect — even a little odd", and it promises a different way to keep services egoistic *without* a mediator in every message's path.
:::
::: {.fr}
Le raccourci évident : le premier médiateur ne fait que recopier les messages tels quels, alors pourquoi ne pas le supprimer et laisser ROT13 faire `take()` directement sur `consoleIn.outbox` ?
Parce que ROT13 contiendrait alors le nom `consoleIn.outbox`, c'est-à-dire qu'il saurait que ConsoleIn existe et où il publie. La topologie entrerait *dans* ROT13, et ROT13 cesserait d'être une capacité égoïste. Le test qui rend cela concret : supposons que l'entrée vienne d'une nouvelle capacité `FileIn` publiant dans `fileIn.outbox`.
| | avec le médiateur | avec le raccourci |
|---|---|---|
| ce qui change | un argument du médiateur | `runRot13` lui-même |
| qui est touché | aucune capacité | ROT13, dont le travail n'a pas changé |
Le tutoriel est honnête sur le prix : ce design « peut sembler indirect — voire un peu bizarre », et il promet une autre manière de garder les services égoïstes *sans* médiateur sur le chemin de chaque message.
:::
::: {.de}
Die 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?
Weil 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.
| | mit Vermittler | mit der Abkürzung |
|---|---|---|
| was sich ändert | ein Argument des Vermittlers | `runRot13` selbst |
| wer berührt wird | keine Fähigkeit | ROT13, dessen Aufgabe unverändert blieb |
Das Tutorial ist ehrlich über den Preis: dieses Design „mag indirekt wirken — sogar etwas eigenartig", und es verspricht einen anderen Weg, Dienste egoistisch zu halten, *ohne* Vermittler im Pfad jeder Nachricht.
:::
## [What part I moved]{.en}[Ce que la partie I a déplacé]{.fr}[Was Teil I verschoben hat]{.de} {#sec-part-i-result}
::: {.en}
| stage | where the topology lives | who could rewire it |
|---|---|---|
| step 1 | inside the capability code (`IO.println(rot13(text))`) | whoever edits that code |
| steps 7–8 | in `main()`, as pairs of mailbox names | whoever edits `main()` |
Functionality: unchanged. Lines of code: more. Parts that know each other: none. That is the trade the rest of the tutorial keeps testing.
:::
::: {.fr}
| étape | où vit la topologie | qui peut recâbler |
|---|---|---|
| étape 1 | dans le code de la capacité (`IO.println(rot13(text))`) | celui qui édite ce code |
| étapes 7–8 | dans `main()`, en paires de noms de boîtes | celui qui édite `main()` |
Fonctionnalité : inchangée. Lignes de code : davantage. Parties qui se connaissent : aucune. C'est le compromis que le reste du tutoriel continue de mettre à l'épreuve.
:::
::: {.de}
| Stufe | wo die Topologie liegt | wer umverdrahten kann |
|---|---|---|
| Schritt 1 | im Code der Fähigkeit (`IO.println(rot13(text))`) | wer diesen Code ändert |
| Schritte 7–8 | in `main()`, als Paare von Postfachnamen | wer `main()` ändert |
Funktionalität: unverändert. Codezeilen: mehr. Teile, die einander kennen: keine. Das ist der Tauschhandel, den das restliche Tutorial immer wieder prüft.
:::