Observer, ou l'émetteur qui ignore son publicObserver, or the emitter that ignores its audience

Un émetteur qui appelle ses réactions une par une. Qui devrait varier ?An emitter that calls its reactions one by one. What should vary?

Une commande est passée : il faut notifier le client, tracer l'analytics, réserver le stock. La version qu'on écrit tous enchaîne les appels dans place(). Ça marche — et ça soude le fait métier (« une commande a été passée ») à la liste de ceux qui y réagissent. Ce qui varie ici, ce n'est pas le fait : c'est son public. Le réflexe : l'émetteur ne devrait pas connaître ses auditeurs.An order is placed: notify the customer, track analytics, reserve stock. The version we all write chains the calls inside place(). It works — and it welds the business fact ('an order was placed') to the list of those who react to it. What varies here isn't the fact: it's its audience. The reflex: the emitter shouldn't know its listeners.

class OrderService:
    def place(order):
        save(order)
        EmailService().send(order.customer, "Confirmée")   # réaction 1
        Analytics().track("order_placed", order)            # réaction 2
        Warehouse().reserve(order.items)                    # réaction 3
        # … et demain : programme de fidélité, anti-fraude, webhook

L'émetteur devient un carrefour — et une réaction lente bloque le fait.The emitter becomes a crossroads — and one slow reaction blocks the fact.

Énumérer les réactions dans place() a deux coûts qui empirent ensemble. Le premier est structurel : l'émetteur dépend de tout ce dont chaque réaction a besoin, et il faut le rouvrir à chaque ajout. Le second est temporel : comme il les appelle en file, l'analytics lente ralentit la commande, et une réaction qui lève une exception fait échouer le fait lui-même — alors que réserver le stock n'aurait jamais dû dépendre de l'envoi d'un mail.Listing the reactions inside place() has two costs that worsen together. The first is structural: the emitter depends on everything each reaction needs, and must be reopened on every addition. The second is temporal: since it calls them in sequence, slow analytics slows the order, and a reaction that throws makes the fact itself fail — when reserving stock should never have depended on sending an email.

def place(order):
    save(order)
    Analytics().track("order_placed", order)   # ✗ lève → tout s'arrête ici
    EmailService().send(...)                    # jamais atteint
    Warehouse().reserve(...)                    # jamais atteint

On inverse l'abonnement : l'émetteur cesse de connaître ses récepteurs.Invert the subscription: the emitter stops knowing its receivers.

Observer renverse le sens du savoir. Au lieu que l'émetteur énumère ses réactions, ce sont les réactions qui s'inscrivent auprès de lui. L'émetteur ne garde qu'une liste d'abonnés abstraits et leur publie un fait, sans savoir qui ils sont. L'animation inverse les flèches de dépendance — comme au Vol 1, mais pour le public d'un événement — puis pousse le fil rouge : l'observateur à une méthode n'était qu'une fonction.Observer reverses the direction of knowledge. Instead of the emitter listing its reactions, the reactions register with it. The emitter keeps only a list of abstract subscribers and publishes a fact to them, without knowing who they are. The animation flips the dependency arrows — as in Vol 1, but for an event's audience — then pushes the red thread: the one-method observer was just a function.

# Objet (Observer classique)
interface Observer: on_order_placed(order)
class OrderService:▸ à toiyour turn — le sujet cesse de nommer ses récepteurs — que garde-t-il à la place ?the subject stops naming its receivers — what does it keep instead? · cliquer pour révélerclick to reveal    def place(order):
        save(order)▸ à toiyour turn — publier le fait sans savoir qui écoute — la boucle aveuglepublish the fact without knowing who listens — the blind loop · cliquer pour révélerclick to reveal
# Fonctionnel — l'observateur à une méthode EST une fonction▸ à toiyour turn — l'observateur à une méthode EST une fonction — s'abonner sans classethe one-method observer IS a function — subscribing without a class · cliquer pour révélerclick to revealorders.subscribe(lambda order: analytics.track("order_placed", order))

Rendre l'émetteur aveugle ne suffit pas. L'Observer qui retombe en chaîne synchrone.Making the emitter blind isn't enough. The Observer that falls back into a synchronous chain.

