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
82 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": "Contrôle de processus",
"section": "",
"text": "À propos de ces notes\nCes notes suivent un petit programme à travers une longue série de reconstructions, de l’appel de méthode direct à une architecture événementielle sur MQTT. Chaque reconstruction laisse le programme faire exactement ce qu’il faisait avant, et change qui connaît qui.\nLe programme construit ne change jamais : vous tapez une ligne, elle revient décalée de 13 lettres.\nCe qui change, c’est tout ce qui l’entoure. Le même système est reconstruit encore et encore, et chaque reconstruction pose trois questions, dans cet ordre :\nUn résumé est ajouté ici chaque fois qu’une étape est terminée : le livre grandit donc au rythme du travail. Chaque résumé dit ce que l’étape a fait, ce qui a été observé à l’exécution, et ce qui a bougé sur le plan architectural — en général une connaissance qui a changé de mains.\nD’après le matériel de Reto Konig, Université de Fribourg.",
"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": "Contrôle de processus",
"section": "Comment lire les figures",
"text": "Comment lire les figures\nChaque figure existe une fois comme dessin et trois fois comme langue. Dans la version web, une figure qui porte un flux de messages possède une petite barre de lecture : Lancer fait parcourir toute la chaîne à un message, Un saut avance d’une seule étape, et Réinitialiser remet tout à zéro. Les boîtes s’allument au passage du message : on voit ainsi quel composant attend et lequel travaille.\nDans le PDF, et dans un navigateur sans JavaScript, la même image est là — simplement immobile. Rien dans ces notes ne dépend de l’animation.",
"crumbs": [
"[About these notes]{.en}[À propos de ces notes]{.fr}[Über diese Notizen]{.de}"
]
},
{
"objectID": "00-orientation.html",
"href": "00-orientation.html",
"title": "1  Étape 0 — De quoi il s’agit",
"section": "",
"text": "1.1 Les trois questions\nL’étape 0 ne contient aucun code. Elle énonce le sujet : non pas ROT13, mais l’architecture autour de lui. La fonctionnalité reste presque inchangée pendant 81 étapes, et c’est précisément ce qui rend visibles les changements alentour.\nDeux règles sont posées ici et valent jusqu’au bout :\nC’est pourquoi la construction ne commence ni par MQTT, ni par les abonnements dynamiques. Un système aux médiateurs délibérément maladroits est bâti d’abord, mis en service, et l’on demande seulement ensuite s’ils ont mérité leur place.\nLa seconde règle concerne le vocabulaire : Intent, Status/State et Event ne sont nommés qu’après avoir été utilisés. Ils apparaissent vers l’étape 42, pas avant.\nL’itinéraire prévu, dès l’étape 0 :\nLa formulation des trois questions compte, et il est facile de la remplacer par une version plus faible :\n« Connaître » n’est pas « communiquer » : deux composants peuvent échanger des messages toute la journée sans que l’un nomme l’autre. « Décider du câblage » n’est pas « relier » : la partie qui transmet les messages n’est pas forcément celle qui a choisi la route. Les deux distinctions deviennent concrètes plus tard — la première dès l’étape 1, la seconde dans la partie 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  Étape 0 — De quoi il s’agit",
"section": "",
"text": "Telle qu’elle est posée ici\nUne version plus faible\n\n\n\n\nQui connaît qui ?\nqui communique avec qui\n\n\nQui possède quoi ?\nquelles données détient chaque partie\n\n\nQui décide du câblage ?\nquelle partie relie le tout",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "",
"text": "2.1 Étape 1 — Au plus simple : appeler, point\nLes é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.\nProceduralRot13.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é.\nIO.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.\nCe 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.\nLa 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é.\nObservé : taper une ligne l’affiche transformée ; Ctrl+D termine le programme sans rien afficher, car IO.readln() retourne null et main() retourne.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"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\nFigure 2.1: La version procédurale. Le câblage est écrit dans le code : main() nomme les trois parties et fixe leur ordre.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.2 Étape 2 — Trois capacités égoïstes",
"text": "2.2 Étape 2 — Trois capacités égoïstes\nUn 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(...).\nSupprimer ces appels crée aussitôt un problème, qui se pose 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.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.3 Étape 3 — Donner une boîte aux lettres à chaque capacité",
"text": "2.3 Étape 3 — Donner une boîte aux lettres à chaque capacité\nLe plus petit mécanisme pour les liaisons manquantes : un message et une file nommée.\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}\nCe sont des boîtes aux lettres (mailboxes) et non des sujets (topics), et la distinction mérite qu’on y insiste : 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.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.4 Étapes 4–6 — Les trois capacités deviennent égoïstes",
"text": "2.4 Étapes 4–6 — Les trois capacités deviennent égoïstes\nChaque capacité ne touche plus que ses propres noms de boîtes :\n\n\n\nCapacité\nlit\nécrit\n\n\n\n\nConsoleIn\nle clavier\nconsoleIn.outbox\n\n\nROT13\nrot13.inbox\nrot13.outbox\n\n\nConsoleOut\nconsoleOut.inbox\nla console\n\n\n\nAucune capacité ne contient le nom d’une autre, et c’est exactement le résultat : trois capacités bien isolées qui ne font absolument rien ensemble. Rien ne déplace un message de consoleIn.outbox vers rot13.inbox, ni de rot13.outbox vers 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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.5 Étape 7 — Entre le médiateur",
"text": "2.5 Étape 7 — Entre le médiateur\nLa 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.\nvoid mediate(String from, String to) {\n while (true)\n mailbox(to).put(mailbox(from).take());\n}\nmain() 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.\nObservé : 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.\n\n\n\n\n\n\nFigure 2.2: La version médiatisée dans une seule JVM. Dans la version web, Lancer fait parcourir à un message les huit sauts.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.6 Étape 8 — Redemander : qui connaît qui ?",
"text": "2.6 Étape 8 — Redemander : qui connaît qui ?\nConsoleIn 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().\nC’est le premier résultat majeur :\n\nLe découplage ne fait souvent pas disparaître la connaissance. Il la déplace là où elle appartient.\n\nLa 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é.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.7 Étape 9 — Pourquoi des threads virtuels ?",
"text": "2.7 Étape 9 — Pourquoi des threads virtuels ?\nCinq 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.\nC’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 de cette séparation : la même architecture tournera en processus séparés à l’étape 11, sans aucun thread partagé entre les parties.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.8 Étape 10 — Garder les services égoïstes",
"text": "2.8 Étape 10 — Garder les services égoïstes\nLe 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 ?\nParce 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.\n\n\n\n\n\n\n\n\n\navec le médiateur\navec le raccourci\n\n\n\n\nce qui change\nun argument du médiateur\nrunRot13 lui-même\n\n\nqui est touché\naucune capacité\nROT13, dont le travail n’a pas changé\n\n\n\nLe prix mérite d’être dit clairement : ce design peut sembler indirect — voire un peu bizarre. Il existe une autre manière de garder les services égoïstes sans médiateur sur le chemin de chaque message ; elle viendra plus tard.",
"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  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.9 Ce que la partie I a déplacé",
"text": "2.9 Ce que la partie I a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\nqui peut recâbler\n\n\n\n\nétape 1\ndans le code de la capacité (IO.println(rot13(text)))\ncelui qui édite ce code\n\n\nétapes 7–8\ndans main(), en paires de noms de boîtes\ncelui qui édite main()\n\n\n\nFonctionnalité : inchangée. Lignes de code : davantage. Parties qui se connaissent : aucune. C’est le compromis que tout ce qui suit continue de mettre à l’épreuve.",
"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  Partie II — Franchir la frontière de processus",
"section": "",
"text": "3.1 Étape 11 — Séparer les composants\nLes étapes 11 à 18 reprennent l’architecture de la partie I et la répartissent sur cinq processus du système d’exploitation, sur un seul ordinateur. Les capacités gardent leurs noms de boîtes ; seul le transport en dessous change, des objets Java vers des fichiers dans des répertoires. Le premier problème réellement distribué apparaît ici, et il n’a rien à voir avec ROT13.\nTrois processus ne peuvent pas partager une BlockingQueue : chaque commande java démarre sa propre JVM avec sa propre mémoire, la carte mailboxes existerait donc en trois exemplaires et chacun ne verrait que ses propres messages. Il faut un transport externe.\nTCP conviendrait, MQTT conviendrait. C’est délibérément l’option la plus primitive qui est choisie, le système de fichiers, pour une raison en une ligne : parce qu’on peut le voir. Les messages deviennent des fichiers que l’on peut lister avec ls et lire avec cat pendant que le système tourne. Primitif ne veut pas dire inférieur : la partie VIII revient sur ce que le système de fichiers fait vraiment bien et vraiment mal.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.2 Étapes 12–13 — Un répertoire devient une boîte aux lettres",
"text": "3.2 Étapes 12–13 — Un répertoire devient une boîte aux lettres\nLa correspondance tient en une ligne :\ndirectory = mailbox file = message\npublish = create file receive = watch directory\nmessageBoard/\n├── consoleIn/outbox/\n├── rot13/inbox/\n├── rot13/outbox/\n└── consoleOut/inbox/\nLe record Message gagne un horodatage optionnel, et le format de fichier reste deux lignes plus une troisième facultative :\nTEXT\nHello World\nTIMESTAMP: 2026-09-22T10:42:12.123Z\nUn message écrit à la main peut omettre l’horodatage. Le marqueur TIMESTAMP: empêche qu’une ligne de contenu ressemblant à une date soit prise pour une métadonnée ; dans ce format minuscule, une dernière ligne commençant par TIMESTAMP: est réservée.\nJackson pourrait être introduit ici et ne l’est volontairement pas. L’intérêt d’un format ridiculement simple, c’est que presque rien ne cache l’architecture — le message entier est lisible dans n’importe quel éditeur de texte, ce qui maintient l’attention sur qui parle à qui.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.3 Étape 14 — Le premier problème de système distribué : la publication",
"text": "3.3 Étape 14 — Le premier problème de système distribué : la publication\nUn lecteur qui surveille un répertoire peut découvrir un fichier avant que l’écrivain ait fini de l’écrire. D’où un protocole de publication :\n\ncréer un fichier temporaire privé ;\nécrire le message complet ;\nle fermer ;\nle renommer atomiquement vers son nom final .msg ;\nles consommateurs ne réagissent qu’aux fichiers finaux.\n\nFiles.writeString(temporary, content);\nFiles.move(temporary, published, StandardCopyOption.ATOMIC_MOVE);\nLes deux moitiés sont nécessaires. Le renommage est atomique — un lecteur voit soit aucun fichier .msg, soit le fichier complet — mais il ne protège rien si les lecteurs ramassent aussi les .tmp. .tmp et .msg restent dans le même répertoire, pour que le déplacement ne traverse pas de système de fichiers, où l’atomicité serait perdue.\n\nÉcrire et publier ne sont pas la même opération.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.4 Étape 15 — Observer une boîte avec WatchService",
"text": "3.4 Étape 15 — Observer une boîte avec WatchService\nL’observateur de système de fichiers de Java fournit la moitié consommateur : enregistrer un répertoire pour ENTRY_CREATE, se bloquer dans watcher.take(), et ignorer tout nom de fichier qui ne finit pas par .msg.\nCela donne aussi un outil d’injection très rudimentaire. Avec ActuatorService lancé comme consommateur :\nprintf 'TEXT\\nHello from a file' &gt; messageBoard/consoleOut/inbox/manual.tmp\nmv messageBoard/consoleOut/inbox/manual.tmp messageBoard/consoleOut/inbox/manual.msg\nObservé : rien ne se passe à l’apparition du fichier .tmp ; la ligne est affichée à l’instant où le renommage crée le nom .msg. Les deux formats acceptés fonctionnent, avec et sans horodatage final.\nLe point architectural s’écrit producer → filesystem → consumer : le consommateur n’a pas pu distinguer un humain tapant mv d’un véritable service. Il connaît sa propre boîte d’entrée, pas qui y écrit. L’égoïsme a survécu à la frontière de processus.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.5 Étapes 16–17 — Services et médiateur deviennent des processus",
"text": "3.5 Étapes 16–17 — Services et médiateur deviennent des processus\nLes trois capacités deviennent trois programmes, et le médiateur un quatrième type de programme :\n\n\n\n\n\n\n\n\n\nprogramme\njoue\nlit\nécrit\n\n\n\n\nSensorService.java\nConsoleIn\nle clavier\nconsoleIn/outbox\n\n\nProcessorService.java\nROT13\nrot13/inbox\nrot13/outbox\n\n\nActuatorService.java\nConsoleOut\nconsoleOut/inbox\nla console\n\n\nMediator.java &lt;from&gt; &lt;to&gt;\nla colle\n&lt;from&gt;\n&lt;to&gt;\n\n\n\nLe médiateur est générique : sa route n’est pas compilée en dur, elle arrive en deux arguments de démarrage. Mais une asymétrie mérite d’être gardée en tête : les trois capacités reçoivent leur travail sous forme de messages dans une boîte, tandis que le médiateur reçoit sa route comme configuration de démarrage, et il n’a ni nom ni boîte de contrôle propre où quelqu’un pourrait écrire.\nConséquence pratique : les arguments sont lus une seule fois, donc changer la route d’un médiateur en cours d’exécution exige de l’arrêter et de le relancer. Un fichier de configuration ne changerait rien — il est lui aussi lu au démarrage. Ce point reste volontairement ouvert jusqu’à ce que le coût des médiateurs distribués ait été ressenti.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.6 Étape 18 — Exécuter la version entièrement externe, en local",
"text": "3.6 Étape 18 — Exécuter la version entièrement externe, en local\nCinq terminaux, cinq processus, un seul système de fichiers local entre eux :\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\nObservé : Hello World tapé dans le terminal 1 est apparu comme Uryyb Jbeyq dans le terminal 5. Les trois terminaux du milieu n’ont rien affiché de nouveau — chaque médiateur affiche une ligne « Mediating: … » au démarrage, et ProcessorService n’affiche rien du tout. Ensuite, chacun des quatre répertoires de boîtes contenait un fichier .msg : la même ligne, recopiée le long de la chaîne.\nComptons : cinq processus pour ce que l’étape 1 faisait en une instruction. Ce n’est pas le moment d’optimiser : ce n’est pas encore censé être confortable.\n\n\n\n\n\n\nFigure 3.1: Les cinq processus et les quatre répertoires de boîtes. Dans la version web, Lancer suit une ligne de texte du clavier à la console.",
"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  Partie II — Franchir la frontière de processus",
"section": "3.7 Ce que la partie II a déplacé",
"text": "3.7 Ce que la partie II a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\nqui peut recâbler\n\n\n\n\nétape 1\ndans le code de la capacité\ncelui qui édite ce code\n\n\nétapes 7–8\ndans main(), en noms de boîtes\ncelui qui édite main()\n\n\nétape 18\ndans les deux lignes de commande Mediator.java &lt;from&gt; &lt;to&gt;\ncelui qui lance les processus\n\n\n\nLa topologie a maintenant quitté le code source : aucun fichier .java ne contient la route. Elle vit dans ce que l’opérateur a tapé, ce qui fait d’une personne l’orchestrateur actuel. Ce que la version à cinq processus apporte est réel — le câblage peut changer sans toucher aucun programme — et ce qu’elle coûte l’est tout autant : cinq processus, quatre copies de chaque message, et un programme qui ne s’arrête plus quand on appuie sur Ctrl+D.",
"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  Partie III — Le rendre réellement distribué",
"section": "",
"text": "4.1 Syncthing réplique ; il ne distribue pas\nCinq processus sur un seul ordinateur partagent encore un même système de fichiers. Les étapes 19 à 27 les répartissent sur deux machines, répliquent le tableau de messages entre elles avec Syncthing, mesurent ce que cela coûte, puis cassent délibérément un médiateur. À la fin, le prix des médiateurs est un chiffre, non une opinion.\nSyncthing maintient un répertoire répliqué entre plusieurs machines. C’est tout ce qu’on lui demande ici. Il ne sait rien d’Intent, de Status, d’Event, de ROT13 ni des médiateurs, et il n’a aucune notion de consommateur : pas d’abonnement, pas de sujet, aucune garantie de livraison, aucune idée que quelqu’un attend.\nLe déclencheur reste le nôtre. Chaque service exécute son propre WatchService sur un répertoire local ; Syncthing fait seulement apparaître les fichiers à cet endroit. C’est pourquoi aucun des trois services n’a changé d’une ligne lorsque le système est devenu distribué.\nDeux conséquences en découlent, et toutes deux apparaîtront comme des observations plutôt que comme des avertissements :",
"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  Partie III — Le rendre réellement distribué",
"section": "",
"text": "la réplication est asynchrone — le renommage .tmp → .msg est atomique sur chaque machine séparément, et rien ne promet d’ordre ni d’atomicité entre machines ;\nle système de fichiers est un transport sérieux, avec ses forces : les fichiers peuvent être gros, les répliques survivent à un redémarrage, et chaque message se lit avec cat.",
"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  Partie III — Le rendre réellement distribué",
"section": "4.2 Tester une couche à la fois",
"text": "4.2 Tester une couche à la fois\nAvant que le moindre programme Java ne touche au dossier répliqué, le test le plus ennuyeux possible a été fait d’abord : écrire hello.txt sur une machine, vérifier qu’il apparaît sur l’autre, le supprimer, vérifier que la suppression revient. Les deux sens fonctionnent.\nCet ordre compte. Quand l’exécution distribuée a échoué plus tard, la question « est-ce la réplication ou mon programme ? » était déjà tranchée pour le transport, et la recherche pouvait commencer une couche plus haut.",
"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  Partie III — Le rendre réellement distribué",
"section": "4.3 Ce que coûte une frappe",
"text": "4.3 Ce que coûte une frappe\nAvec le capteur sur une machine et les médiateurs, ROT13 et l’actionneur sur l’autre, une ligne tapée a produit quatre fichiers .msg, un par boîte :\n\n\n\nboîte\ncontenu\nhorodatage interne\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\nLes horodatages répétés prouvent que deux de ces quatre publications sont de pures copies : les médiateurs republient le message inchangé, horodatage compris. Ils calculent identity(x) = x, sous forme de processus distribués distincts.\nLe temps, mesuré sur les dates de modification des quatre fichiers d’une seule machine pour qu’aucun décalage d’horloge n’intervienne : le fichier du capteur apparaît à 01:02:05.432, les trois autres à 01:02:13.460, .504 et .532 — 8,10 s plus tard, et à 72 ms l’un de l’autre. Le travail propre de la chaîne a donc pris des millisecondes ; les huit secondes sont la propagation de Syncthing. La même chaîne, exécutée entièrement sur une machine, termine en 24 ms environ.",
"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  Partie III — Le rendre réellement distribué",
"section": "4.4 Casser un médiateur",
"text": "4.4 Casser un médiateur\nArrêtez le premier médiateur et tapez deux lignes. ConsoleIn est vivant, ROT13 est vivant, ConsoleOut est vivant, Syncthing est vivant — et le flux métier est mort. Les deux lignes s’accumulent dans consoleIn/outbox ; rien ne va plus loin. Les médiateurs font partie de la chaîne de disponibilité.\nRedémarrez ensuite le médiateur. Rien n’est livré. FileMessageBoard.watch enregistre un répertoire pour ENTRY_CREATE et se bloque dans watcher.take() ; il ne liste jamais ce qui est déjà là. Les deux fichiers sont toujours sur le disque, dans les deux répliques : aucune donnée n’a été perdue. Ce qui n’a pas de mémoire, c’est l’abonnement.\nLa distinction mérite d’être retenue : les messages ont survécu, la livraison non. Un courtier répond à cela par l’état de session et les messages retenus ; dans notre propre code, ce serait une ligne — lister les fichiers .msg existants avant d’entrer dans la boucle d’observation — que le matériel se garde volontairement d’écrire pour l’instant.",
"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  Partie III — Le rendre réellement distribué",
"section": "4.5 Le médiateur devient un service ordinaire",
"text": "4.5 Le médiateur devient un service ordinaire\nAvant de supprimer les médiateurs, une asymétrie disparaît : les services reçoivent leur travail sous forme de messages, alors que le médiateur recevait sa route en arguments de shell. On ne lui donne donc qu’un nom, ConfigurableMediator mediator1, dont il dérive une boîte de contrôle permanente, mediators/mediator1/inbox, et la route arrive comme message :\nROUTE\nconsoleIn/outbox\nrot13/inbox\nfrom et to voyagent dans un seul message, volontairement : en deux, le médiateur combinerait brièvement une nouvelle source avec l’ancienne destination et transmettrait au mauvais endroit. Une route est un seul fait, et un fait tient dans un message.\nUn orchestrateur éphémère publie les deux routes puis s’arrête : la topologie est visible en un seul endroit et n’est pas dans le chemin des données. Le lancer après les services, en ayant tapé une ligne avant, montre les deux moitiés d’un coup : la ligne précoce reste bloquée, la suivante circule.\nCe qui s’améliore : le médiateur a une identité, reçoit sa configuration par sa propre boîte, garde une capacité générique et tient sa topologie d’un orchestrateur. Ce qui ne s’améliore pas : le chemin des données. Il reste event → médiateur → copie de l'event, toujours un processus dans la chaîne de disponibilité, qui copie chaque message sans rien y ajouter. Et cette version accepte exactement une route : waitForRoute(...) retourne, puis le médiateur entre dans watch(route.from(), …) et ne lit plus jamais sa boîte de contrôle. Le recâblage à chaud n’est pas promis, car un watch bloquant ne peut pas servir à la fois une boîte de contrôle et une source — d’où l’aide à l’abonnement qui apparaît plus tard.",
"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  Partie III — Le rendre réellement distribué",
"section": "4.6 Ce que la partie III a déplacé",
"text": "4.6 Ce que la partie III a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\ndans le chemin des données ?\n\n\n\n\nétape 18\nles lignes de commande de l’opérateur\nles médiateurs y sont\n\n\nétape 27\nun orchestrateur, publiée comme Intent\nles médiateurs y sont encore\n\n\n\nLa question sur laquelle se referme la partie est donc précise et non rhétorique : pourquoi le service intéressé par la donnée ne pourrait-il pas l’écouter lui-même ?",
"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  Partie IV — Rembobinage",
"section": "",
"text": "5.1 Le raccourci évident, et son piège\nLes étapes 28 à 34 reviennent volontairement à une seule JVM. Sans délai de réplication ni cinq terminaux, la seule chose qui peut changer est qui connaît qui — l’idée s’essaie donc en quelques secondes plutôt que pendant une séance de débogage distribué.\nSi le premier médiateur ne fait que copier des messages, supprimons-le et laissons ROT13 lire la source lui-même :\nLe médiateur a disparu. Mais posons la question récurrente : ROT13 contient désormais le nom de la boîte de ConsoleIn. La topologie a quitté le médiateur pour entrer dans le service. Comme le dit le matériel : « nous avons supprimé le médiateur… et remis la topologie dans le service. Oups. »",
"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  Partie IV — Rembobinage",
"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  Partie IV — Rembobinage",
"section": "5.2 La capacité n’est pas la topologie",
"text": "5.2 La capacité n’est pas la topologie\nROT13 peut savoir deux choses : je sais transformer du texte et je suis capable d’écouter des messages texte compatibles. Il ne doit pas savoir mon entrée vient toujours de consoleIn.outbox — c’est de la topologie de déploiement.\nLe nom n’est donc pas compilé ; il arrive à l’exécution :\nTOPIC consoleIn.outbox\nROT13 apprend son câblage par la donnée. Notez qui l’envoie : dans DynamicQueueRot13.java, c’est main() qui publie les deux messages TOPIC — un configurateur, hors du chemin des données, dans le rôle qu’occupait l’orchestrateur. Ce ne peut pas être ConsoleIn : s’il disait à ROT13 à quoi s’abonner, il devrait savoir que ROT13 existe, et la topologie aurait seulement changé de capacité d’accueil.",
"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  Partie IV — Rembobinage",
"section": "5.3 Ce qui change dans le code",
"text": "5.3 Ce qui change dans le code\nlisten(...) n’a rien d’exotique : un thread virtuel qui appelle take() en boucle sur l’une des mêmes files. subscribe(...) démarre un tel thread par nom abonné. La conséquence se voit dans les boîtes :\n\nROT13 retire directement de consoleIn.outbox — le nom qu’on lui a transmis ;\nrot13.inbox n’est plus une boîte de charge utile. Elle porte des messages de contrôle, et la boucle de ROT13 la lit pour décider si un message est un TOPIC à appliquer.\n\nPlus rien n’écrit dans rot13.inbox pour déplacer des données. La boîte n’a pas disparu : elle a changé de métier, de la charge utile vers l’Intent.\nUne observation à l’exécution : après Ctrl+D, la sortie s’arrête mais le programme reste en vie. Rien n’a été interrompu — runConsoleIn retourne à la fin de l’entrée, donc le producteur a disparu, tandis que les deux threads abonnés restent bloqués dans take() sur des sources qui ne publieront plus. La JVM survit parce que main finit par Thread.currentThread().join(). « Le flux s’est arrêté » doit toujours être ramené à quel participant s’est arrêté.",
"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  Partie IV — Rembobinage",
"section": "5.4 ROUTE et TOPIC sont de l’Intent",
"text": "5.4 ROUTE et TOPIC sont de l’Intent\nAppliquons deux tests à TOPIC consoleIn.outbox. Décrit-il quelque chose qui est arrivé ? Non. Quelque chose actuellement vrai ? Non. Il dit commence à écouter ici — un comportement souhaité, donc de l’Intent. Le ROUTE du médiateur est du même genre : transmets d’ici à là.\nUn piège à nommer, car il est tentant dans une soutenance : publier un Intent est bien sûr quelque chose qui est arrivé. La classification suit ce que dit le message, pas le fait qu’il existe.\nEt une condition, qui reviendra : la version dynamique n’est pas automatiquement supérieure. Elle n’a de sens que si le consommateur comprend vraiment le contrat de message du producteur.\nMÉDIÉ STATIQUE DIRECT DYNAMIQUE\nProducteur → Médiateur → Consommateur Intent → (Producteur ──► Consommateur)",
"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  Partie V — Rejouer l’idée dynamique entre processus",
"section": "",
"text": "6.1 Une observation bloquante ne suffit pas\nLes étapes 35 à 38 sortent l’idée d’abonnement de la JVM unique. Les services redeviennent des programmes séparés, mais au lieu de médiateurs qui copient des fichiers, chaque service observe la boîte qu’on lui a indiquée. Une hypothèse du premier utilitaire de fichiers ne survit pas au déplacement, et c’est bien de la corriger qu’il s’agit ici.\nFileMessageBoard.watch(topic, receiver) enregistre un répertoire et se bloque indéfiniment. Cela suffisait tant que chaque processus observait une boîte fixe. Un service câblé dynamiquement demande davantage :\nL’ancienne signature ne peut pas exprimer cela, et la conséquence était déjà visible : le médiateur configurable n’acceptait qu’une seule ROUTE, car dès qu’il observait sa source il devenait sourd à sa propre boîte de contrôle. La limite n’a jamais été de qui est le répertoire, mais un seul, fixe, pour toujours.",
"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  Partie V — Rejouer l’idée dynamique entre processus",
"section": "",
"text": "observer en permanence sa propre boîte de contrôle\nET\najouter un répertoire observé à l'exécution\nET\néventuellement le retirer ensuite",
"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  Partie V — Rejouer l’idée dynamique entre processus",
"section": "6.2 L’utilitaire : FileSubscriptions",
"text": "6.2 L’utilitaire : FileSubscriptions\nUn seul WatchService peut servir plusieurs répertoires. register(...) retourne un WatchKey qui en identifie un, watcher.take() retourne la clé qui a des événements, et key.cancel() la désenregistre. L’utilitaire garde les deux sens, nom → clé et clé → nom, pour qu’un événement puisse être rattaché à la boîte dont il vient.\nLes événements n’arrivent pas directement dans un callback. Ils passent par une file, lue avec take(), et portent\nrecord IncomingMessage(String mailbox, Message message) {}\nDeux raisons, l’ordre d’arrivée n’étant que la troisième. D’abord, le thread observateur doit rester réactif pour tous les répertoires abonnés : un callback qui transforme, publie ou bloque arrêterait l’observation de tous les autres. Ensuite, le nom de la boîte voyage avec le message, de sorte qu’une seule boucle du service peut décider de son sens — boîte de contrôle, donc un Intent à appliquer ; source abonnée, donc des données à transformer — et cette même boucle peut ajouter ou retirer des abonnements, puisqu’elle n’est pas prisonnière d’un callback.",
"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  Partie V — Rejouer l’idée dynamique entre processus",
"section": "6.3 Deux publications au lieu de quatre",
"text": "6.3 Deux publications au lieu de quatre\nLancez SensorService, DynamicProcessorService et DynamicActuatorService — sans médiateurs — puis laissez Configure.java publier les deux messages TOPIC. Une ligne tapée ensuite laisse exactement deux publications applicatives dans le tableau :\n\n\n\nboîte\ncontenu\nnature\n\n\n\n\nconsoleIn/outbox\nTEXT hello\nl’entrée\n\n\nrot13/outbox\nTEXT uryyb\nle résultat\n\n\nrot13/inbox\nTOPIC consoleIn/outbox\nIntent, publié une fois\n\n\nconsoleOut/inbox\nTOPIC rot13/outbox\nIntent, publié une fois\n\n\n\nconsoleOut/inbox ne contient aucune charge utile : ConsoleOut retire directement de rot13/outbox. Sa boîte a changé de métier, des messages vers le câblage.\nUne ligne tapée avant l’exécution de Configure.java reste dans consoleIn/outbox pour toujours. Un abonnement qui n’existe pas encore manque ce qui l’a précédé — le même constat que le médiateur redémarré qui n’a rien livré.\n\n\n\n\n\n\n\n\nversion\npublications applicatives\nprocessus dans le chemin des données\n\n\n\n\nmédiée (étape 18)\n4\n5\n\n\nmédiateur configurable (étape 27)\n4\n5\n\n\ndynamique (étape 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  Partie VI — Rejouer sur Syncthing, et nommer les messages",
"section": "",
"text": "7.1 L’exécution dynamique distribuée\nLes étapes 39 à 47 répartissent la version dynamique sur deux machines, précisent ce que « direct » veut dire, puis — maintenant seulement, après avoir utilisé les idées — donnent leurs noms aux trois sortes de messages : Intent, Status, Event.\nCapteur sur une machine, ROT13 et l’actionneur sur l’autre, aucun médiateur. Après la réplication des deux Intents TOPIC, une ligne tapée a produit le résultat sur l’autre machine — et le tableau montre ce que cela coûte :\nLe temps est la partie intéressante. L’entrée a été publiée à 02:35:12 et les résultats sont apparus sur la première machine à 04:11:28,797 et ,893 — à 96 ms d’écart, bien après l’entrée. Syncthing était saturé pendant la nuit : le lot est arrivé quand la file s’est vidée. La chaîne est restée correcte ; la latence du transport n’est tout simplement pas contrôlée par l’architecture. À comparer aux 24 ms de la même chaîne sur une seule machine.",
"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  Partie VI — Rejouer sur Syncthing, et nommer les messages",
"section": "",
"text": "consoleIn/outbox : l’entrée ;\nrot13/outbox : le résultat, écrit par le service qui l’a produit ;\nconsoleOut/inbox : de l’Intent seulement, là où la version médiée contenait une copie complète de chaque message.",
"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  Partie VI — Rejouer sur Syncthing, et nommer les messages",
"section": "7.2 Ce que « direct » veut dire, exactement",
"text": "7.2 Ce que « direct » veut dire, exactement\nDeux sauts qui se ressemblent sont architecturalement opposés :\n\nun saut de transport — Syncthing de chaque côté, éventuellement un relais entre les deux — n’ajoute aucun participant qui connaisse la topologie, et rien n’y réagit. Si les paquets passaient par un autre continent, aucune affirmation ici ne serait contredite.\nun saut architectural — un médiateur copiant consoleIn/outbox → rot13/inbox — ajoute un composant qui doit connaître les deux noms, se place dans la chaîne de disponibilité et republie le message.\n\nL’affirmation défendable est donc : ROT13 réagit à la publication de ConsoleIn sans aucun de nos composants entre les deux, et sans contenir l’identité de ConsoleIn. Et non : les données vont directement de A à B. L’architecture décide à quels messages un service réagit, pas du routage du transport.",
"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  Partie VI — Rejouer sur Syncthing, et nommer les messages",
"section": "7.3 Intent, Status, Event",
"text": "7.3 Intent, Status, Event\nTrois sortes de messages, nommées seulement après avoir été utilisées :\n\n\n\n\n\n\n\n\n\ndit\nnos exemples\n\n\n\n\nE — Event\nquelque chose est arrivé\nTEXT hello comme ConsoleIn/E/text ; TEXT uryyb comme ROT13/E/crypted\n\n\nS — Status/State\nquelque chose est actuellement vrai\nROT13/S/subscriptions — pas encore publié par notre système\n\n\nI — Intent\nce qui devrait arriver\nTOPIC consoleIn/outbox, ROUTE … …\n\n\n\nLe passé composé est un bon indice pour les Events. Pour l’Intent, le test tient en deux questions : le message rapporte-t-il quelque chose qui est arrivé ? Non. Quelque chose d’actuellement vrai ? Non. Alors il demande un comportement.\nUn piège : publier un Intent est bien sûr quelque chose qui est arrivé. Il faut classer d’après ce que dit le message, non d’après son existence — sinon tout devient Event et le vocabulaire ne sert plus à rien.\nLe Status mérite une note, car l’instinct est de le demander : « quels sont tes abonnements ? » Mais demander, c’est appeler, et un appel exige que le demandeur connaisse le composant, le sache en vie, et attende. Le Status se publie : ROT13 publie ROT13/S/subscriptions dès que son câblage change, et quiconque s’y intéresse le lit. Le lecteur a alors besoin d’un sujet, pas d’un composant, et ROT13 n’apprend jamais qui l’audite. Chaque sorte répond à une question différente :\n\nun Event n’est utile que si l’on écoutait — nos messages bloqués, trois fois de suite ;\nun Status est ce dont un nouveau venu a besoin : la valeur actuelle, sans rejouer l’histoire ;\nun Intent demande un changement.\n\nEt les commandes ne sont pas interdites. Envoyer ROT13/I avec ACTION Hello ressemble à une commande, et le verdict du matériel est « Fine. » Le composant exerce sa capacité et publie ses Events et son Status. Le flux retenu est Intent → composant → 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  Partie VI — Rejouer sur Syncthing, et nommer les messages",
"section": "7.4 La règle de l’écrivain unique",
"text": "7.4 La règle de l’écrivain unique\n\nToute ressource écrivable a exactement une autorité d’écriture.\n\nNe pas confondre avec l’UUID du nom de fichier. L’UUID empêche deux publications de choisir le même nom physique ; l’autorité d’écriture dit quel composant possède une ressource logique d’Event ou de Status. Deux écrivains n’entrent jamais en collision sur un nom de fichier, et c’est précisément pour cela que le problème passe inaperçu.\nCe que coûte un second écrivain : le nom de la boîte était le seul marqueur de provenance, donc rot13/outbox cesse de signifier « ROT13 a transformé ceci » et un abonné ne peut plus faire confiance au contrat sur lequel il s’appuie. Pour le Status c’est pire — deux composants prétendant chacun publier la valeur actuelle d’un même fait se contredisent, sans aucune garantie d’ordre entre machines pour trancher. Pour des Events en ajout seul, de nombreuses publications coexistent par construction ; la question est la propriété sémantique, pas la collision. Quand deux autorités apparaissent, demandez pourquoi il y en a deux plutôt que de sortir un verrou.",
"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  Partie VII — Fusionner les deux idées architecturales",
"section": "",
"text": "8.1 Un transformateur mérite d’exister\nDeux médiateurs ont été supprimés et le gain mesuré. Les étapes 48 à 52 répondent à la question suivante, évidente : la médiation est-elle pour autant mauvaise ? Non — et la distinction qui tranche est assez nette pour s’appliquer à une conception qu’on n’a jamais vue.\nCe qui a été supprimé, c’est un médiateur calculant A → A : une fonction identité coûteuse, dans la chaîne de disponibilité, copiant chaque message sans rien y ajouter.\nPrenons maintenant un producteur publiant {\"value\":\"Hello\"} et un consommateur attendant une structure d’affichage. Un TextToDisplayTransformer entre les deux apporte transformation de schéma, adaptation sémantique, éventuellement conversion d’unités, éventuellement agrégation. C’est un travail qu’aucun des deux ne devrait porter : ROT13 n’a pas à décider des couleurs du terminal, et la console n’a pas à comprendre la forme de la charge utile de ROT13.\nLa ligne se trace par la compatibilité des contrats, non par le fait d’ajouter quelque chose. Un médiateur convertissant des Celsius en Fahrenheit modifie au lieu d’ajouter et mérite sa place ; un médiateur ajoutant un horodatage à un message que le consommateur comprend déjà a ajouté quelque chose et reste suspect. La question est toujours : le consommateur pourrait-il lire le message du producteur tel quel ?",
"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  Partie VII — Fusionner les deux idées architecturales",
"section": "",
"text": "Si un consommateur comprend sémantiquement la publication d’un producteur, l’abonnement direct suffit souvent. Si les contrats sont incompatibles, introduire un transformateur qui effectue une adaptation réelle.\nUn médiateur qui ne fait que transmettre des données compatibles est suspect. Un médiateur qui ajoute la sémantique nécessaire mérite d’exister.",
"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  Partie VII — Fusionner les deux idées architecturales",
"section": "8.2 Le transformateur est égoïste aussi",
"text": "8.2 Le transformateur est égoïste aussi\nInséré dans la chaîne, le transformateur s’abonne à rot13/outbox et publie dans sa propre boîte de sortie ; ConsoleOut s’abonne alors à celle du transformateur plutôt qu’à celle de ROT13. Notez ce que cela coûte en code : rien. ConsoleOut reçoit un autre Intent — TOPIC display/outbox au lieu de TOPIC rot13/outbox — et la chaîne est recâblée. ROT13 n’apprend jamais que le transformateur existe ; le transformateur n’apprend jamais que ConsoleOut existe.\nPourquoi ne pas publier directement dans consoleOut/inbox, en économisant une boîte ? Quatre raisons :\n\nconnaissance — il contiendrait le nom de ConsoleOut, c’est-à-dire de la topologie dans un service, la rechute de l’étape 28 ;\npropriété — cette boîte est le canal de contrôle de ConsoleOut, écrit par le configurateur ; une charge utile venue du transformateur lui donnerait deux autorités ;\nportée — sa propre boîte peut être lue par un journal, une vue web ou un second affichage sans frais, alors qu’une boîte d’entrée ne sert qu’un consommateur ;\nmutabilité — un agrégateur peut être inséré ensuite en envoyant un autre Intent, sans modifier aucun composant.",
"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  Partie VII — Fusionner les deux idées architecturales",
"section": "8.3 L’architecture complète sur système de fichiers",
"text": "8.3 L’architecture complète sur système de fichiers\nChaque boîte avec exactement un écrivain :\n\n\n\n\n\n\n\nboîte\nécrivain unique\n\n\n\n\nconsoleIn/outbox\nSensorService\n\n\nrot13/outbox\nProcessorService\n\n\ndisplay/outbox\nle transformateur\n\n\nchaque boîte de contrôle\nle configurateur — l’unique autorité d’Intent désignée\n\n\nle terminal\nActuatorService, qui n’écrit aucune boîte\n\n\n\nDes capacités égoïstes, l’Intent venant d’une seule autorité, un transformateur seulement là où les contrats diffèrent, un écrivain par ressource, et la topologie nulle part dans les capacités. C’est la conception que le système de fichiers a suffi à enseigner — et la partie suivante demande à quoi le système de fichiers, lui, ne suffit plus.",
"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  Partie IX — MQTT",
"section": "",
"text": "9.1 Ce que le système de fichiers a enseigné, et ce pour quoi il n’est pas fait\nLe système de fichiers a enseigné les frontières de publication, les répertoires comme adresses, l’observation, des processus indépendants, des langages indépendants, la latence de synchronisation, le câblage à l’exécution, le State, l’Intent, les Events, le coût des médiateurs, la propriété des services et les services transformateurs. Ce fut un bon professeur, et ce n’est pas un courtier de messages élégant : à la fin, l’architecture était propre et le transport était un amas de fichiers .tmp, de déplacements atomiques, de rescans, de chemins partagés et de délais de réplication.\nLa conclusion n’est pas « fichiers mauvais, MQTT bon ». Le système de fichiers a un avantage que MQTT ne peut égaler — il stocke couramment des gigaoctets ou des téraoctets, alors que courtiers et clients sont conçus pour de petits messages, et découper une charge énorme sur MQTT revient à inventer un protocole de transfert de fichiers dans un protocole de messages. Donc :\nUn système de fichiers répliqué donne aussi à chaque machine une copie locale, ce qui est une vraie force — mais la réplication n’est pas une sauvegarde : suppressions et corruptions se répliquent aussi, à moins qu’un versionnement conserve les copies antérieures.",
"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  Partie IX — MQTT",
"section": "",
"text": "Utilisez les messages pour la coordination et les événements. Utilisez un stockage de fichiers ou d’objets adapté pour les grandes données. Un message peut porter l’emplacement, l’identité et les métadonnées de ces données au lieu des téraoctets eux-mêmes.",
"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  Partie IX — MQTT",
"section": "9.2 MQTT devrait sembler familier",
"text": "9.2 MQTT devrait sembler familier\n\n\n\n\n\n\n\nsystème de fichiers / Syncthing\nMQTT\n\n\n\n\nracine du tableau de messages synchronisé\ncourtier / espace de noms\n\n\nchemin de répertoire\nsujet (topic)\n\n\nfichier .msg\npublication\n\n\ncontenu du fichier\ncharge utile\n\n\nWatchService\nabonnement\n\n\nrépertoire dynamique\nsujet / filtre\n\n\nrépertoire de contrôle\nI\n\n\nrépertoire d’état\nS/…\n\n\nrépertoire d’événements\nE/…\n\n\n\nLa réaction visée par le matériel : « Ah. Nous connaissons déjà cette architecture. » MQTT est un changement de transport, pas une affirmation architecturale.\nDeux choses qu’un répertoire ne pouvait pas faire, visibles en une minute en ligne de commande. Une publication faite avant l’existence d’un abonné ne lui parvient jamais — le constat des messages bloqués, pour la troisième fois, mais avec une réponse que le système de fichiers n’avait pas. Et un filtre comme test/# correspond à test/a et test/a/b/c mais pas à testing/x, car # travaille par niveaux et non par préfixes de chaîne ; test/+ ne correspondrait qu’à un seul niveau.\nLa correction plus profonde : un sujet n’est pas un conteneur. Il n’existe aucun objet nommé test/a sur le courtier. Un sujet est une clé de routage portée par chaque publication et confrontée aux filtres de qui est abonné à cet instant. Les répertoires contiennent les messages ; les sujets les filtrent. Un seul abonnement couvre donc des sujets qui n’existent pas encore — là où un tableau de messages exigeait un nouveau répertoire et un nouvel enregistrement.",
"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  Partie IX — MQTT",
"section": "9.3 La bibliothèque, l’identifiant client et l’adresse du courtier",
"text": "9.3 La bibliothèque, l’identifiant client et l’adresse du courtier\nJava n’a pas de client MQTT dans sa bibliothèque standard ; Paho arrive donc maintenant — après le besoin, comme le médiateur à l’étape 7 et Jackson à l’étape 64. Quatre choses suffisent : se connecter, publier, s’abonner, rappeler. La connexion est volontairement anticlimatique : « Rien d’architectural ne s’est produit ici. Nous avons simplement attaché notre processus au transport. »\nDeux détails de la connexion comptent :\n\nl’identifiant client n’est pas qu’un jeton d’unicité. Le courtier reconnaît par lui un client qui revient et conserve son état de session : abonnements, messages en file en QoS &gt; 0, et l’association à sa dernière volonté. Un répertoire ne savait jamais qui l’observait, et c’est précisément pour cela qu’un observateur redémarré ne rejouait rien.\nl’adresse du courtier est de la configuration de déploiement : chaque programme lit System.getProperty(\"mqtt.broker\", \"tcp://localhost:1883\"). C’est aussi la seule configuration qui ne peut pas arriver par Intent, puisque l’Intent passe par le courtier. La topologie se publie ; l’adresse de ce qui la publie, non.\n\nS’abonner coûte un paquet, et le courtier détient la liste des abonnements. Il n’existe aucun moyen standard de lui demander à quoi un autre client s’est abonné — d’où S/subscriptions : la déclaration par un composant de son propre câblage, publiée pour que l’architecture sache ce que le transport garde privé. Seul son propriétaire peut la publier, par la règle de l’écrivain unique, car seul lui sait ce qu’il a accepté.",
"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  Partie IX — MQTT",
"section": "9.4 Intent structuré, et deux mappeurs",
"text": "9.4 Intent structuré, et deux mappeurs\nTOPIC some/path a un champ et un sens. Il ne peut pas dire de quel type d’Intent il s’agit, porter un second paramètre, s’imbriquer ou s’étendre ; et un récepteur n’a rien contre quoi valider. Un Intent plus riche demande une structure :\nsubscribe:\n topic: Demo/ConsoleIn/U/alice/E/text\nC’est seulement là qu’une bibliothèque de sérialisation a une tâche claire. JsonTools garde deux mappeurs, et l’asymétrie est voulue :\n\nen entrée, une fabrique YAML avec FAIL_ON_UNKNOWN_PROPERTIES désactivé — JSON étant un sous-ensemble de YAML, un Intent tapé à la main est accepté, et un configurateur plus récent peut envoyer des champs qu’un service plus ancien ignore ;\nl’écriture utilise du JSON strict avec INDENT_OUTPUT activé, donc les charges publiées sont strictes et lisibles.\n\nTolérant en entrée, strict en sortie. Un mappeur unique devrait renoncer à l’un des deux.",
"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  Partie IX — MQTT",
"section": "9.5 DUISE, et recâbler un système en marche",
"text": "9.5 DUISE, et recâbler un système en marche\nLe schéma de nommage reçoit enfin son nom : Description (quels contrats ce service comprend et publie), Unit (quelle instance), Intent (comportement demandé), Status (ce qui est vrai maintenant), Event (ce qui est arrivé).\nDemo/ROT13/U/alice/{I, S/online, S/subscriptions/text, E/crypted}\nU/&lt;unit&gt; est ce dont le système de fichiers n’avait pas besoin : chaque machine avait sa réplique du même chemin relatif, l’identité d’instance était implicite. MQTT a un espace de noms partagé : un sujet doit donc dire quelle copie. Coder en dur U/alice dans une capacité est donc pire que de coder en dur consoleIn.outbox : cela lie la compilation à un déploiement. Configuré par Intent, une seule compilation sert tout le monde — d’où les trois noms d’unité en arguments de MqttConfigure. Les noms d’unité sont la topologie.\nRecâblage observé sur un système en marche : publiez un nouvel Intent nommant une autre source, et le service se désabonne de l’ancienne, s’abonne à la nouvelle et republie S/subscriptions en conséquence. Sans redémarrage, sans édition. Envoyez au contraire un filtre invalide — Demo/#/E/text, où # n’est pas le dernier niveau — et MqttTools.isValidFilter le rejette ; l’ancien abonnement demeure et le Status continue de dire vrai.\nCe rejet révèle une vraie lacune, à nommer plutôt qu’à cacher : il n’est journalisé que localement. Le configurateur ne peut savoir si son Intent a été appliqué ou refusé, et un moniteur ne peut distinguer « refusé » de « pas encore traité ». Dans cette conception, l’émetteur apprend le résultat en lisant le Status et en le comparant à sa demande. Publier les refus comme Event, ou un Status de dernière erreur, combleraient la lacune ; ni l’un ni l’autre n’est dans le matériel : c’est une décision de conception à justifier.",
"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  Partie IX — MQTT",
"section": "9.6 Ce qu’un nouvel abonné apprend, et ce qu’un mort avoue",
"text": "9.6 Ce qu’un nouvel abonné apprend, et ce qu’un mort avoue\nS’abonner à Demo/# pendant trois secondes, sans que rien ne soit publié, renvoie ceci :\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\"\nUn arrivant tardif apprend instantanément tout le câblage actuel du système, sans rien demander et sans qu’aucun composant sache qu’un moniteur existe. C’est le Status retenu. Aucun Event n’arrive, car les Events sont publiés non retenus — « State retenu, Events non retenus ». C’est aussi la bonne réponse à l’instinct de demander à un service ce qu’il fait : personne ne demande ; le service le déclare, une fois, et le courtier le garde pour quiconque se présente.\nLe Status retenu seul mentirait pourtant. Tuez un service par Ctrl+C et son S/online = true reste sur le courtier à jamais. D’où la dernière volonté, enregistrée au moment de la connexion :\nvar will = new MqttMessage(\"{\\\"value\\\":false}\".getBytes(UTF_8), 1, true, new MqttProperties());\noptions.setWill(lastWillTopic, will);\nElle est retenue : quand le courtier la publie au nom du client, elle remplace le true périmé. Le composant qui échoue n’est pas celui qui signale l’échec — seul arrangement qui puisse fonctionner. Une réserve : une déconnexion propre ne déclenche pas la dernière volonté ; un service bien élevé publie donc online=false lui-même en partant, la volonté couvrant les morts brutales.",
"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  Partie IX — MQTT",
"section": "9.7 Ce qui a survécu au transport, et le couplage restant",
"text": "9.7 Ce qui a survécu au transport, et le couplage restant\nLa moitié inférieure du tableau système de fichiers→MQTT est l’essentiel : I, S, E, les services égoïstes, la topologie à l’exécution et « transformateur si nécessaire » sont inchangés. L’architecture a survécu au remplacement du transport, et c’est la meilleure preuve disponible qu’elle n’a jamais dépendu du transport.\nUn couplage faible ne signifie pas que rien ne sait rien. Ce qui reste, nécessairement, est l’accord sur : la syntaxe des messages, leur sémantique, les contrats de sujets, l’Intent, la propriété, le sens du State et celui des Events. Le but n’est pas d’éliminer le couplage mais d’éliminer la connaissance inutile. Concrètement, chaque service ici doit comprendre exactement un contrat d’Event étranger — ROT13 comprend E/text de ConsoleIn, ConsoleOut comprend E/crypted de ROT13 — plus le schéma d’Intent qu’il accepte sur son propre I. Cette liste est le minimum irréductible.\nPar ailleurs, le courtier est une dépendance d’infrastructure partagée : tout le monde a besoin de son adresse et rien ne marche sans lui. Réel, mais d’une autre nature que la connaissance d’un composant par un autre.\nLa liste de l’étape 78 est l’outil à garder. Douze questions, dont ces six portent l’argument de ce système :\n\n\n\n\n\n\n\nquestion\nréponse ici\n\n\n\n\nune capacité contient-elle l’identité d’un producteur en dur ?\nnon — elle arrive par Intent\n\n\nquels contrats étrangers doit-elle comprendre ?\nun contrat d’Event chacun, plus son propre schéma d’Intent\n\n\noù la topologie est-elle définie ?\ndans le configurateur, hors du chemin des données\n\n\nla topologie peut-elle changer sans recompiler ?\noui — démontré sur un système en marche\n\n\nle transport pourrait-il être remplacé ?\noui — démontré : système de fichiers puis MQTT\n\n\nchaque médiateur fait-il quelque chose qui exige une médiation ?\noui, trivialement : TEXT → TEXT n’en exige aucune, et il n’y en a aucun\n\n\n\nLa prudence du matériel s’applique : les réponses n’ont pas à être toutes « non ». Elles doivent être intentionnelles.",
"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  Partie IX — MQTT",
"section": "9.8 Le parcours complet",
"text": "9.8 Le parcours complet\nLe programme n’a jamais changé : une ligne entre, la même ressort décalée de 13 lettres. Ce qui a changé, onze fois, c’est la manière dont les parties sont reliées et qui détient la connaissance de ce câblage.\n\n\n\n\n\n\n\n\n\nétape\ncomment les parties sont reliées\noù vit la topologie\ndans le chemin des données, outre les capacités\n\n\n\n\n1 procédural\nappels directs\ndans le code de la capacité\n—\n\n\n2 services égoïstes\npas reliées du tout\nnulle part — c’est le problème\n—\n\n\n3 médiation statique, une JVM\nboîtes, copiées par des médiateurs\nles médiateurs, démarrés dans main()\ndeux médiateurs\n\n\n4 médiation statique, système de fichiers\nrépertoires, copiés par des processus médiateurs\nles lignes de commande de l’opérateur\ndeux processus médiateurs\n\n\n5 médiation statique, Syncthing\nrépertoires répliqués\nles lignes de commande de l’opérateur\ndeux processus médiateurs, plus le délai de réplication\n\n\n6 médiateurs nommés et configurables\nIntent ROUTE d’un orchestrateur\nl’orchestrateur, hors du chemin\nles médiateurs, encore\n\n\n7 dynamique, une JVM\nles services écoutent, guidés par un Intent TOPIC\nle configurateur\nrien\n\n\n8 dynamique, système de fichiers\nidem, sur des répertoires\nle configurateur\nrien\n\n\n9 dynamique, Syncthing\nidem, sur des répertoires répliqués\nle configurateur\nrien — seulement des sauts de transport\n\n\n10 contrats\ncompatibles : direct ; incompatibles : un transformateur\nle configurateur\nun transformateur, seulement là où les contrats diffèrent\n\n\n11 MQTT\ndes sujets sur un courtier\nle configurateur\nrien — le courtier est du transport\n\n\n\nLisez la troisième colonne de haut en bas : la topologie s’éloigne, une étape après l’autre, jusqu’à ce qu’aucune capacité n’en détienne plus rien. Lisez la dernière : le prix de ce déplacement tombe à zéro à l’étape 7 et y reste pendant que le transport change trois fois en dessous. Même architecture, meilleur 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  Partie IX — MQTT",
"section": "9.9 Les phrases à retenir",
"text": "9.9 Les phrases à retenir\n\n« Event-driven » décrit comment circulent l’information et le contrôle.\nLe couplage faible décrit ce que les participants doivent savoir les uns des autres.\nPubliez ce qui est arrivé.\nDéclarez ce que vous voulez.\nPubliez votre propre état.\nGardez les capacités égoïstes.\nGardez la topologie hors des capacités.\nNe payez pas un médiateur qui ne fait pas réellement de médiation.\n\nEt chaque fois qu’une architecture devient confuse, revenez à la première question de ce livre : qui connaît qui ?",
"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": "Glossaire",
"section": "",
"text": "Chaque terme ci-dessous est défini là où il sert pour la première fois, et lié depuis chaque mention ultérieure. La flèche d’une entrée ramène à cet endroit.",
"crumbs": [
"Annexes",
"[Glossary]{.en}[Glossaire]{.fr}[Glossar]{.de}"
]
}
]