La capture du defer What defer captures

Les arguments d'un defer sont évalués à l'instant du defer ; son corps, lui, s'exécute à la sortie. Toute la subtilité — et le bug de la variable de boucle, et le defer qui s'accumule dans une boucle — tient dans cet écart. A defer's arguments are evaluated at the moment of defer; its body runs at exit. All the subtlety — the loop-variable bug, the defer piling up inside a loop — lives in that gap.

Audience
Dev mordu par un defer qui capture la mauvaise valeur, ou qui accumule ses Close dans une boucle Dev bitten by a defer that captures the wrong value, or piles up its Closes in a loop
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●●○
Date
Jan 2028 Jan 2028

deferCapturePiège

SommaireContents ·
№ 01CadrageFraming3 min

Un defer vit en deux temps : ses arguments sont évalués maintenant, son appel s'exécute à la sortie.A defer lives in two times: its arguments are evaluated now, its call runs at exit.

Le numéro précédent a posé le quand de defer : à la sortie de la fonction, quel que soit le chemin. Ce numéro précise le quoi — qu'est-ce, exactement, qui est mis de côté ? Et la réponse est plus subtile qu'il n'y paraît, parce que defer fonctionne en deux temps distincts. Quand l'exécution rencontre la ligne defer, deux choses se produisent à des instants différents. Premièrement, sur-le-champ, Go évalue les arguments de l'appel différé. Si tu écris defer log(x), la valeur de x est lue et figée à cet instant précis, même si l'appel à log n'aura lieu que bien plus tard. Deuxièmement, à la sortie de la fonction, Go exécute enfin l'appel, avec les arguments qu'il avait gelés. Cet écart — arguments évalués tôt, appel exécuté tard — est invisible tant que les variables concernées ne changent pas entre les deux moments. Mais dès qu'elles changent, le comportement surprend : le defer utilise la photographie prise à l'instant du defer, pas l'état final. C'est une décision de conception délibérée, et plutôt sensée : elle capture l'intention du moment où tu écris le defer. Mais elle a une exception majeure, qui est la source de presque tous les pièges du numéro : si l'appel différé est une fermeture sans arguments, alors il n'y a rien à évaluer tôt, et le corps de la fermeture lira les variables à la sortie, dans leur état final. Appel direct avec arguments, ou fermeture : ces deux formes capturent à deux moments opposés. Tout le numéro vit dans cet écart.The previous issue laid down defer's when: at the function's exit, whatever the path. This issue clarifies the what — what, exactly, is set aside? And the answer is subtler than it seems, because defer works in two distinct times. When execution meets the defer line, two things happen at different instants. First, on the spot, Go evaluates the deferred call's arguments. If you write defer log(x), the value of x is read and frozen at that precise instant, even though the call to log will only happen much later. Second, at the function's exit, Go finally runs the call, with the arguments it had frozen. This gap — arguments evaluated early, call run late — is invisible as long as the variables involved don't change between the two moments. But the moment they change, the behavior surprises: the defer uses the photograph taken at the instant of defer, not the final state. It's a deliberate design decision, and a rather sensible one: it captures the intent of the moment you write the defer. But it has a major exception, the source of nearly all the issue's traps: if the deferred call is a closure with no arguments, then there's nothing to evaluate early, and the closure's body will read the variables at exit, in their final state. Direct call with arguments, or closure: these two forms capture at two opposite moments. The whole issue lives in that gap.

L'argument est gelé à l'instant du defer, pas à la sortieThe argument is frozen at the instant of defer, not at exit
func demo() {
    x := 1
    defer fmt.Println("différé :", x)   // x est ÉVALUÉ ICI → fige la valeur 1
    x = 2
    fmt.Println("immédiat :", x)        // 2
}
// sortie :
//   immédiat : 2
//   différé : 1     ← l'argument a été figé au moment du defer, pas à la sortie
Deux instants, un seul deferTwo instants, one defer
à l'instant du defer
les arguments sont évalués et figés
· · · · · ·
à la sortie de la fonction
l'appel différé s'exécute, avec ces arguments gelés

Entre les deux instants, la fonction continue et les variables changent. Un appel différé defer f(x) a déjà figé x ; une fermeture différée, elle, lira x à la sortie. Savoir laquelle tu écris, c'est savoir ce que tu vas obtenir.Between the two instants, the function continues and variables change. A deferred call defer f(x) has already frozen x; a deferred closure will read x at exit. Knowing which you write is knowing what you'll get.

