Synchrone vs Asynchrone, ou la réponse dont je n'ai pas besoinSynchronous vs Asynchronous, or the answer I don't need

Quatre appels en file. De combien ai-je besoin de la réponse, maintenant ?Four calls in a row. How many of their answers do I need, now?

Au #2 du Vol 3, Observer a rendu l'émetteur aveugle à son public — mais ses réactions restaient dans le même fil. Voici la suite : checkout enchaîne quatre appels comme s'ils étaient de même nature. Ils ne le sont pas. Le paiement gate la réponse : sans lui, pas de commande. Le mail, le PDF, l'analytics doivent seulement être faits — un jour. Ce qui varie, ce n'est pas l'appel : c'est si j'ai besoin de sa réponse maintenant. Le réflexe : ne fais attendre l'utilisateur que pour ce qui décide de la suite.In Vol 3 #2, Observer made the emitter blind to its audience — but its reactions stayed in the same thread. Here's the sequel: checkout chains four calls as if they were the same kind. They aren't. The payment gates the response: without it, no order. The email, the PDF, analytics only need to happen — someday. What varies isn't the call: it's whether I need its answer now. The reflex: make the user wait only for what decides what comes next.

def checkout(order):
    pay = PaymentGateway().charge(order)   # ← j'ai BESOIN de la réponse : refusé ?
    if not pay.ok: return "paiement refusé"
    EmailService().send_receipt(order)      # … le client n'attend pas le mail
    InvoiceService().generate_pdf(order)    # … ni la génération du PDF
    Analytics().track("purchase", order)    # … ni l'analytics
    return "commande confirmée"             # le client attend TOUT ça pour ça

Les latences s'additionnent, les disponibilités se multiplient.Latencies add up, availabilities multiply.

Tout enchaîner en synchrone a un coût qui n'apparaît pas sur un poste de dev, où chaque service répond en 5 ms et personne n'est en panne. En production, deux lois s'installent. Les latences s'additionnent : le client attend la somme de tous les appels. Les disponibilités se multiplient : il suffit qu'un seul service périphérique soit lent ou tombé pour que le paiement réussi… échoue quand même à se conclure en commande.Chaining everything synchronously has a cost invisible on a dev machine, where each service answers in 5 ms and nothing is down. In production, two laws kick in. Latencies add up: the customer waits for the sum of every call. Availabilities multiply: a single peripheral service being slow or down is enough for a successful payment to… still fail to become an order.

pay = PaymentGateway().charge(order)   # ✓ carte débitée
EmailService().send_receipt(order)      # 💥 fournisseur d'e-mail HS → lève
# checkout échoue. Le client est débité, voit une erreur, et n'a pas de commande.

On coupe le fil après ce qui gate la réponse — le reste draine derrière.Cut the thread after what gates the response — the rest drains behind.

L'asynchrone n'est pas une vitesse, c'est une coupure. On garde synchrone le seul appel dont la réponse décide de la suite, et on rend la main tout de suite après ; tout ce qui doit seulement arriver part dans une file et s'exécute en arrière-plan. L'animation suit le fil d'exécution du client : d'abord bloqué sur les quatre appels, puis libéré au gate — puis montre que ce gain a un prix, et lequel.Async isn't a speed, it's a cut. Keep synchronous the only call whose answer decides what comes next, and return right after; everything that merely has to happen goes to a queue and runs in the background. The animation follows the client's thread of execution: first blocked across all four calls, then freed at the gate — then shows that this gain has a price, and which one.

# Synchrone — j'ai besoin de la réponse pour décider
pay = gateway.charge(order)          # bloque, retourne ok/refusé
if not pay.ok: return "refusé"

# Asynchrone — il suffit que ce soit fait ; je rends la main
queue.publish("OrderPaid", order.id)  # dépose, ne bloque pas
return "commande confirmée"            # le reste draine derrière
# un worker, plus tard : mail, PDF, analytics — chacun à son rythme