Le piège n'est pas d'oublier la liste d'abonnés — c'est de croire qu'avoir une liste a tout réglé. Observer ne découple que le savoir : qui réagit. Il ne dit rien du temps : quand, et si la réaction réussit. Si le sujet itère ses abonnés en série, sans filet, une exception ou une lenteur d'un seul abonné remonte au fait lui-même. On a inversé la dépendance, pas isolé les réactions. Bascule le toggle : cherche le for sans try.The trap isn't forgetting the subscriber list — it's believing the list fixed everything. Observer only decouples knowledge: who reacts. It says nothing about time: when, and whether the reaction succeeds. If the subject iterates its subscribers in series, without a net, a single subscriber's exception or slowness propagates back to the fact itself. You inverted the dependency, you didn't isolate the reactions. Flip the toggle: hunt the for without a try.

# le sujet ignore qui écoute ET protège le fait de leurs défaillances
class OrderService:
    subscribers: list[Observer] = []
    def place(order):
        save(order)                       # le fait, scellé d'abord
        for o in self.subscribers:        # liste abstraite
            try: o.on_order_placed(order)
            except Exception: log(...)     # un raté n'en bloque pas un autre
# ajouter une réaction : s'abonner, ZÉRO ligne touchée dans place()

Le public nommé dans la fonction, ou le fait publié à des abonnés.The audience named inside the function, or the fact published to subscribers.

Quand ne pas introduire un ObserverWhen not to introduce an Observer

Observer a un loyer : un flux de contrôle qu'on ne lit plus en ligne droite, et un abonnement à gérer. On garde l'appel direct — et c'est correct — quand :Observer has rent: a control flow you can no longer read in a straight line, and a subscription to manage. Keep the direct call — and that's fine — when:

• le récepteur est unique et fixe : un seul destinataire qui ne variera pas ne mérite pas une liste d'abonnés. Un appel nommé se lit mieux qu'une indirection — inverser ici, c'est de la cérémonie (YAGNI, Vol 0 #3).the receiver is single and fixed: one recipient that won't vary doesn't deserve a subscriber list. A named call reads better than an indirection — inverting here is ceremony (YAGNI, Vol 0 #3).
• tu as besoin du résultat ou de l'ordre : Observer suppose que l'émetteur se moque de ce que font ses abonnés. Si la suite dépend de leur retour, ou exige un ordre garanti, c'est une orchestration — appelle-les explicitement, ne publie pas.you need the result or the ordering: Observer assumes the emitter doesn't care what its subscribers do. If what follows depends on their return, or requires a guaranteed order, that's orchestration — call them explicitly, don't publish.
• le flux doit rester traçable de bout en bout : trop d'observateurs anonymes rendent le « qui a réagi à quoi » illisible. Quand comprendre une panne exige de reconstituer une chaîne invisible d'abonnés, le découplage est devenu un coût, pas un bénéfice.the flow must stay traceable end to end: too many anonymous observers make 'who reacted to what' unreadable. When understanding a failure means reconstructing an invisible chain of subscribers, the decoupling has become a cost, not a benefit.

Le réflexe n'est donc pas « émets un événement dès qu'il se passe quelque chose ». C'est : « cette liste de réactions va-t-elle changer, et le fait peut-il les ignorer — leur identité comme leur succès ? Si oui, publie un fait à des abonnés ; sinon, appelle, et garde le flux lisible. »So the reflex isn't 'emit an event whenever something happens'. It's: 'will this list of reactions change, and can the fact ignore them — their identity and their success? If yes, publish a fact to subscribers; if not, call, and keep the flow readable.'

Mot de l'éditeurFrom the editor

Observer prolonge le fil rouge du volume : l'interface à une méthode est un type de fonction déguisé. En Java de 2002, écouter un événement exigeait une interface, une classe anonyme, une méthode ; aujourd'hui on passe une lambda à subscribe(). Mais Observer porte une leçon que Strategy n'avait pas : un pattern peut découpler une dimension (qui réagit) et en laisser une autre soudée (quand, et si ça réussit). L'architecte ne s'arrête pas à « j'ai inversé la dépendance » ; il demande quelle dépendance reste.Observer extends the volume's red thread: the one-method interface is a disguised function type. In 2002 Java, listening to an event required an interface, an anonymous class, a method; today you pass a lambda to subscribe(). But Observer carries a lesson Strategy didn't: a pattern can decouple one dimension (who reacts) and leave another welded (when, and whether it succeeds). The architect doesn't stop at 'I inverted the dependency'; they ask which dependency remains.