Le réflexe du numéroThe issue's reflex

« Mon defer a-t-il des arguments, ou est-ce une fermeture ? Le premier fige maintenant, la seconde lit à la sortie. » Cette seule question dissipe la quasi-totalité des surprises. Tu choisis le moment de capture en choisissant la forme : passe une valeur en argument pour la figer tout de suite, mets-la dans le corps d'une fermeture pour la lire à la fin. Les deux sont utiles — encore faut-il savoir laquelle on a sous les doigts."Does my defer have arguments, or is it a closure? The first freezes now, the second reads at exit." This single question dispels nearly all the surprises. You choose the moment of capture by choosing the form: pass a value as an argument to freeze it at once, put it in a closure's body to read it at the end. Both are useful — you just need to know which one you have under your fingers.

Pourquoi geler les arguments tôt ?Why freeze the arguments early?

Le choix de Go — évaluer les arguments à l'instant du defer — n'est pas arbitraire. Il capture l'état du monde au moment où tu décides de différer, ce qui est souvent exactement ce qu'on veut. Un defer trace(time.Now()) en début de fonction fige l'heure de début, pas l'heure de fin : précisément l'usage attendu. Un defer log(currentStep) enregistre l'étape où l'on était quand on a posé le defer. En gelant les arguments, Go te permet de capturer un instantané sans avoir à le stocker toi-même dans une variable temporaire. La fermeture offre le comportement inverse — lire l'état final — pour les cas où c'est ce qu'on veut. Deux outils, deux moments de capture, et la responsabilité de choisir. Le langage ne devine pas ton intention ; il te donne deux formes claires et te laisse l'exprimer.Go's choice — evaluating arguments at the instant of defer — isn't arbitrary. It captures the state of the world at the moment you decide to defer, which is often exactly what you want. A defer trace(time.Now()) at a function's start freezes the start time, not the end time: precisely the expected use. A defer log(currentStep) records the step you were at when you placed the defer. By freezing the arguments, Go lets you capture a snapshot without having to store it yourself in a temporary variable. The closure offers the opposite behavior — read the final state — for cases where that's what you want. Two tools, two moments of capture, and the responsibility to choose. The language doesn't guess your intent; it gives you two clear forms and lets you express it.

№ 02La surpriseThe surprise4 min

Le même defer, deux formes, deux résultats opposés : « début » d'un côté, « changé » de l'autre.The same defer, two forms, two opposite results: "start" on one side, "changed" on the other.

Mettons l'écart en pleine lumière avec deux fonctions presque identiques, dont seule la forme du defer change. Dans la première, on diffère un appel direct avec un argument : defer fmt.Println(s). L'argument s est évalué à l'instant du defer, sa valeur d'alors — début — est gelée, et c'est elle qui s'imprimera, même si s change juste après. Dans la seconde, on diffère une fermeture qui lit s dans son corps : defer suivi d'une petite fonction anonyme. Ici, rien n'est évalué tôt — la fermeture ne prend pas d'argument — et c'est seulement à la sortie que son corps s'exécute, lisant alors s dans son état final : changé. Deux formes, deux moments de capture, deux résultats. Aucune n'est « la bonne » dans l'absolu ; tout dépend de ce que tu veux. Veux-tu capturer la valeur du moment où tu poses le defer ? Passe-la en argument. Veux-tu agir sur l'état tel qu'il sera à la sortie ? Mets-la dans le corps d'une fermeture. La confusion naît quand on écrit une forme en pensant à l'autre — typiquement, une fermeture qu'on croit avoir figée, et qui lit en réalité une valeur modifiée entre-temps. C'est précisément ce qui se produit dans le bug le plus célèbre du langage, celui de la variable de boucle, qu'on regarde juste après.Let's put the gap in full light with two nearly identical functions, where only the defer's form changes. In the first, you defer a direct call with an argument: defer fmt.Println(s). The argument s is evaluated at the instant of defer, its value then — start — is frozen, and that's what will print, even if s changes right after. In the second, you defer a closure that reads s in its body: defer followed by a little anonymous function. Here, nothing is evaluated early — the closure takes no argument — and only at exit does its body run, then reading s in its final state: changed. Two forms, two moments of capture, two results. Neither is 'the right one' in the absolute; it all depends on what you want. Do you want to capture the value at the moment you place the defer? Pass it as an argument. Do you want to act on the state as it will be at exit? Put it in a closure's body. The confusion arises when you write one form thinking of the other — typically, a closure you believe you froze, that actually reads a value modified in between. That's precisely what happens in the language's most famous bug, the loop variable, which we look at right after.

