Event Sourcing, ou le grand livre qu'on ne peut plus fermerEvent Sourcing, or the ledger you can no longer close

On stocke l'état présent. Et si la vérité était la suite des faits ?We store present state. What if the truth were the sequence of facts?

On ferme le volume des données par son hypothèse la plus profonde, jamais questionnée jusqu'ici : on stocke l'état présent. status = 'shipped'. Chaque changement écrase le précédent — un UPDATE détruit ce qui était là. La colonne ne retient qu'une valeur : la dernière. Event Sourcing inverse l'ordre des choses : on ne stocke plus l'état, on stocke les faits qui l'ont produit — payée, expédiée, remboursée — en append seul, et l'état devient un calcul, le repli de cette suite. Ce qui varie : garde-t-on la photo, ou le film ? Mais — et ce numéro insiste — la réponse par défaut reste « la photo ». Le film coûte cher, pour toujours.We close the data volume with its deepest, until-now unquestioned assumption: we store present state. status = 'shipped'. Each change overwrites the last — an UPDATE destroys what was there. The column holds one value: the latest. Event Sourcing inverts the order of things: you no longer store the state, you store the facts that produced it — paid, shipped, refunded — append-only, and state becomes a computation, the fold of that sequence. What varies: do you keep the photo, or the film? But — and this issue insists — the default answer stays 'the photo'. The film is expensive, forever.

# on stocke l'ÉTAT présent — et on écrase le passé à chaque pas
class Order:
    def pay(self):    self.status = "paid"       # ← l'ancien statut disparaît
    def ship(self):   self.status = "shipped"    # ← écrasé encore
    def refund(self): self.status = "refunded"   # ← et encore

db.query("UPDATE orders SET status='shipped' WHERE id=%s", id)
# la colonne status ne garde qu'une valeur : la dernière.
# « pourquoi cette commande a-t-elle été remboursée, et quand ? » → l'UPDATE
# a effacé la preuve. On a gardé l'état, on a jeté l'histoire qui l'a produit.

L'UPDATE efface la preuve, et les questions du passé n'ont plus de réponse.The UPDATE erases the evidence, and the past's questions have no answer.

Ne stocker que l'état a trois coûts — réels, mais qui ne mordent que certains métiers. La preuve est détruite : un UPDATE écrase la valeur d'avant, et avec elle le « pourquoi » et le « quand ». Les bugs deviennent irreproductibles : la mutation a effacé le chemin qui y menait, impossible de rejouer. Et des questions métier deviennent insolubles : « combien de commandes remboursées après expédition le mois dernier ? » exige des données qu'on a jetées à chaque pas. Attention : ces coûts justifient Event Sourcing là où l'histoire est le produit — pas partout. Pour la plupart des CRUD, perdre le passé ne coûte rien.Storing only state has three costs — real, but biting only certain domains. The evidence is destroyed: an UPDATE overwrites the prior value, and with it the 'why' and the 'when'. Bugs become irreproducible: the mutation erased the path that led there, no replay possible. And business questions become unanswerable: 'how many orders refunded after shipping last month?' demands data discarded at every step. Caution: these costs justify Event Sourcing where history is the product — not everywhere. For most CRUD, losing the past costs nothing.

db.query("UPDATE orders SET status='cancelled' WHERE id=4217")   # 💥 passé écrasé

# trois semaines plus tard, ticket #882 :
#   « le client dit qu'il n'a jamais annulé. Que s'est-il passé ? »
SELECT status FROM orders WHERE id=4217;   →  'cancelled'
# … c'est tout ce que la base sait. Le qui, le quand, le pourquoi : effacés.

On n'écrase plus : on ajoute. Et l'état devient le repli des faits.We stop overwriting: we append. And state becomes the fold of facts.

