Choreography vs Orchestration, ou le fil que personne ne tientChoreography vs Orchestration, or the thread no one holds

Quatre étapes qui s'enchaînent par événements. Qui tient le fil ?Four steps chained by events. Who holds the thread?

Au #2, la file a découplé l'émetteur de ses consommateurs. Mais une commande n'est pas une réaction isolée : c'est une transaction métier en plusieurs étapes — payer, réserver, expédier, notifier — avec un ordre et des règles d'échec. En chorégraphie, chaque service réagit à l'événement du précédent et émet le sien. Ça marche, et ça pose une question dérangeante : la séquence existe dans la tête du métier, mais dans le code, elle n'est écrite nulle part. Le réflexe : demande-toi si l'ordre des étapes et leur rattrapage sont eux-mêmes de la logique métier — et donc s'ils doivent appartenir à un endroit nommé.In #2, the queue decoupled the emitter from its consumers. But an order isn't an isolated reaction: it's a multi-step business transaction — pay, reserve, ship, notify — with an order and failure rules. In choreography, each service reacts to the previous one's event and emits its own. It works, and it raises an unsettling question: the sequence exists in the business's head, but in the code it's written nowhere. The reflex: ask whether the order of steps and their recovery are themselves business logic — and so whether they should belong to a named place.

# Chorégraphie : chaque service réagit à l'événement du précédent
@subscribe("OrderPaid")        # Paiement a publié ceci
def on_paid(evt): warehouse.reserve(evt); publish("StockReserved", evt)

@subscribe("StockReserved")    # … Logistique réagit
def on_reserved(evt): shipping.dispatch(evt); publish("Shipped", evt)

@subscribe("Shipped")          # … Notif réagit
def on_shipped(evt): email.send_tracking(evt)
# la séquence payer → réserver → expédier → notifier existe… nulle part.

La séquence n'est écrite nulle part — donc impossible à suivre, et à défaire.The sequence is written nowhere — so impossible to follow, or to undo.

La chorégraphie pure séduit : aucun point central, un découplage maximal. Mais quand les étapes forment une vraie transaction, son absence de propriétaire se paie cher. Le processus métier devient émergent — il n'existe que dans la somme des abonnements, dispersée sur N services. Trois douleurs en découlent : on ne peut pas voir où en est une commande, on ne peut pas changer la séquence sans toucher partout, et quand une étape échoue au milieu, personne ne sait défaire les précédentes.Pure choreography seduces: no central point, maximal decoupling. But when the steps form a real transaction, the absence of an owner costs dearly. The business process becomes emergent — it exists only in the sum of subscriptions, scattered across N services. Three pains follow: you can't see where an order stands, you can't change the sequence without touching everywhere, and when a step fails midway, no one knows how to undo the prior ones.

@subscribe("OrderPaid")
def on_paid(evt):
    warehouse.reserve(evt)       # 💥 rupture de stock → lève
    # le paiement a réussi, la réservation non. Aucun code ne rembourse :
    # personne ici ne sait qu'un paiement a précédé, ni comment l'annuler.

On donne un propriétaire au fil — qui connaît la séquence, et sait la défaire.Give the thread an owner — one that knows the sequence, and how to undo it.

Orchestrer, ce n'est pas recoupler : c'est rendre visible et possédable un processus qui, en chorégraphie, n'existait que dispersé. L'animation suit le fil de la transaction : émergent et sans propriétaire, puis perdu quand une étape échoue, puis tenu par un orchestrateur qui garde l'état — et enfin déroulé à l'envers, par compensations, quand il faut défaire. C'est la Saga, en germe.Orchestrating isn't recoupling: it's making visible and ownable a process that, in choreography, existed only scattered. The animation follows the transaction's thread: emergent and ownerless, then lost when a step fails, then held by an orchestrator that keeps the state — and finally run backwards, by compensations, when it must be undone. That's the Saga, in seed.

# Chorégraphie — la séquence est éparpillée en abonnements▸ à toiyour turn — chorégraphie : réagir au fait précédent, puis publier le suivantchoreography: react to the previous fact, then publish the next · cliquer pour révélerclick to reveal@subscribe("StockReserved") def _(e): dispatch(e); publish("Shipped", e)

# Orchestration — la séquence ET son rattrapage vivent en un seul endroit
def fulfill(order):▸ à toiyour turn — orchestration, 1re étape : garder de quoi compenser plus tardorchestration, 1st step: keep what you'll need to compensate later · cliquer pour révélerclick to reveal    stock = None
    try:▸ à toiyour turn — les étapes suivantes, dans l'ordre, au même endroitthe next steps, in order, in the same place · cliquer pour révélerclick to reveal    except StepFailed:▸ à toiyour turn — à l'échec : défaire à l'envers — les compensationson failure: undo in reverse — the compensations · cliquer pour révélerclick to reveal