Argument différé : la valeur est photographiée tout de suiteDeferred argument: the value is photographed at once
func demo() {
    s := "début"
    defer fmt.Println(s)    // ARGUMENT : la valeur "début" est figée ici
    s = "changé"
    // à la sortie : imprime "début"  ← l'instantané pris au defer
}

L'appel différé fmt.Println(s) évalue s au passage du defer et garde « début » en réserve. Que s devienne « changé » ensuite n'y fait rien : l'argument est déjà gelé. C'est la forme à choisir quand tu veux capturer un instantané — l'heure de début, l'identifiant courant, l'état d'avant traitement. La valeur passée est mise à l'abri des modifications futures, sans que tu aies à la copier dans une variable dédiée.The deferred call fmt.Println(s) evaluates s as the defer passes and keeps "start" in reserve. That s later becomes "changed" makes no difference: the argument is already frozen. It's the form to choose when you want to capture a snapshot — the start time, the current id, the pre-processing state. The passed value is shielded from future changes, without you having to copy it into a dedicated variable.

Le bug le plus célèbre du langageThe language's most famous bug

Ce mécanisme est à la racine du bug de la variable de boucle. Une fermeture différée qui référence la variable d'un for lit cette variable à la sortie — et historiquement, en Go, cette variable était partagée par tous les tours de boucle. Résultat : toutes les fermetures différées voyaient la même variable, à sa valeur finale, et l'on obtenait dix fois le dernier élément au lieu des dix éléments. Go 1.22 a changé cette règle : la variable de boucle est désormais redéclarée à chaque tour, ce qui supprime le piège pour for. Mais l'enseignement demeure entier : une fermeture capture une variable, pas une valeur, et la lit quand elle s'exécute. Pour figer la valeur du tour, on passe encore par un argument — defer f(x) — ou par une copie locale explicite.This mechanism is at the root of the loop-variable bug. A deferred closure referencing a for variable reads that variable at exit — and historically, in Go, that variable was shared across all iterations. Result: all the deferred closures saw the same variable, at its final value, and you got ten times the last element instead of the ten elements. Go 1.22 changed this rule: the loop variable is now redeclared each iteration, which removes the trap for for. But the lesson stays whole: a closure captures a variable, not a value, and reads it when it runs. To freeze the iteration's value, you still go through an argument — defer f(x) — or an explicit local copy.

Un argument différé fige une valeur. Une fermeture différée capture une variable — et la lit seulement à la sortie.A deferred argument freezes a value. A deferred closure captures a variable — and reads it only at exit.
№ 03La mécaniqueThe mechanics5 min

Tout, dans l'expression différée, est évalué tout de suite — sauf l'appel extérieur lui-même. Receveur compris.Everything in the deferred expression is evaluated at once — except the outer call itself. Receiver included.