Event Sourcing emprunte l'idée la plus vieille de la comptabilité : on n'efface jamais une ligne, on en ajoute une qui corrige. L'animation part de la case status qu'on écrase, la remplace par un journal en append seul, montre l'état présent se recalculer en repliant les faits, puis le même journal nourrir autant de projections qu'on veut — y compris une vue inventée après coup, reconstruite en rejouant tout. La dernière marche montre la superpuissance ; le chapitre suivant montrera ce qu'elle coûte.Event Sourcing borrows accounting's oldest idea: you never erase a line, you add one that corrects it. The animation starts from the status cell you overwrite, replaces it with an append-only log, shows present state recomputed by folding the facts, then the same log feeding as many projections as you want — including a view invented after the fact, rebuilt by replaying everything. The last step shows the superpower; the next chapter shows what it costs.

# on n'écrit que des faits, en append — jamais d'UPDATE, jamais de DELETE▸ à toiyour turn — on n'écrit pas l'état, on écrit un fait — quel geste, jamais d'UPDATE ?you don't write state, you write a fact — which gesture, never an UPDATE? · cliquer pour révélerclick to revealevents.append(OrderShipped(id, at="14:20"))▸ à toiyour turn — le remboursement ne remplace pas l'expédition : il s'ajoute au journal, comme un fait de plusthe refund doesn't replace the shipping: it's appended to the log, as one more fact · cliquer pour révélerclick to reveal
# l'état présent est un REPLI des faits — pas une donnée stockée
def current_state(events):▸ à toiyour turn — l'état = repli des faits — quelle opération rejoue tout le journal ?state = fold of the facts — which operation replays the whole log? · cliquer pour révélerclick to reveal# « refunded » n'est pas écrit nulle part : c'est ce que donne le fold.

Le pattern le plus séduisant de la série, et le plus regretté.The series' most seductive pattern, and the most regretted.

Voici le numéro où le panneau danger est plus grand que le réflexe. Event Sourcing est élégant — on ne perd rien, l'audit est gratuit, on rejoue l'histoire à volonté — et c'est exactement ce qui le rend dangereux : on l'adopte partout, par défaut, pour la beauté de l'idée, sans le besoin qui la justifie. Le prix n'est pas un coût ponctuel, c'est une taxe permanente : versionner des événements pour toujours, ne plus jamais pouvoir effacer ni réécrire, recalculer l'état par du code, gérer snapshots et migrations. Sur l'agrégat où l'histoire est le métier, ce prix s'achète. Partout ailleurs, c'est une dette qu'on ne peut plus rembourser. Bascule le toggle : compte les versions d'événements.This is the issue where the danger sign is bigger than the reflex. Event Sourcing is elegant — you lose nothing, audit is free, you replay history at will — and that's exactly what makes it dangerous: you adopt it everywhere, by default, for the beauty of the idea, without the need that justifies it. The price isn't a one-off cost, it's a permanent tax: versioning events forever, never again being able to erase or rewrite, recomputing state through code, managing snapshots and migrations. On the aggregate where history is the domain, that price buys something. Everywhere else, it's a debt you can no longer repay. Flip the toggle: count the event versions.

# Event Sourcing sur le SEUL agrégat où l'histoire EST le métier : le grand livre
class Ledger:                       # un compte : la loi exige l'historique complet
    def post(self, entry): self.events.append(entry)   # append seul, jamais d'UPDATE
    def balance(self): return sum(e.amount for e in self.events)   # solde = fold

# … et tout le reste du système reste en état mutable, simple et cohérent :
class Order:
    def ship(self): db.update(id, status="shipped")   # un CRUD honnête, pas d'ES
# l'histoire est due là où elle est due — et nulle part ailleurs.

Garder l'état, ou garder les faits qui l'ont produit.Keep the state, or keep the facts that produced it.

Quand ne pas faire d'Event SourcingWhen not to do Event Sourcing

Ici la liste compte plus que partout ailleurs, parce que le défaut sain est de ne PAS faire d'Event Sourcing. On reste en état mutable — et c'est presque toujours le bon choix — quand :Here the list matters more than anywhere else, because the sane default is NOT to do Event Sourcing. Stay with mutable state — and it's almost always the right choice — when:

• l'histoire est un confort, pas une exigence : si perdre le passé ne viole aucune règle métier ni légale, tu n'as pas besoin d'ES. Un simple journal d'audit à côté répond au « qui a fait quoi » sans transformer toute la persistance en grand livre. C'est YAGNI (Vol 0 #3) appliqué à la donnée.history is a comfort, not a requirement: if losing the past violates no business or legal rule, you don't need ES. A plain audit log on the side answers 'who did what' without turning all persistence into a ledger. It's YAGNI (Vol 0 #3) applied to data.
• l'équipe ne connaît pas le pattern : ES demande de penser en faits, en projections, en rejeu, en versions d'événements. Adopté sans cette culture, il produit un système que personne ne sait déboguer — où « quel est l'état ? » devient une énigme. Le coût d'apprentissage est réel et permanent.the team doesn't know the pattern: ES demands thinking in facts, projections, replay, event versions. Adopted without that culture, it yields a system no one can debug — where 'what's the state?' becomes a riddle. The learning cost is real and permanent.
• tu ne te poses pas de questions temporelles : pas d'audit, pas de « pourquoi cet état », pas de reconstruction rétroactive de vues — alors l'append seul, le fold, les snapshots ne paient rien. Tu portes une taxe pour un bénéfice que tu n'encaisses jamais.you ask no temporal questions: no audit, no 'why this state', no retroactive view rebuilding — then append-only, fold, snapshots buy nothing. You carry a tax for a benefit you never collect.
• dans le doute : comme on ne peut presque jamais retirer ES, l'incertitude tranche en faveur de l'état mutable. On peut toujours sourcer un agrégat plus tard ; on ne peut quasiment jamais dé-sourcer. Le défaut, c'est la photo ; le film se mérite.in doubt: since you can almost never remove ES, uncertainty rules for mutable state. You can always source an aggregate later; you can hardly ever un-source one. The default is the photo; the film is earned.

Le réflexe n'est donc pas « source tes événements, tu ne perdras rien » : c'est « le journal des changements est-il une fonctionnalité que mon métier doit fournir ? Si oui, sur cet agrégat-là, source. Sinon — et c'est le cas par défaut — garde l'état, et un audit à côté si besoin. »So the reflex isn't 'source your events, you'll lose nothing': it's 'is the log of changes a feature my domain must provide? If yes, on that aggregate, source it. If not — and that's the default case — keep the state, with an audit log on the side if needed.'

Mot de l'éditeurFrom the editor

Ce numéro est volontairement le plus prudent de la série, parce qu'Event Sourcing est le pattern le plus sur-vendu par la hype. Son idée est magnifique — n'efface jamais, garde les faits, l'état n'est qu'un calcul — et c'est précisément cette beauté qui pousse à l'adopter sans le besoin. Retiens l'asymétrie : on ajoute le sourcing à un agrégat presque quand on veut, on ne le retire presque jamais. Le défaut sain n'est donc pas « garde tout par sécurité », c'est « garde l'état, et ne source que là où l'histoire est, littéralement, le produit ». La sophistication n'est pas une vertu ; la sobriété en est une.This issue is deliberately the series' most cautious, because Event Sourcing is the pattern most over-sold by hype. Its idea is beautiful — never erase, keep the facts, state is just a computation — and it's precisely that beauty that pushes adoption without the need. Remember the asymmetry: you add sourcing to an aggregate almost whenever you like, you almost never remove it. So the sane default isn't 'keep everything to be safe', it's 'keep the state, and source only where history is, literally, the product'. Sophistication isn't a virtue; sobriety is.

Ce numéro referme le volume « Données & état ». Son arc tenait dans une seule relation, prise sous trois angles : le #1 a demandé où vivent les données et a rendu le métier ignorant de sa base ; le #2 a demandé si lire et écrire sont le même métier et les a séparés ; le #3 a demandé si l'on garde l'état ou les faits, et a posé le panneau danger. Trois questions sur le lien entre un domaine et la donnée qui lui survit. La suite change d'échelle : jusqu'ici on rangeait l'intérieur d'un système. Le Vol 6 demande où le couper — « cette frontière suit-elle une vraie couture métier, ou juste un découpage technique ? » — et commence, à rebours de la mode, par le monolithe modulaire.This issue closes the 'Data & state' volume. Its arc held in a single relationship, taken from three angles: #1 asked where the data lives and made the domain ignorant of its database; #2 asked whether reading and writing are the same job and separated them; #3 asked whether you keep the state or the facts, and planted the danger sign. Three questions about the bond between a domain and the data that outlives it. What follows changes scale: until now we organized the inside of a system. Vol 6 asks where to cut it — 'does this boundary follow a real business seam, or just a technical split?' — and starts, against the fashion, with the modular monolith.

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