C'est aussi le plus petit pas vers l'événementiel : émettre un fait sans savoir qui l'écoute. Poussée hors du processus, la même intention devient Pub/Sub, puis file de messages (Vol 4) — et c'est là que le découplage temporel, ici facultatif, devient la raison d'être. On installe le réflexe en mémoire ; on le décline plus tard dans le temps et sur le réseau.It's also the smallest step toward event-driven: emit a fact without knowing who listens. Pushed beyond the process, the same intent becomes Pub/Sub, then a message queue (Vol 4) — and there the temporal decoupling, optional here, becomes the whole point. We install the reflex in memory; we extend it across time and network later.

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

• Pub/Sub — le même Observer, mais l'émetteur et les abonnés ne se connaissent plus du tout : un courtier (broker) s'intercale. Au-delà du processus, c'est la file de messages du Vol 4. Observer en mémoire, Pub/Sub sur le réseau.the same Observer, but emitter and subscribers no longer know each other at all: a broker sits between them. Beyond the process, it's Vol 4's message queue. Observer in memory, Pub/Sub on the network.
• Mediator — quand les relations deviennent n-à-n, un point central orchestre les notifications au lieu que chaque sujet tienne sa propre liste. Observer relie un fait à son public ; Mediator relie plusieurs collègues entre eux.when relations become n-to-n, a central point orchestrates the notifications instead of each subject keeping its own list. Observer links a fact to its audience; Mediator links several colleagues to each other.
• Signaux réactifsReactive signals — la version où la valeur elle-même notifie ses dépendants : changer une donnée propage la réaction automatiquement. C'est Observer rendu implicite par le langage ou le framework — le pattern disparaît dans la déclaration.the version where the value itself notifies its dependents: changing a datum propagates the reaction automatically. It's Observer made implicit by the language or framework — the pattern vanishes into the declaration.

Le kata — écris-le, ne le relis pasThe kata — write it, don't reread it

# test_order_events.py — la spec EST le harnais : fais-le passer au vert.
# le sujet publie un fait à des abonnés abstraits, sans les nommer et sans
# dépendre de leur succès. un appelable = un abonné. sans lib, sans framework.

def test_l_abonne_recoit_le_fait():
    orders = OrderService()
    recu = []
    orders.subscribe(lambda o: recu.append(o.id))
    orders.place(order(id=1))
    assert recu == [1]                        # le fait a bien été publié

def test_tous_les_abonnes_dans_l_ordre():
    orders = OrderService()
    vus = []
    orders.subscribe(lambda o: vus.append("email"))
    orders.subscribe(lambda o: vus.append("analytics"))
    orders.place(order(id=1))
    assert vus == ["email", "analytics"]      # chacun, dans l'ordre d'inscription

def test_ajouter_une_reaction_ne_touche_pas_place():
    orders = OrderService()
    orders.subscribe(lambda o: None)          # on s'abonne DE L'EXTÉRIEUR, après coup…
    orders.place(order(id=1))                 # …et place() n'a pas changé d'une ligne

def test_le_desabonnement_arrete_les_notifs():
    orders = OrderService()
    vus = []
    stop = orders.subscribe(lambda o: vus.append(o.id))
    stop()                                    # subscribe rend de quoi se désabonner
    orders.place(order(id=1))
    assert vus == []                          # l'abonné parti ne reçoit plus rien

def test_un_abonne_qui_leve_n_emporte_pas_les_autres():
    # LE test du pattern : la réaction du milieu explose. Les deux autres doivent
    # quand même être notifiées, et place() ne doit PAS propager l'exception.
    orders = OrderService()
    vus = []
    orders.subscribe(lambda o: vus.append("email"))
    orders.subscribe(boom)                    # lève une exception
    orders.subscribe(lambda o: vus.append("stock"))
    orders.place(order(id=1))
    assert vus == ["email", "stock"]          # le raté est isolé, pas contagieux