La règle exacte, une fois énoncée, dissipe toutes les surprises restantes : quand Go rencontre un defer, il évalue immédiatement tout ce qui constitue l'appel différé, à la seule exception de l'appel extérieur lui-même. Cela inclut deux choses qu'on oublie souvent. D'abord, le receveur de la méthode. Si tu écris defer t.stop(), Go évalue t à cet instant — en fait, il en prend une copie, puisque le receveur de stop est une valeur, exactement la sémantique du volume 6 — et c'est cette copie figée qui recevra l'appel à la sortie. Réassigner t après le defer n'a aucun effet : le receveur a déjà été photographié. Ensuite, les sous-appels dans les arguments. Si tu écris defer log(compute()), compute() n'est pas différé — il est appelé sur-le-champ, son résultat figé en argument, et seul log sera repoussé. C'est une source de confusion fréquente : on croit avoir différé tout un calcul, alors qu'on n'a différé que l'appel le plus extérieur. La règle se résume d'une phrase : dans defer A(B(c)), seul A est différé ; B et c sont évalués maintenant. Si tu veux différer aussi l'évaluation de B et c — agir sur leur état final, ou ne déclencher le calcul qu'à la sortie — tu dois envelopper le tout dans une fermeture, dont le corps, lui, n'est exécuté qu'à la fin. La fermeture est l'outil universel pour repousser l'évaluation complète ; l'appel direct, l'outil pour figer un instantané. Connaître cette frontière, c'est ne plus jamais être surpris par un defer.The exact rule, once stated, dispels all remaining surprises: when Go meets a defer, it immediately evaluates everything making up the deferred call, with the sole exception of the outer call itself. This includes two things often forgotten. First, the method's receiver. If you write defer t.stop(), Go evaluates t at that instant — in fact it takes a copy, since stop's receiver is a value, exactly volume 6's semantics — and it's that frozen copy that will receive the call at exit. Reassigning t after the defer has no effect: the receiver has already been photographed. Second, the sub-calls in the arguments. If you write defer log(compute()), compute() isn't deferred — it's called on the spot, its result frozen as an argument, and only log will be pushed back. It's a frequent source of confusion: you think you deferred a whole computation, when you only deferred the outermost call. The rule sums up in one sentence: in defer A(B(c)), only A is deferred; B and c are evaluated now. If you want to defer the evaluation of B and c too — act on their final state, or only trigger the computation at exit — you must wrap the whole in a closure, whose body only runs at the end. The closure is the universal tool to push back full evaluation; the direct call, the tool to freeze a snapshot. Knowing this boundary is never being surprised by a defer again.

Le receveur d'une méthode différée est évalué tout de suiteA deferred method's receiver is evaluated at once
type tracer struct{ label string }
func (t tracer) stop() { fmt.Println("stop:", t.label) }

func demo() {
    t := tracer{"A"}
    defer t.stop()      // le RECEVEUR t est évalué ici → copie {label:"A"} figée
    t = tracer{"B"}     // réassignation après le defer
    // à la sortie : "stop: A"  ← c'est le receveur gelé, pas le t final
}

defer t.stop() fige t à l'instant du defer, copie comprise — la réassignation t = tracer{"B"} arrive trop tard. C'est le même piège que l'argument figé, déplacé sur le receveur, et il surprend davantage parce que le receveur ne ressemble pas à un argument. Si tu veux que la méthode agisse sur l'état final de t, n'écris pas defer t.stop() : enveloppe-le dans une fermeture, defer func(){ t.stop() }(), dont le corps lira t à la sortie.defer t.stop() freezes t at the instant of defer, copy included — the reassignment t = tracer{"B"} comes too late. It's the same trap as the frozen argument, moved onto the receiver, and it surprises more because the receiver doesn't look like an argument. If you want the method to act on t's final state, don't write defer t.stop(): wrap it in a closure, defer func(){ t.stop() }(), whose body will read t at exit.

Dans defer A(B(c)), seul A attend la sortie. Pour tout différer — receveur, sous-appels, lecture finale — enveloppe dans une fermeture.In defer A(B(c)), only A waits for exit. To defer it all — receiver, sub-calls, final read — wrap in a closure.
№ 04Le piègeThe trap4 min

Un defer dans une boucle ne se déclenche pas à chaque tour. Il s'accumule, et n'explose qu'à la sortie de la fonction.A defer in a loop doesn't fire each iteration. It accumulates, and only bursts at the function's exit.