Découpler n'est pas gratuit. La chorégraphie qui cache une transaction.Decoupling isn't free. The choreography that hides a transaction.

Le piège n'est pas de choisir la chorégraphie — c'est de la choisir pour un processus qui est en réalité une transaction. On prend la chorégraphie « parce que c'est découplé », mais si les étapes ont un ordre imposé et doivent se défaire à l'échec, on vient de disperser une transaction sans propriétaire : invisible, non réversible, impossible à faire évoluer. Le découplage qu'on croyait gagner se paie en cohérence perdue. Bascule le toggle : cherche la séquence qui a besoin d'un rattrapage.The trap isn't choosing choreography — it's choosing it for a process that's actually a transaction. You pick choreography 'because it's decoupled', but if the steps have a required order and must undo on failure, you've just scattered an ownerless transaction: invisible, irreversible, impossible to evolve. The decoupling you thought you gained is paid in lost consistency. Flip the toggle: hunt the sequence that needs recovery.

# le processus métier — séquence ET rattrapage — vit en UN endroit nommé
class FulfillOrder:               # l'orchestrateur possède le fil
    def run(order):
        pay = payment.charge(order)
        stock = None
        try:
            stock = warehouse.reserve(order)
            shipping.dispatch(order)
            notify.send_tracking(order)
        except StepFailed:
            if stock: warehouse.release(stock)   # compensations explicites, à l'envers :
            payment.refund(pay)                  # libérer d'abord, rembourser ensuite
# « où en est #4217 ? » → on lit l'état ici. Changer l'ordre → un seul fichier.

Le fil qui émerge de la chaîne, ou le fil tenu par un propriétaire.The thread that emerges from the chain, or the thread held by an owner.

Quand ne pas orchestrerWhen not to orchestrate

L'orchestration a un loyer : un coordinateur qui connaît la séquence, donc un point de couplage et une chose de plus à garder en vie. On reste en chorégraphie — et c'est correct — quand :Orchestration has rent: a coordinator that knows the sequence, hence a coupling point and one more thing to keep alive. Stay in choreography — and that's fine — when:

• les étapes sont vraiment indépendantes : envoyer un mail, tracer l'analytics, mettre à jour un cache après « commande payée » n'ont ni ordre imposé ni besoin de se défaire mutuellement. Les orchestrer, c'est inventer un fil qui n'existe pas — de la cérémonie (YAGNI, Vol 0 #3).the steps are truly independent: sending an email, tracking analytics, updating a cache after 'order paid' have neither required order nor need to undo one another. Orchestrating them invents a thread that doesn't exist — ceremony (YAGNI, Vol 0 #3).
• aucune étape n'a besoin d'être compensée : si l'échec d'une réaction n'oblige pas à annuler les autres, il n'y a pas de transaction à protéger — juste des abonnés, et la chorégraphie est exactement Observer à l'échelle du réseau (Vol 4 #2).no step needs compensating: if one reaction's failure doesn't require undoing the others, there's no transaction to protect — just subscribers, and choreography is exactly Observer at network scale (Vol 4 #2).
• tu veux ajouter des réacteurs sans toucher au cœur : la force de la chorégraphie est l'extension libre. Tant que personne n'a besoin de posséder la séquence, garde ce découplage — ne le sacrifie pas à un orchestrateur dont tu n'as pas l'usage.you want to add reactors without touching the core: choreography's strength is free extension. As long as no one needs to own the sequence, keep that decoupling — don't sacrifice it to an orchestrator you have no use for.

Le réflexe n'est donc pas « orchestre, c'est plus propre » ni « chorégraphie, c'est plus découplé ». C'est : « cette séquence a-t-elle un ordre imposé et un besoin de se défaire ? Si oui, c'est une transaction : donne-lui un propriétaire. Sinon, ce sont des réactions indépendantes : laisse-les libres. »So the reflex isn't 'orchestrate, it's cleaner' nor 'choreograph, it's more decoupled'. It's: 'does this sequence have a required order and a need to undo? If yes, it's a transaction: give it an owner. If not, they're independent reactions: leave them free.'

Mot de l'éditeurFrom the editor

Ce numéro referme le volume de la communication, et il le fait en désamorçant un faux débat. « Chorégraphie vs orchestration » n'est pas un choix de style entre découplé et centralisé : c'est une question sur la nature de ce qu'on coordonne. Des réactions indépendantes ? La chorégraphie est juste. Une transaction — un ordre, un état, un défaire ? Alors le fil est de la logique métier, et toute logique métier mérite un endroit où on peut la lire, la changer et la tester. Orchestrer n'est pas revenir au monolithe ; c'est refuser qu'un processus important n'existe nulle part.This issue closes the communication volume, and it does so by defusing a false debate. 'Choreography vs orchestration' isn't a style choice between decoupled and centralized: it's a question about the nature of what you're coordinating. Independent reactions? Choreography is right. A transaction — an order, a state, an undo? Then the thread is business logic, and all business logic deserves a place where you can read it, change it and test it. Orchestrating isn't returning to the monolith; it's refusing to let an important process exist nowhere.

Le volume entier tenait dans une seule question — « ai-je besoin d'une réponse maintenant, ou seulement que ce soit fait un jour ? ». Le #1 l'a posée à l'échelle d'un appel, le #2 à l'échelle d'un fan-out durable, le #3 à l'échelle d'une transaction qui traverse des services. À chaque fois, le couplage temporel s'est révélé un choix, jamais un défaut. La suite logique attend au Vol 7 : quand on défait par compensation et que les messages arrivent deux fois, comment reste-t-on cohérent ? La Saga, qu'on a vue en germe, y devient le sujet.The whole volume fit in one question — 'do I need an answer now, or only that it gets done someday?'. #1 asked it at the scale of a call, #2 at the scale of a durable fan-out, #3 at the scale of a transaction spanning services. Each time, temporal coupling proved a choice, never a defect. The logical sequel waits in Vol 7: when you undo by compensation and messages arrive twice, how do you stay consistent? The Saga, seen here in seed, becomes the subject there.

Les voisins que ce numéro débloqueThe neighbors this issue unlocks

• Saga — la transaction distribuée sans verrou global : une suite d'étapes locales, chacune avec son action compensatoire pour défaire à l'échec. C'est l'orchestration de ce numéro, poussée jusqu'à la résilience — le sujet central du Vol 7.the distributed transaction without a global lock: a series of local steps, each with its compensating action to undo on failure. It's this issue's orchestration pushed to resilience — Vol 7's central subject.
• Workflow engine — l'orchestrateur sorti du code : les étapes, l'état et les compensations décrits en données, persistés et rejouables. Utile quand le processus est long, doit survivre aux redémarrages, et mérite d'être observé et versionné comme un artefact métier.the orchestrator pulled out of code: steps, state and compensations described as data, persisted and replayable. Useful when the process is long, must survive restarts, and deserves to be observed and versioned like a business artifact.
• Monolithe distribuéDistributed monolith — l'anti-pattern qui guette des deux côtés : une chorégraphie si emmêlée qu'on ne peut plus rien déployer seul, ou un orchestrateur-dieu qui aspire la logique de tous. Le nommer, c'est se rappeler que le but n'est pas « découplé » ni « centralisé », mais « possédé par qui de droit ».the anti-pattern lurking on both sides: a choreography so tangled nothing deploys alone, or a god orchestrator that absorbs everyone's logic. Naming it is a reminder that the goal isn't 'decoupled' nor 'centralized', but 'owned by the right place'.

Le kata de décision — transaction ou réactions ?The decision kata — transaction or reactions?

Rien à implémenter ici : le geste qui ancre, c'est de trancher — et de savoir pourquoi. Trois flux. Pour chacun, parie avant de dérouler : chorégraphie ou orchestration ? Le critère n'est pas « découplé vs centralisé », c'est « suite de réactions indépendantes, ou transaction qui mérite un propriétaire ? ». La dernière question est la sournoise : elle distingue « il y a un ordre » de « il faut pouvoir défaire ».Nothing to implement here: the anchoring gesture is to decide — and to know why. Three flows. For each, bet before you scroll: choreography or orchestration? The criterion isn't 'decoupled vs centralized', it's 'a chain of independent reactions, or a transaction that deserves an owner?'. The last question is the sneaky one: it separates 'there's an order' from 'you must be able to undo'.

# Trois flux métier. Pour CHACUN, une seule question :
# chorégraphie (réactions libres) ou orchestration (un propriétaire tient
# l'ordre, l'état, le défaire) ? Attention : « ordonné » n'est pas « transaction ».

FLUX_A = "commande payée → envoyer le reçu · tracer l'analytics · réchauffer le cache"

FLUX_B = "réserver un voyage → bloquer le vol · bloquer l'hôtel · débiter la carte
          règle métier : si l'hôtel échoue, LIBÉRER le vol et NE PAS débiter"

FLUX_C = "inscription → créer le compte · envoyer l'e-mail de bienvenue · provisionner l'espace
          règle métier : l'e-mail ne part qu'APRÈS la création du compte"