Factory & Builder, ou l'objet reçu prêt à l'emploiFactory & Builder, or the object received ready to use

Un code qui fabrique ce qu'il veut seulement utiliser.Code that builds what it only wants to use.

ReportService veut une seule chose : rendre un rapport. Mais avant d'appeler render(), il doit choisir la bonne classe d'exporteur et l'assembler — marges, polices, en-tête, filigrane. Deux savoirs étrangers à sa mission se sont infiltrés : quel type concret instancier, et comment le monter pièce par pièce. Ce qui varie ici, ce n'est pas l'usage — c'est la création. Le réflexe : un code qui se sert d'un objet ne devrait ni connaître sa classe concrète, ni savoir l'assembler.ReportService wants one thing: render a report. But before calling render(), it must pick the right exporter class and assemble it — margins, fonts, header, watermark. Two concerns foreign to its mission have crept in: which concrete type to instantiate, and how to assemble it piece by piece. What varies here isn't the usage — it's the creation. The reflex: code that uses an object should know neither its concrete class nor how to assemble it.

class ReportService:
    def export(report, format):
        if format == "pdf":
            exp = PdfExporter(margins=20, font=load_font("Inter"),
                              header=True, watermark=company_logo())   # assemblage
        elif format == "csv":
            exp = CsvExporter(delimiter=";", encoding="utf-8")
        elif format == "html":
            exp = HtmlExporter(theme=load_theme("light"), inline_css=True)
        return exp.render(report)   # … le SEUL truc que ce code voulait faire

Le new se répand, et le constructeur télescope.The new spreads, and the constructor telescopes.

Fabriquer dans le code qui utilise a deux coûts, un par question. Côté Factory : chaque new lie l'appelant à une classe concrète, et le même switch de formats se duplique partout où l'on exporte. Côté Builder : un objet à dix réglages se monte par un constructeur à dix arguments — illisible, et qui laisse passer des objets à moitié construits. L'un couple au type, l'autre rend l'assemblage fragile.Building inside the code that uses has two costs, one per question. On the Factory side: every new ties the caller to a concrete class, and the same format switch duplicates everywhere you export. On the Builder side: a ten-setting object is assembled through a ten-argument constructor — unreadable, and it lets half-built objects through. One couples to the type, the other makes assembly fragile.

exp = PdfExporter(20, None, True, None, None, "A4")  # ✗ font oubliée
# … 200 lignes plus loin, dans un autre fichier :
exp.render(report)   # 💥 AttributeError: NoneType — trop tard pour savoir d'où

On sort la fabrication de l'usage : le choix, puis le montage.Pull construction out of usage: the choice, then the assembly.

Deux gestes en un. D'abord la Factory absorbe le « quel type » : le service reçoit une abstraction et cesse de connaître les classes concrètes. Ensuite le Builder absorbe le « comment » : l'objet se monte option par option et n'est livré que validé. L'animation déporte d'abord le choix, puis l'assemblage — puis pousse le fil rouge du volume : ces deux patterns ne sont qu'une fonction et des arguments nommés.Two moves in one. First the Factory absorbs the «which type»: the service receives an abstraction and stops knowing the concrete classes. Then the Builder absorbs the «how»: the object is assembled option by option and delivered only once validated. The animation relocates the choice first, then the assembly — then pushes the volume's red thread: these two patterns are just a function and named arguments.

# Objet — Factory + Builder explicites
class ExporterFactory:▸ à toiyour turn — le type de RETOUR d'une vraie Factory — l'abstraction, jamais le concretthe RETURN type of a real Factory — the abstraction, never the concrete · cliquer pour révélerclick to reveal        if format == "pdf":▸ à toiyour turn — monter option par option puis livrer un objet validé — la chaîne du Builderassemble option by option then deliver a validated object — the Builder chain · cliquer pour révélerclick to reveal        ...
exp = ExporterFactory.create("pdf")        # l'appelant ignore la classe

# Fonctionnel — la factory EST une fonction, le builder des args nommés▸ à toiyour turn — en fonctionnel : la factory est une fonction, le builder des arguments nommésin FP: the factory is a function, the builder named arguments · cliquer pour révélerclick to reveal