Voici le second grand piège du numéro, et il découle directement de la portée de defer qu'on a posée au numéro 1 : defer vise la sortie de la fonction, pas la fin du bloc. Dans une boucle qui acquiert une ressource à chaque tour, cette nuance devient un bug de ressources sévère. Tu ouvres un fichier dans le for, tu écris docilement defer f.Close() juste en dessous, et tu penses bien faire — la libération est collée à l'acquisition, comme on l'a appris. Mais ce defer ne ferme rien à la fin du tour de boucle : il met le Close de côté, et tous ces Close s'empilent, tour après tour, pour ne se déclencher qu'au retour de la fonction. Sur dix fichiers, personne ne le remarque. Sur dix mille, le programme garde dix mille descripteurs ouverts simultanément, atteint la limite du système d'exploitation, et échoue avec « too many open files » — un échec d'autant plus déroutant qu'il ne dépend que du volume, et que le code « ferme bien ses fichiers ». La cause est exactement la portée fonction de defer : la boucle n'est pas une frontière pour lui. La parade canonique est d'introduire la frontière manquante — extraire le corps de la boucle dans sa propre fonction. Dès lors, chaque itération appelle cette fonction, qui ouvre, traite, et voit son defer se déclencher à sa propre sortie, c'est-à-dire à chaque tour. Le fichier est fermé immédiatement, avant le suivant, et il n'y en a jamais plus d'un ouvert à la fois. C'est le bon réflexe général : quand tu acquiers une ressource dans une boucle, le corps de cette boucle veut presque toujours être une fonction.Here's the issue's second great trap, and it follows directly from defer's scope we laid down in issue 1: defer targets the function's exit, not the block's end. In a loop that acquires a resource each iteration, this nuance becomes a severe resource bug. You open a file in the for, you dutifully write defer f.Close() right below, and you think you're doing well — the release glued to the acquisition, as we learned. But this defer closes nothing at the loop iteration's end: it sets the Close aside, and all these Closes pile up, iteration after iteration, only to fire on the function's return. On ten files, nobody notices. On ten thousand, the program holds ten thousand descriptors open simultaneously, hits the operating system's limit, and fails with 'too many open files' — a failure all the more disorienting because it depends only on volume, and the code 'does close its files.' The cause is exactly defer's function scope: the loop isn't a boundary for it. The canonical fix is to introduce the missing boundary — extract the loop body into its own function. From then on, each iteration calls that function, which opens, processes, and sees its defer fire at its own exit, that is, each iteration. The file is closed immediately, before the next, and there's never more than one open at a time. It's the right general reflex: when you acquire a resource in a loop, that loop's body almost always wants to be a function.

Les Close s'empilent et n'explosent qu'au retourThe Closes pile up and only burst on return
func processAll(paths []string) error {
    for _, p := range paths {
        f, err := os.Open(p)
        if err != nil {
            return err
        }
        defer f.Close()      // ← ne ferme PAS en fin de tour : en fin de processAll
        use(f)
    }
    // si paths a 10 000 entrées, 10 000 fichiers restent OUVERTS jusqu'ici…
    return nil               // → "too many open files" bien avant d'y arriver
}

Le code a l'air exemplaire : acquisition, defer de libération juste dessous. Mais la boucle n'est pas une frontière pour defer, alors les Close attendent tous la sortie de processAll. Le bug ne dépend que de la taille de l'entrée — il passe en test sur trois fichiers et tombe en production sur des milliers, exactement le profil de défaillance qu'on déteste. Le message « too many open files » est le symptôme ; la cause est la portée fonction de defer.The code looks exemplary: acquisition, release defer right below. But the loop isn't a boundary for defer, so the Closes all wait for processAll's exit. The bug depends only on input size — it passes in a test on three files and falls in production on thousands, exactly the failure profile we hate. The 'too many open files' message is the symptom; the cause is defer's function scope.

La portée fonction, deux fois piégeuseFunction scope, twice a trap

Les deux pièges du numéro tiennent à la même propriété, lue sous deux angles. La capture : un defer fige ses arguments tôt mais s'exécute tard, et confondre les deux instants donne le bug de la valeur capturée. L'accumulation : un defer appartient à la fonction, pas à la boucle, et l'oublier remplit la table des descripteurs. Dans les deux cas, le remède passe souvent par une fonction : envelopper pour différer l'évaluation, extraire pour borner la portée. defer récompense ceux qui savent exactement où commence et finit une fonction.The issue's two traps rest on the same property, read from two angles. Capture: a defer freezes its arguments early but runs late, and confusing the two instants gives the captured-value bug. Accumulation: a defer belongs to the function, not the loop, and forgetting it fills the descriptor table. In both cases, the cure often goes through a function: wrap to defer the evaluation, extract to bound the scope. defer rewards those who know exactly where a function begins and ends.

Le defer peut faire plus que nettoyer : il peut rattraper.defer can do more than clean up: it can catch.