Rendre la main ne suffit pas. L'« async » qui a juste supprimé la garantie.Returning early isn't enough. The 'async' that merely deleted the guarantee.

Le piège n'est pas d'oublier de découpler — c'est de croire que ne plus attendre, c'est avoir découplé. Le synchrone offrait une garantie gratuite : quand l'appel revient, le travail est fait. L'asynchrone la perd par défaut. Si on se contente de lancer un thread et d'oublier, un redémarrage avale le travail en silence : pas de persistance, pas de retry, pas d'accusé. On n'a pas déplacé la garantie vers une file — on l'a supprimée. Bascule le toggle : cherche le « et si le process meurt maintenant ? ».The trap isn't forgetting to decouple — it's believing that not waiting means having decoupled. Synchronous gave a free guarantee: when the call returns, the work is done. Async loses it by default. If you just spawn a thread and forget, a restart swallows the work silently: no persistence, no retry, no acknowledgement. You didn't move the guarantee to a queue — you deleted it. Flip the toggle: hunt the 'what if the process dies now?'.

# async = on déplace la garantie vers une file DURABLE
def checkout(order):
    pay = gateway.charge(order)
    if not pay.ok: return "refusé"
    queue.publish("OrderPaid", {"order_id": order.id})  # persisté avant le retour
    return "commande confirmée"

# un worker, idempotent, retenté par la file si ça casse
def on_order_paid(msg):
    if already_done(msg.id): return        # rejouer ne fait pas de doublon
    EmailService().send_receipt(msg.order_id)
    mark_done(msg.id)                      # APRÈS l'effet : un crash entre les deux = un renvoi, pas une perte

Attendre la réponse, ou déposer le travail et rendre la main.Await the answer, or drop the work and return.

Quand ne pas passer en asynchroneWhen not to go asynchronous

L'asynchrone a un loyer : une file à exploiter, un travail à suivre sur deux temps, une garantie à reconstruire. On reste synchrone — et c'est correct — quand :Async has rent: a queue to operate, work to track across two timelines, a guarantee to rebuild. Stay synchronous — and that's fine — when:

• tu as besoin de la réponse pour décider de la suite : un paiement refusé annule la commande. Rendre ça asynchrone, c'est répondre avant de savoir — et parfois mentir à l'utilisateur.you need the answer to decide what comes next: a declined payment cancels the order. Making that async means answering before you know — and sometimes lying to the user.
• l'appel est instantané et la dépendance toujours disponible : une lecture en cache local, un calcul en mémoire. La file n'absorberait aucun pic et n'éviterait aucune panne ; elle n'ajouterait que du suivi — de la cérémonie (YAGNI, Vol 0 #3).the call is instant and the dependency always available: a local cache read, an in-memory computation. The queue would absorb no spike and avoid no outage; it would only add tracking — ceremony (YAGNI, Vol 0 #3).
• tu ne peux pas tolérer la cohérence à terme : quand le résultat doit être vrai au moment exact où tu le renvoies, le « ce sera fait un jour » de l'async est précisément la mauvaise sémantique.you can't tolerate eventual consistency: when the result must be true at the exact moment you return it, async's 'it'll be done someday' is precisely the wrong semantics.

Le réflexe n'est donc pas « passe tout en async, c'est plus scalable ». C'est, appel par appel : « ai-je besoin de cette réponse pour décider, ou seulement que ce soit fait un jour ? Si la réponse décide, garde-le synchrone ; si elle ne fait qu'accuser, coupe le fil — mais alors reconstruis la garantie, ne la supprime pas. »So the reflex isn't 'make everything async, it scales better'. It's, call by call: 'do I need this answer to decide, or only that it gets done someday? If the answer decides, keep it synchronous; if it merely acknowledges, cut the thread — but then rebuild the guarantee, don't delete it.'

Mot de l'éditeurFrom the editor

« Asynchrone » est devenu un mot de prestige, comme si attendre était une faute de goût. Mais le synchrone n'est pas lent : il est honnête. Quand l'appel revient, le travail est fait — et cette garantie est gratuite. L'asynchrone ne la rend pas obsolète, il l'échange : on gagne du découplage temporel et on rachète, à la main, ce qui était offert — la certitude que le travail finit par arriver. L'architecte ne demande pas « est-ce async ? » mais « qu'est-ce que j'ai accepté de ne plus savoir tout de suite, et l'ai-je reconstruit ? ».'Asynchronous' has become a prestige word, as if waiting were a lapse of taste. But synchronous isn't slow: it's honest. When the call returns, the work is done — and that guarantee is free. Async doesn't make it obsolete, it trades it: you gain temporal decoupling and buy back, by hand, what was given — the certainty that the work eventually happens. The architect doesn't ask 'is it async?' but 'what did I agree to stop knowing right away, and did I rebuild it?'.

Ce numéro ouvre le volume de la communication avec sa clé : le couplage temporel est un choix, pas un défaut. Observer (Vol 3) avait coupé le savoir ; ici on coupe le temps. Les deux prochains poussent l'idée : la file de messages (#2) fait de la garantie durable la vedette — persistance, pics, pannes ; chorégraphie vs orchestration (#3) demande qui tient le fil de la transaction quand plus personne n'attend en ligne droite.This issue opens the communication volume with its key: temporal coupling is a choice, not a defect. Observer (Vol 3) cut knowledge; here we cut time. The next two push the idea: the message queue (#2) makes the durable guarantee the star — persistence, spikes, outages; choreography vs orchestration (#3) asks who holds the thread of the transaction when no one waits in a straight line anymore.

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

• Request/Response — le synchrone nommé : j'envoie, je bloque, je reçois la réponse qui décide de la suite. Le régime par défaut, et le bon tant que la réponse gate une décision.synchronous, named: I send, I block, I receive the answer that decides what comes next. The default regime, and the right one as long as the answer gates a decision.
• Fire-and-forget — l'asynchrone dans sa forme la plus pure : j'émets, je ne lis jamais le résultat. Puissant pour ce qui doit seulement arriver — dangereux dès qu'on confond « je n'attends pas » avec « je ne garantis plus ».async in its purest form: I emit, I never read the result. Powerful for what merely has to happen — dangerous the moment you confuse 'I don't wait' with 'I no longer guarantee'.
• Outbox pattern — la réponse au piège de ce numéro : écrire le message dans la même transaction que la donnée métier, pour qu'il soit impossible de confirmer sans avoir enregistré le travail à faire. Le pont direct vers la file durable du #2.the answer to this issue's trap: write the message in the same transaction as the business data, so it's impossible to confirm without having recorded the work to do. The direct bridge to #2's durable queue.

Le kata de décision — trace le gateThe decision kata — trace the gate

Pas de machine à écrire ici : le geste qui ancre, c'est de trancher. Voici un checkout réel, six appels sur un seul fil. Pour chaque groupe, parie avant de dérouler — synchrone (la réponse gate une décision) ou asynchrone (ça doit seulement finir par arriver) ? La dernière question est la sournoise : elle sépare « gate la réponse au client » de « gate un fait que la réponse promet ».No machine to type here: the anchoring gesture is to decide. Here's a real checkout, six calls on one thread. For each group, bet before you scroll — synchronous (the answer gates a decision) or asynchronous (it must merely happen eventually)? The last question is the sneaky one: it separates 'gates the answer to the client' from 'gates a fact the answer promises'.

# handle_checkout(order) — six gestes, un seul fil synchrone aujourd'hui.
# Pour CHACUN, une seule question : sa réponse décide-t-elle de la suite,
# ou doit-il seulement finir par arriver ? C'est ça, tracer le gate.
charge_payment(order)            # 1. débite la carte
reserve_stock(order)             # 2. décrémente le stock disponible
send_confirmation_email(order)   # 3. accuse réception au client
generate_invoice_pdf(order)      # 4. produit la facture
push_analytics(order)            # 5. incrémente les compteurs produit
refresh_reco_model(order)        # 6. réentraîne les recommandations