Cacher le new ne suffit pas. La Factory dont le concret fuit encore.Hiding the new isn't enough. The Factory whose concrete type still leaks.

Le piège n'est pas d'oublier la fonction de création — c'est de croire qu'emballer le new a découplé l'appelant. Si la factory retourne un type concret, ou si l'appelant doit l'inspecter (isinstance) pour atteindre une méthode spécifique, le couplage est intact : on a juste déménagé le switch, et souvent en double. Le new caché, mais la dépendance restée. Bascule le toggle : regarde le type de retour et l'isinstance.The trap isn't forgetting the creation function — it's believing that wrapping the new decoupled the caller. If the factory returns a concrete type, or if the caller must inspect it (isinstance) to reach a specific method, the coupling is intact: you just relocated the switch, often duplicating it. The new is hidden, the dependency remains. Flip the toggle: watch the return type and the isinstance.

# la factory retourne l'ABSTRACTION ; l'appelant n'en sait pas plus
class ExporterFactory:
    def create(format) -> Exporter:        # type de retour = l'interface
        return _REGISTRY[format]()         # une table, pas un switch qui pourrit
exp = ExporterFactory.create(fmt)
exp.render(report)                          # appelle l'interface, rien d'autre
# ajouter "xlsx" : on enregistre une classe. ZÉRO appelant touché.

Le new écrit dans l'usage, ou l'objet reçu prêt à l'emploi.The new written in the usage, or the object received ready to use.

Quand ne pas isoler la créationWhen not to isolate creation

Factory et Builder ont un loyer : une indirection de plus, un contrat à tenir, du câblage à la composition root. On garde le new direct — et c'est correct — quand :Factory and Builder have rent: one more indirection, a contract to maintain, wiring at the composition root. Keep the direct new — and that's fine — when:

• le type ne varie pas : un seul exporteur, qui ne deviendra pas trois, ne mérite pas une Factory. Cacher un new stable derrière une fonction, c'est de la cérémonie — YAGNI (Vol 0 #3).the type doesn't vary: a single exporter that won't become three doesn't deserve a Factory. Hiding a stable new behind a function is ceremony — YAGNI (Vol 0 #3).
• le constructeur est simple : deux ou trois champs, aucun invalide possible. Un Builder n'a de sens que si l'objet a assez d'options pour naître à moitié monté ; sinon le constructeur lisible suffit.the constructor is simple: two or three fields, no invalid state possible. A Builder only earns its place when the object has enough options to be born half-built; otherwise the readable constructor is enough.
• le langage offre déjà les arguments nommés et les valeurs par défaut : alors « Builder » n'est pas une classe à écrire mais une signature, et « Factory » une fonction qui retourne le produit. Ne construis la machinerie d'objets que si la création porte un vrai choix ou un vrai état.the language already offers named arguments and default values: then 'Builder' isn't a class to write but a signature, and 'Factory' a function returning the product. Build the object machinery only if creation carries a real choice or real state.

Le réflexe n'est donc pas « emballe tout new dans une Factory ». C'est : « le type que je crée va-t-il varier, ou l'objet peut-il naître invalide ? Si oui, sors la création de l'usage — une fonction si ça suffit, une classe si elle porte un choix ou un état ; sinon, écris le new et économise l'indirection. »So the reflex isn't 'wrap every new in a Factory'. It's: 'will the type I create vary, or can the object be born invalid? If yes, pull creation out of usage — a function if that suffices, a class if it carries a choice or state; if not, write the new and save the indirection.'

Mot de l'éditeurFrom the editor

Factory et Builder poussent le fil rouge du volume à sa démonstration la plus nette : ce sont des patterns que beaucoup de langages ont avalés. Le Builder de Joshua Bloch — sa réponse au constructeur télescopique de Java — n'est, en Python, Kotlin ou Swift, qu'une signature à arguments nommés avec des défauts. La Factory n'est qu'une fonction qui retourne une abstraction. Ce qui reste, ce n'est pas la classe : c'est l'opération — séparer qui crée de qui utilise — et le jugement de savoir quand elle vaut son loyer.Factory and Builder push the volume's red thread to its clearest demonstration: they're patterns many languages have swallowed. Joshua Bloch's Builder — his answer to Java's telescoping constructor — is, in Python, Kotlin or Swift, just a named-argument signature with defaults. The Factory is just a function returning an abstraction. What remains isn't the class: it's the operation — separate who creates from who uses — and the judgment of when it earns its rent.

Et c'est pourquoi le Singleton est l'écarté du volume : il déguise un état global et une instance imposée en « pattern de création », alors qu'il rend la dépendance invisible et le test difficile — l'inverse exact de ce que Factory cherche. Depuis le #1, une seule clé : ne demande pas « quel pattern du GoF appliquer ? » mais « quel détail je veux changer sans toucher au reste, et mon langage me le donne-t-il déjà ? ». Le #4 pose cette question à l'état plutôt qu'au comportement — et la retourne : quelles transitions veux-tu rendre littéralement impossibles ?And that's why the Singleton is the volume's outcast: it dresses up global state and a forced instance as a 'creational pattern', when it makes the dependency invisible and testing hard — the exact opposite of what Factory seeks. Since #1, one key: don't ask 'which GoF pattern to apply?' but 'which detail do I want to change without touching the rest, and does my language already give me that?'. #4 asks that question of state rather than behavior — and turns it around: which transitions do you want to make literally impossible?

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

• Abstract Factory — une Factory qui produit une famille d'objets cohérents entre eux (le thème sombre : son exporteur, ses polices, ses icônes) plutôt qu'un seul. Même geste, une dimension de plus : la cohérence du lot.a Factory that produces a family of mutually consistent objects (the dark theme: its exporter, its fonts, its icons) rather than one. Same move, one extra dimension: the batch's consistency.
• Prototype — créer en clonant un modèle déjà configuré plutôt qu'en rappelant un constructeur. Utile quand l'assemblage coûte cher ou quand l'objet de départ est lui-même la meilleure recette.creating by cloning an already-configured model instead of recalling a constructor. Useful when assembly is expensive or when the starting object is itself the best recipe.
• Conteneur d'injection (DI)DI container — la Factory portée à l'échelle de l'application : un registre unique qui sait construire et câbler tous les collaborateurs, à la composition root. C'est le pont direct vers l'inversion de dépendance du Vol 1.the Factory scaled to the whole application: a single registry that knows how to build and wire every collaborator, at the composition root. It's the direct bridge to Vol 1's dependency inversion.

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

# test_exporter_factory.py — la spec EST le harnais : fais-le passer au vert.
# la factory retourne l'ABSTRACTION Exporter ; le builder ne livre qu'un objet
# validé. ajouter un format = enregistrer une classe, zéro appelant touché.

def test_la_factory_retourne_l_abstraction():
    exp = ExporterFactory.create("csv")
    assert isinstance(exp, Exporter)          # le contrat, jamais le type concret

def test_un_format_inconnu_echoue_clairement():
    with raises(UnknownFormat):
        ExporterFactory.create("xml")         # pas de None silencieux qui casse plus loin

def test_le_builder_refuse_l_objet_incomplet():
    b = PdfBuilder().margins(20)              # on oublie la police, obligatoire
    with raises(Incomplete):
        b.build()                             # build() valide AVANT de livrer

def test_le_builder_livre_un_objet_valide():
    exp = PdfBuilder().margins(20).font("Inter").build()
    assert exp.margins == 20 and exp.font == "Inter"

def test_ajouter_un_format_ne_touche_aucun_appelant():
    # LE test du pattern : on enregistre un exporteur APRÈS coup, et create() le
    # sert sans qu'on rouvre la factory ni un seul appelant. c'est l'ouvert/fermé.
    class XlsxExporter(Exporter):
        def render(self, r): return b"xlsx-bytes"
    ExporterFactory.register("xlsx", XlsxExporter)
    assert isinstance(ExporterFactory.create("xlsx"), Exporter)