• Snapshots — le remède au rejeu qui s'allonge : on fige périodiquement l'état replié, pour ne rejouer que les événements depuis le dernier instantané. Indispensable dès que le journal grossit — mais un cache à invalider à chaque évolution du fold, donc une complexité de plus à tenir.the cure for ever-lengthening replay: you periodically freeze the folded state, to replay only the events since the last snapshot. Indispensable once the log grows — but a cache to invalidate on every change to the fold, hence one more complexity to maintain.
• CQRS + ES — le mariage naturel mais non obligatoire : le journal d'événements est le modèle d'écriture, les projections sont les modèles de lecture du #2. Puissant, et c'est là qu'on rejoint vraiment Event Sourcing — mais c'est cumuler deux factures, à ne faire que si les deux besoins existent pour de vrai.the natural but non-mandatory marriage: the event log is the write model, the projections are #2's read models. Powerful, and where Event Sourcing truly comes into its own — but it stacks two bills, to be done only if both needs genuinely exist.
• Tables temporellesTemporal tables — le compromis tiède : la base elle-même garde l'historique des versions de chaque ligne, sans repenser le modèle en faits. On gagne le « comment était-ce à telle date » sans la taxe complète d'ES — souvent la réponse suffisante quand on ne voulait que l'audit, pas le rejeu.the lukewarm compromise: the database itself keeps the version history of each row, without rethinking the model as facts. You gain 'how was it on this date' without ES's full tax — often the sufficient answer when all you wanted was audit, not replay.

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

# test_event_sourced_ledger.py — la spec EST le harnais : fais-le passer au vert.
# un grand livre en append seul ; l'état (le solde) est le REPLI des faits.
# jamais d'UPDATE, jamais de DELETE — on corrige en ajoutant.

def test_solde_est_le_fold_des_ecritures():
    acc = Account()
    acc.post(Deposited(100)); acc.post(Withdrawn(30))
    assert acc.balance() == 70                  # solde = fold(faits), écrit nulle part

def test_journal_est_append_seul():
    acc = Account()
    acc.post(Deposited(100)); assert len(acc.events) == 1
    acc.post(Withdrawn(30));  assert len(acc.events) == 2   # on empile, on n'écrase rien

def test_on_corrige_en_ajoutant_pas_en_effacant():
    acc = Account()
    acc.post(Deposited(100)); acc.post(Deposited(999))   # saisie fautive…
    acc.post(Corrected(-999))                   # …annulée par un fait compensatoire
    assert acc.balance() == 100
    assert len(acc.events) == 3                 # le faux dépôt reste VISIBLE dans l'histoire

def test_rejouer_donne_l_etat_a_une_date():
    acc = Account()
    acc.post(Deposited(100, at=1)); acc.post(Withdrawn(30, at=2))
    assert fold(acc.events, until=1) == 100     # rejoue jusqu'à t=1 : l'état d'alors
    assert fold(acc.events, until=2) == 70      # la question temporelle, gratuite

def test_snapshot_evite_de_tout_rejouer():
    acc = Account()
    for _ in range(1000): acc.post(Deposited(1))
    snap = acc.snapshot()                        # fige le solde replié à cet instant
    acc.post(Deposited(5))
    assert acc.balance_from(snap) == 1005        # ne rejoue QUE les faits après le snapshot

def test_l_ordre_des_faits_change_le_repli():
    acc = Account()
    acc.post(Withdrawn(50)); acc.post(Deposited(100))
    with raises(Overdrawn): fold_strict(acc.events)   # retirer AVANT de déposer = découvert
    # rejouer, ce n'est pas sommer : l'ordre porte le sens. le fold n'est pas commutatif.