On a vu quand un defer s'exécute (numéro 1) et ce qu'il capture (ce numéro). Reste sa capacité la plus puissante, à peine effleurée : un defer est le seul endroit d'où l'on peut reprendre la main sur un panic, via recover. Le volume 4 en a montré la mécanique — recover déroule, convertit la rupture en valeur. Mais une question reste ouverte, et c'est tout le sujet du dernier numéro de ce volume : où placer ce defer qui récupère ? Pas partout. Recover n'a de sens qu'à certaines frontières — l'entrée d'une requête, le sommet d'une goroutine de travail — et l'utiliser ailleurs revient à masquer des bugs au lieu de les traiter. Le danger n'est pas de paniquer, c'est d'avaler la panique en silence. Vol. 7 №03 — recover sans masquer.We've seen when a defer runs (issue 1) and what it captures (this issue). Its most powerful capacity remains, barely touched: a defer is the only place from which you can take back control of a panic, via recover. Volume 4 showed the mechanics — recover unwinds, converts the rupture into a value. But a question stays open, and it's the whole subject of this volume's last issue: where to place that recovering defer? Not everywhere. Recover only makes sense at certain boundaries — a request's entry, a worker goroutine's top — and using it elsewhere amounts to masking bugs instead of handling them. The danger isn't panicking, it's swallowing the panic silently. Vol. 7 №03 — recover without masking.

Un defer en boucle ne ferme rien avant la sortie de la fonction. Pour fermer à chaque tour, donne à chaque tour sa propre fonction.A defer in a loop closes nothing before the function exits. To close each pass, give each pass its own function.
№ 05Bilan & éditoWrap-up & editorial2 min

Tout defer tient en une frontière : ce qui est figé à l'instant du defer, et ce qui attend la sortie.Every defer rests on one boundary: what's frozen at the instant of defer, and what waits for exit.

Ce numéro a déplié le quoi de defer. Un defer vit en deux temps : ses arguments sont évalués à l'instant où on le rencontre, son appel s'exécute à la sortie. De là, deux formes opposées : un appel direct fige ses arguments — instantané — tandis qu'une fermeture lit les variables à la sortie — état final. La règle exacte étend ce gel à tout l'intérieur de l'expression différée : le receveur de la méthode et les sous-appels dans les arguments sont, eux aussi, évalués tout de suite ; seul l'appel le plus extérieur attend. D'où les deux pièges du numéro, deux faces d'une même portée fonction : la capture, qui produit le bug de la variable de boucle quand on attend figé ce qui ne l'est pas, et l'accumulation, qui remplit la table des descripteurs quand un defer en boucle ne se déclenche qu'au retour. Le remède, dans les deux cas, est souvent une fonction — envelopper pour différer, extraire pour borner. Avec le numéro 1, on sait désormais quand un defer s'exécute et ce qu'il emporte. Reste sa faculté la plus délicate : reprendre la main sur un panic — et le faire au bon endroit.This issue unfolded defer's what. A defer lives in two times: its arguments are evaluated at the instant it's met, its call runs at exit. From there, two opposite forms: a direct call freezes its arguments — snapshot — while a closure reads the variables at exit — final state. The exact rule extends this freeze to everything inside the deferred expression: the method's receiver and the sub-calls in the arguments are also evaluated at once; only the outermost call waits. Hence the issue's two traps, two faces of the same function scope: capture, which produces the loop-variable bug when you expect frozen what isn't, and accumulation, which fills the descriptor table when a defer in a loop only fires on return. The cure, in both cases, is often a function — wrap to defer, extract to bound. With issue 1, we now know when a defer runs and what it carries. Its most delicate faculty remains: taking back control of a panic — and doing it in the right place.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Deux instantsTwo instantsArguments évalués au defer ; appel exécuté à la sortie de la fonction.Arguments evaluated at defer; call run at the function's exit.Tu lis une valeur que tu croyais figée — ou l'inverse.You read a value you thought frozen — or the reverse.
Argument vs fermetureArgument vs closureL'argument fige une valeur ; la fermeture lit la variable à la sortie.The argument freezes a value; the closure reads the variable at exit.Le bug de la variable de boucle, le grand classique.The loop-variable bug, the great classic.
Tout sauf l'appelAll but the callReceveur et sous-appels évalués maintenant ; seul l'appel extérieur attend.Receiver and sub-calls evaluated now; only the outer call waits.Un « différé » qui n'a différé que l'affichage, pas le calcul.A 'deferred' that only deferred the display, not the work.
defer en boucledefer in a loopPortée fonction, pas bloc : extrais le corps de boucle en fonction.Function scope, not block: extract the loop body into a function.Les libérations s'empilent : « too many open files ».Releases pile up: 'too many open files.'
Un argument différé est une photographie ; une fermeture différée, une fenêtre. L'une fige l'instant, l'autre montre la fin — choisis en connaissance.A deferred argument is a photograph; a deferred closure, a window. One freezes the instant, the other shows the end — choose knowingly.
Mot de l'éditeurFrom the editor

