Strategy, ou le comportement qu'on injecteStrategy, or the behavior you inject

Un if/else qui grandit à chaque nouveau cas. Nomme ce qui varie.An if/else that grows with each new case. Name what varies.

Calculer un frais de port selon le transporteur. La version qu'on écrit tous : un if/elif qui s'allonge d'une branche à chaque transporteur ajouté. Ça marche — et ça transforme une fonction stable (« calculer un coût ») en une liste ouverte de cas qu'il faut rouvrir à l'infini. Ce qui varie ici, c'est l'algorithme de calcul. Le réflexe : isoler ce qui change du squelette qui reste.Computing shipping cost by carrier. The version we all write: an if/elif that grows a branch per added carrier. It works — and turns a stable function ('compute a cost') into an open list of cases you must reopen forever. What varies here is the calculation algorithm. The reflex: isolate what changes from the skeleton that stays.

def shipping_cost(order, carrier):
    if carrier == "ups":
        return 5 + 0.5 * order.weight
    elif carrier == "fedex":
        return 8 + 0.4 * order.weight
    elif carrier == "dhl":
        return 3 + 0.9 * order.weight
    # … et demain : "chronopost", "colissimo", "mondial_relay"

Chaque nouveau cas rouvre la même fonction — et la fait tout connaître.Each new case reopens the same function — and makes it know everything.

Le switch ne plante pas : il pourrit lentement. Chaque transporteur ajouté est une branche de plus dans une fonction qui devrait être close. Et comme elle les contient tous, elle finit par dépendre de tout ce dont chaque cas a besoin — un client API ici, une table de tarifs là. Le coût n'est pas la lisibilité d'aujourd'hui ; c'est qu'on doit modifier du code qui marche pour ajouter du code qui n'existait pas.The switch doesn't crash: it rots slowly. Each added carrier is one more branch in a function that ought to be closed. And since it holds them all, it ends up depending on everything each case needs — an API client here, a rate table there. The cost isn't today's readability; it's that you must modify working code to add code that didn't exist.

def shipping_cost(order, carrier):
    if carrier == "mondial_relay":
        pts = relay_api.nearest(order.address)   # ✗ réseau dans le calcul
        return 2 + 0.3 * order.weight + fee(pts)
    elif carrier == "ups": ...                    # et tout le reste reste soudé

On sort l'algorithme de la fonction, puis on le regarde devenir une fonction.Lift the algorithm out of the function, then watch it become a function.

Strategy nomme un comportement variable, l'extrait derrière un contrat commun, et le passe au code qui s'en sert. Le squelette cesse de connaître les cas : il appelle une abstraction. L'animation vide le switch, transforme chaque branche en stratégie injectable — puis pousse jusqu'au bout du fil rouge du volume : quand le contrat n'a qu'une méthode, l'objet n'était qu'une fonction déguisée.Strategy names a variable behavior, extracts it behind a common contract, and passes it to the code that uses it. The skeleton stops knowing the cases: it calls an abstraction. The animation empties the switch, turns each branch into an injectable strategy — then pushes the volume's red thread to its end: when the contract has a single method, the object was just a function in disguise.

# Objet (Strategy classique)
interface ShippingCost: cost(order) -> Money
class Ups implements ShippingCost: cost(o) = 5 + 0.5 * o.weight

class Checkout(rate: ShippingCost):
    self.rate.cost(order)             # le contexte appelle l'abstraction

# Fonctionnel — le contrat à une méthode EST le type
ups = lambda o: 5 + 0.5 * o.weight    # ShippingCost = (Order) -> Money
Checkout(rate = ups)                  # même injection, zéro classe

Extraire des classes ne suffit pas. La Strategy que le contexte espionne encore.Extracting classes isn't enough. The Strategy the context still spies on.

Le piège n'est pas d'oublier l'interface — c'est de croire que créer des classes Strategy a éliminé le switch. Si le contexte demande encore « quelle stratégie concrète tiens-je ? » pour un cas spécial, le if/else est revenu, juste déplacé. On a payé le prix de l'abstraction (une interface, des classes) sans en toucher le bénéfice. Bascule le toggle : cherche le isinstance.The trap isn't forgetting the interface — it's believing that creating Strategy classes eliminated the switch. If the context still asks 'which concrete strategy do I hold?' for a special case, the if/else is back, just moved. You paid the abstraction's price (an interface, classes) without reaping its benefit. Flip the toggle: hunt the isinstance.

# le contexte ne dépend QUE de l'abstraction
class Checkout(rate: ShippingCost):
    def total(order):
        return order.subtotal + self.rate.cost(order)   # appelle, ne teste rien

# ajouter Chronopost : une classe de plus, ZÉRO ligne touchée ici
class Chronopost implements ShippingCost:
    def cost(o): return 4 + 0.6 * o.weight

Le cas branché dans la fonction, ou le comportement passé en paramètre.The case branched inside the function, or the behavior passed as a parameter.

Quand ne pas extraire une StrategyWhen not to extract a Strategy

Strategy a un loyer : une indirection, un contrat à tenir, un câblage à la composition root. On le garde en if/else — et c'est correct — quand :Strategy has rent: an indirection, a contract to maintain, wiring at the composition root. Keep the if/else — and that's fine — when:

• le comportement ne varie pas, ou ne varie qu'à deux valeurs stables : un if honnête se lit mieux qu'une hiérarchie. Inverser ici, c'est de la cérémonie — YAGNI (Vol 0 #3).the behavior doesn't vary, or varies across only two stable values: an honest if reads better than a hierarchy. Inverting here is ceremony — YAGNI (Vol 0 #3).
• la variation est une donnée, pas un comportement : si la seule différence entre transporteurs est deux nombres, une table {base, parKilo} battra trois classes. On ne fait des objets que quand les variantes diffèrent par leur logique ou leurs dépendances.the variation is data, not behavior: if the only difference between carriers is two numbers, a {base, perKilo} table beats three classes. Make objects only when variants differ by logic or dependencies.
• le langage offre déjà les fonctions comme valeurs : alors « Strategy » n'est pas un pattern à instancier mais une fonction à passer. Ne construis la hiérarchie de classes que si une variante a un état ou des dépendances propres.the language already offers functions as values: then 'Strategy' isn't a pattern to instantiate but a function to pass. Build the class hierarchy only if a variant has its own state or dependencies.

Le réflexe n'est donc pas « extrais une Strategy dès qu'il y a un if ». C'est : « ce comportement va-t-il varier, et par sa logique plutôt que par ses données ? Si oui, fais-en un paramètre — fonction si une expression suffit, objet s'il porte un état ; sinon, garde le if et économise l'indirection. »So the reflex isn't 'extract a Strategy whenever there's an if'. It's: 'will this behavior vary, and by its logic rather than its data? If yes, make it a parameter — a function if an expression suffices, an object if it carries state; if not, keep the if and save the indirection.'

Mot de l'éditeurFrom the editor

Strategy est le pattern où l'on voit le plus nettement que le GoF n'est pas un catalogue de solutions mais un catalogue de manques du langage. En Java de 2002, injecter un comportement exigeait une interface et trois classes ; la même intention tient aujourd'hui en une lambda. Le débutant apprend « le pattern Strategy » ; l'architecte apprend l'opération — paramétrer ce qui varie — et reconnaît qu'elle a autant de costumes que de langages.Strategy is the pattern where you see most clearly that the GoF isn't a catalog of solutions but a catalog of language gaps. In 2002 Java, injecting a behavior required an interface and three classes; the same intent fits today in a lambda. The beginner learns 'the Strategy pattern'; the architect learns the operation — parameterize what varies — and recognizes it wears as many costumes as there are languages.

On ouvre ici le volume des patterns d'objets avec sa clé de lecture : ne demande pas « quel pattern appliquer ? » mais « quel détail je veux pouvoir changer sans toucher au reste, et mon langage me le donne-t-il déjà ? ». Les prochains numéros — Observer, Factory — répondent à la même question pour d'autres axes : le récepteur, la création.We open the object-patterns volume here with its reading key: don't ask 'which pattern to apply?' but 'which detail do I want to change without touching the rest, and does my language already give me that?'. The next issues — Observer, Factory — answer the same question for other axes: the receiver, the creation.

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

• State — une Strategy qui change d'elle-même dans le temps : l'objet remplace sa propre stratégie au gré des transitions (commande → payée → expédiée). Même injection, plus la transition.a Strategy that changes itself over time: the object swaps its own strategy across transitions (order → paid → shipped). Same injection, plus the transition.
• Template Method — la forme inverse : un squelette fixe avec des trous à remplir par sous-classe, au lieu d'un comportement entier injecté. Strategy compose, Template Method hérite.the inverted shape: a fixed skeleton with holes filled by subclass, instead of a whole behavior injected. Strategy composes, Template Method inherits.
• Higher-Order Function — la version fonctionnelle de tous les précédents : passer un comportement, c'est passer une fonction. Le « pattern » s'évapore quand le langage traite les fonctions comme des valeurs.the functional version of all the above: passing a behavior is passing a function. The 'pattern' evaporates when the language treats functions as values.

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

# test_shipping_strategy.py — la spec EST le harnais : fais-le passer au vert.
# Checkout ne connaît QUE le contrat « (Order) -> Money ». une variante de plus,
# c'est une valeur de plus — jamais un if dans Checkout. sans lib, sans framework.

def test_une_strategie_calcule_son_cout():
    assert Ups()(order(weight=10)) == 10             # 5 + 0.5*10, appelable directement

def test_le_contexte_delegue_a_la_strategie():
    co = Checkout(rate=FedEx())                       # 8 + 0.4*poids
    assert co.total(order(weight=10, subtotal=100)) == 112

def test_changer_de_strategie_change_le_total():
    o = order(weight=10, subtotal=100)
    assert Checkout(rate=Ups()).total(o) == 110       # 100 + 10
    assert Checkout(rate=Dhl()).total(o) != Checkout(rate=Ups()).total(o)

def test_une_fonction_vaut_une_strategie():
    flat = lambda o: 7                                # le contrat a UNE méthode : une lambda suffit
    assert Checkout(rate=flat).total(order(subtotal=100)) == 107

def test_le_contexte_n_inspecte_jamais_le_type():
    # LE test du pattern : une stratégie inédite, écrite APRÈS Checkout, passe par
    # le même contexte sans lui faire toucher une ligne. sinon le switch est revenu.
    def chronopost(o): return 4 + 0.6 * o.weight
    o = order(weight=10, subtotal=100)
    assert Checkout(rate=chronopost).total(o) == 110  # 100 + 4 + 6