Qu'est-ce qui change, qu'est-ce qui reste ?What changes, what stays?

La première question n'est pas « quelle structure ? ». C'est « qu'est-ce qui va changer ? ».The first question isn't "what structure?". It's "what is going to change?".

Devant une fonctionnalité, le réflexe du débutant est de choisir un pattern et de le plaquer. Celui de l'architecte est antérieur : repérer, dans le code, ce qui va bouger — et ce qui va rester. Prends un simple calcul de prix. Trois lignes côte à côte, qui semblent du même bloc. Elles changent en réalité à trois vitesses radicalement différentes.Faced with a feature, the beginner's reflex is to pick a pattern and slap it on. The architect's reflex comes first: spot, in the code, what will move — and what will stay. Take a simple price calculation. Three lines side by side, seemingly one block. They actually change at three radically different speeds.

Le piège n'est pas d'oublier d'abstraire. C'est d'abstraire au mauvais endroit.The trap isn't forgetting to abstract. It's abstracting in the wrong place.

On met une couture là où le code paraît compliqué, pas là où il va changer. Et les deux coïncident rarement. Le développeur consciencieux voit l'arithmétique du sous-total, la trouve « centrale », et l'isole derrière une belle abstraction. Il est fier : c'est extensible, testable, propre. Sauf que le sous-total ne change jamais.We place a seam where the code looks complex, not where it will change. And the two rarely coincide. The conscientious developer sees the sub-total arithmetic, deems it 'central', and isolates it behind a clean abstraction. Proud: it's extensible, testable, tidy. Except the sub-total never changes.

interface StratégieDeCalcul:
    calculer(lignes) -> Montant          # ← belle abstraction…

class CalculStandard implements StratégieDeCalcul:
    def calculer(lignes):
        return somme(l.prix * l.quantité)  # …sur ce qui ne bouge JAMAIS

# pendant ce temps, les vrais axes volatils restent codés en dur :
def total(lignes, stratégie):
    st = stratégie.calculer(lignes)
    tva = st * 0.20                       # ✗ figé au milieu de la fonction
    remise = st * 0.10 si st > 100        # ✗ figé, change chaque sprint

def test_tva_alimentaire():
    # impossible à écrire proprement :
    # le taux est noyé dans total(),
    # aucune couture où injecter
    # une autre règle de TVA.

Place la couture sur l'axe qui bouge. Puis regarde ce que chaque changement rouvre.Put the seam on the axis that moves. Then watch what each change reopens.

La méthode tient en trois temps, et aucun ne nomme un pattern : énumère les responsabilités, demande pour chacune « qu'est-ce qui la ferait changer, et à quelle fréquence ? », puis place la couture entre deux axes qui bougent à des vitesses différentes. Le sous-total reste du code nu ; la TVA et la remise deviennent des fonctions injectées. L'animation fait défiler les changements réels et montre, à chaque fois, le rayon d'explosion.The method is three steps, none naming a pattern: list the responsibilities, ask of each 'what would make it change, and how often?', then place the seam between two axes that move at different speeds. The sub-total stays bare code; tax and discount become injected functions. The animation rolls real changes through and shows, each time, the blast radius.

def test_remise_campagne():
    remise = lambda st, _: st*0.10 if st>100 else 0
    assert total(panier, tva_std, remise) == 119.7
    # on teste la règle volatile seule, sans rien d'autre

Le piège de jugement : confondre « compliqué » et « volatil ».The judgment trap: mistaking "complex" for "volatile".

On isole ce qui est difficile à comprendre, en croyant isoler ce qui va changer. Ce sont deux propriétés indépendantes. La complexité d'un bout de code ne justifie jamais à elle seule une couture — seule sa probabilité × fréquence de changement la justifie. Bascule le toggle : les deux versions ont une couture, mais une seule est posée sur le bon axe.We isolate what's hard to understand, believing we isolate what will change. These are independent properties. A snippet's complexity alone never justifies a seam — only its probability × frequency of change does. Flip the toggle: both versions have a seam, but only one is placed on the right axis.

# le cœur stable reste nu — pas de cérémonie
def sous_total(lignes):
    return sum(l.prix * l.quantité for l in lignes)

# l'axe VOLATIL devient un paramètre (la couture est ici)
def total(lignes, règle_tva, règle_remise):
    st = sous_total(lignes)
    return st + règle_tva(st, lignes) - règle_remise(st, lignes)