La simplicité de defer est réelle, mais elle a un prix : il faut savoir lire le temps qu'il manipule.defer's simplicity is real, but it has a price: you must know how to read the time it manipulates.

defer est l'un de ces traits qu'on croit comprendre en une minute et qu'on maîtrise vraiment après quelques bugs. La raison est qu'il introduit une discontinuité dans le temps du programme : une ligne s'écrit ici mais s'exécute là-bas, et entre les deux, le monde change. La plupart du code se lit de haut en bas, chaque ligne dans l'ordre ; defer brise cette linéarité en envoyant du code dans le futur, tout en évaluant une partie de ses ingrédients dans le présent. Cette double temporalité est sa puissance — c'est elle qui permet d'écrire la libération à côté de l'acquisition — mais c'est aussi ce qui demande de la rigueur. Les deux pièges qu'on a vus ne sont pas des défauts du langage ; ce sont les conséquences logiques d'une règle parfaitement cohérente, qu'on subit tant qu'on ne l'a pas explicitée, et qu'on maîtrise dès qu'on l'a fait. Savoir, pour chaque defer, ce qui est figé et ce qui est différé, c'est lire le temps du programme aussi clairement que son espace.defer is one of those features you think you grasp in a minute and truly master after a few bugs. The reason is that it introduces a discontinuity in the program's time: a line is written here but runs over there, and between the two, the world changes. Most code reads top to bottom, each line in order; defer breaks that linearity by sending code into the future, while evaluating some of its ingredients in the present. This double temporality is its power — it's what lets you write the release next to the acquisition — but it's also what demands rigor. The two traps we saw aren't language flaws; they're the logical consequences of a perfectly coherent rule, which you suffer until you've made it explicit, and master once you have. Knowing, for each defer, what's frozen and what's deferred is reading the program's time as clearly as its space.

Le dernier numéro du volume aborde la faculté de defer qu'on a gardée pour la fin, parce qu'elle est la plus puissante et la plus facile à mal employer : reprendre la main sur un panic. Le volume 4 avait montré la mécanique de recover — qu'il ne fonctionne que dans un defer, qu'il convertit une rupture en valeur, qu'on nomme le retour pour la remonter proprement. Ce qu'on n'avait pas tranché, c'est la question du lieu. Où place-t-on un recover ? La réponse n'est pas « là où ça peut paniquer », mais « à la frontière d'une unité de travail » — l'entrée d'une requête HTTP, le sommet d'une goroutine, l'appel d'un greffon. Récupérer trop largement, c'est avaler des bugs qui auraient dû faire crasher le programme en développement, et le laisser continuer dans un état corrompu. Le vrai danger n'a jamais été le panic ; c'est le recover qui masque. On termine le volume sur cette discipline : récupérer à la frontière, nommer le retour, re-paniquer ce qu'on ne comprend pas, ne jamais cacher un invariant rompu. Vol. 7 №03 — recover sans masquer.The volume's last issue tackles the faculty of defer we kept for the end, because it's the most powerful and the easiest to misuse: taking back control of a panic. Volume 4 showed recover's mechanics — that it only works in a defer, that it converts a rupture into a value, that you name the return to surface it cleanly. What we hadn't settled is the question of place. Where do you put a recover? The answer isn't 'where it can panic,' but 'at the boundary of a unit of work' — an HTTP request's entry, a goroutine's top, a plugin's call. Recovering too broadly is swallowing bugs that should have crashed the program in development, and letting it continue in a corrupt state. The real danger was never the panic; it's the recover that masks. We close the volume on this discipline: recover at the boundary, name the return, re-panic what you don't understand, never hide a broken invariant. Vol. 7 №03 — recover without masking.