2  Partie I — Commencer par ce que l’on connaît déjà

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.

2.1 Étape 1 — Au plus simple : appeler, point

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é.

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.

Figure 2.1: La version procédurale. Le câblage est écrit dans le code : main() nomme les trois parties et fixe leur ordre.

2.2 Étape 2 — Trois capacités égoïstes

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, 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.

2.3 Étape 3 — Donner une boîte aux lettres à chaque capacité

Le plus petit mécanisme pour les liaisons manquantes : un message et une file nommée.

record Message(String type, String value) {}

Map<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();

BlockingQueue<Message> mailbox(String name) {
    return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());
}

Ce 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.

2.4 Étapes 4–6 — Les trois capacités deviennent égoïstes

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, 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.

2.5 Étape 7 — Entre le médiateur

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.

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.

Figure 2.2: La version médiatisée dans une seule JVM. Dans la version web, Lancer fait parcourir à un message les huit sauts.

2.6 Étape 8 — Redemander : qui connaît qui ?

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 :

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é.

2.7 Étape 9 — Pourquoi des threads virtuels ?

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 de cette séparation : la même architecture tournera en processus séparés à l’étape 11, sans aucun thread partagé entre les parties.

2.8 Étape 10 — Garder les services égoïstes

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 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.

2.9 Ce que la partie I a déplacé

é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 tout ce qui suit continue de mettre à l’épreuve.