recover sans masquer recover without masking

recover transforme un panic en valeur — à la frontière d'une requête ou d'une goroutine, pas partout. Le danger n'est pas de paniquer, c'est d'avaler un bug en silence. Re-paniquer, nommer le retour, ne jamais cacher l'invariant rompu. recover turns a panic into a value — at the boundary of a request or a goroutine, not everywhere. The danger isn't panicking, it's swallowing a bug silently. Re-panic, name the return, never hide the broken invariant.

Audience
Dev tenté de mettre recover partout, ou dont une goroutine fait tomber tout le serveur Dev tempted to put recover everywhere, or whose goroutine takes down the whole server
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●●●○
Date
Fév 2028 Feb 2028

recoverFrontière

SommaireContents ·
№ 01CadrageFraming3 min

recover n'est pas un try/catch qu'on saupoudre. C'est une digue, qu'on bâtit à une frontière précise.recover isn't a try/catch you sprinkle. It's a dike, built at a precise boundary.

Le volume 4 a montré la mécanique de recover : qu'il ne fonctionne que dans un defer, qu'il intercepte un panic en train de dérouler la pile, et qu'il convertit cette rupture en une valeur qu'on peut inspecter. Ce numéro ne revient pas sur cette mécanique — il répond à la question qu'elle laisse ouverte, et qui sépare le code robuste du code dangereux : où place-t-on un recover ? La tentation, surtout quand on vient d'un langage à exceptions, est de le traiter comme un try/catch et d'en mettre un peu partout, autour de chaque appel qui pourrait mal tourner. C'est exactement ce qu'il ne faut pas faire. recover a un seul bon emplacement : la frontière d'une unité de travail. Un serveur HTTP traite des milliers de requêtes ; si l'une d'elles panique à cause d'un bug, on ne veut pas que tout le serveur s'effondre et coupe les autres. On installe donc un recover à la frontière de la requête — typiquement dans un middleware — qui transforme le panic d'une requête en une réponse 500 pour ce client-là, journalise la trace pour qu'on puisse corriger, et laisse le serveur continuer à servir tous les autres. Le même raisonnement vaut pour le sommet d'une goroutine de travail, ou l'appel d'un greffon dont on ne maîtrise pas le code. La frontière, c'est l'endroit où l'on décide qu'une unité peut échouer sans contaminer le reste. Partout ailleurs, recover n'isole rien — il masque. Et masquer un panic, on va le voir, c'est souvent pire que le laisser tuer le programme.Volume 4 showed recover's mechanics: that it only works in a defer, that it intercepts a panic unwinding the stack, and that it converts that rupture into a value you can inspect. This issue doesn't revisit that mechanics — it answers the question it leaves open, and which separates robust code from dangerous code: where do you put a recover? The temptation, especially coming from an exception language, is to treat it like a try/catch and put one everywhere, around each call that might go wrong. That's exactly what not to do. recover has a single good location: the boundary of a unit of work. An HTTP server handles thousands of requests; if one of them panics because of a bug, you don't want the whole server to collapse and cut off the others. So you install a recover at the request's boundary — typically in a middleware — that turns one request's panic into a 500 response for that client, logs the trace so you can fix it, and lets the server keep serving all the others. The same reasoning holds for a worker goroutine's top, or the call of a plugin whose code you don't control. The boundary is the place where you decide a unit may fail without contaminating the rest. Everywhere else, recover isolates nothing — it masks. And masking a panic, as we'll see, is often worse than letting it kill the program.

Une digue à la frontière de la requêteA dike at the request boundary
func recoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if v := recover(); v != nil {
                log.Printf("panic récupéré : %v\n%s", v, debug.Stack())
                http.Error(w, "internal error", 500)   // … CETTE requête meurt
            }
        }()
        next.ServeHTTP(w, r)   // … le serveur, lui, continue de servir les autres
    })
}
La frontière isole l'échecThe boundary isolates the failure
une requête
un panic peut survenir
→
la frontière
recover : 500 + log
→
le process
reste vivant, sert les autres

Le recover bien placé ne supprime pas l'échec — il le contient. Une unité tombe, le reste tient. C'est une frontière d'isolation, pas un filet posé sous chaque ligne de code.A well-placed recover doesn't erase the failure — it contains it. One unit falls, the rest holds. It's an isolation boundary, not a net laid under every line of code.

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

« Suis-je à une frontière d'unité de travail ? si oui, je récupère, je journalise, je convertis. Sinon, je laisse passer. » Un recover se compte sur les doigts d'une main dans une base de code : un par serveur, un par pool de goroutines, un par appel de greffon. S'il y en a dans chaque fonction, c'est le signe qu'on s'en sert comme d'un try/catch — et qu'on est en train de transformer des bugs francs en silences trompeurs."Am I at a unit-of-work boundary? if yes, I recover, log, convert. Otherwise, I let it through." A recover should be countable on one hand in a codebase: one per server, one per goroutine pool, one per plugin call. If there's one in every function, it's the sign you're using it as a try/catch — and turning honest bugs into deceptive silences.

Pourquoi un panic ne devrait pas tuer tout un serveurWhy one panic shouldn't kill a whole server

En Go, un panic non récupéré dans n'importe quelle goroutine arrête le processus entier — y compris les milliers de requêtes en vol qui n'avaient rien à voir. C'est cohérent avec la philosophie du langage : un panic signale un invariant rompu, un état où il n'est plus sûr de continuer, et la réponse par défaut est l'arrêt. Mais à l'échelle d'un serveur, cette réponse est trop brutale : le bug d'une requête ne devrait pas priver les autres de service. net/http le sait : il rattrape déjà le panic d'un handler, le journalise et coupe la connexion — mais le client ne reçoit aucune réponse exploitable, et une goroutine lancée par le handler n'est pas couverte du tout. Le middleware de recover rend l'échec propre : une vraie 500, une trace structurée. La frontière de recover est précisément le compromis : on accepte qu'une requête isolée échoue durement, on en capture la trace pour la corriger, et on préserve la disponibilité de l'ensemble. C'est de l'isolation de panne, au sens des systèmes — circonscrire le rayon de souffle d'un défaut. Le mot-clé, c'est circonscrire : pas étouffer.In Go, an unrecovered panic in any goroutine stops the whole process — including the thousands of in-flight requests that had nothing to do with it. It's consistent with the language's philosophy: a panic signals a broken invariant, a state where it's no longer safe to continue, and the default response is to stop. But at a server's scale, that response is too brutal: one request's bug shouldn't deprive the others of service. net/http knows this: it already recovers a handler's panic, logs it and drops the connection — but the client gets no usable response, and a goroutine launched by the handler isn't covered at all. A recover middleware makes the failure clean: a real 500, a structured trace. The recover boundary is precisely the compromise: you accept that an isolated request fails hard, you capture its trace to fix it, and you preserve the availability of the whole. It's fault isolation, in the systems sense — bounding a defect's blast radius. The keyword is bound: not smother.

№ 02La surpriseThe surprise4 min

Le danger n'est pas de paniquer. C'est le recover() nu qui avale le bug et laisse le programme continuer corrompu.The danger isn't panicking. It's the bare recover() that swallows the bug and lets the program continue corrupted.

On croit souvent qu'un panic est l'ennemi, et que recover est là pour le neutraliser. C'est un contresens, et il produit le pire motif du langage : le recover nu, defer suivi d'une fermeture qui appelle recover sans rien faire de sa valeur, posé « pour que ça ne crashe pas ». Regarde ce qu'il provoque. Une fonction déréférence un pointeur nil — un vrai bug, une erreur de programmeur — et panique. Le recover nu intercepte ce panic, jette sa valeur, et laisse la fonction se terminer comme si de rien n'était. Aucun log, aucune erreur remontée, aucune trace : le bug a été parfaitement effacé. Sauf que le travail, lui, n'a pas été fait — la configuration n'a jamais été appliquée, la transaction est à moitié écrite, l'état est incohérent. Et le programme continue, en traînant cette corruption silencieuse, jusqu'à ce qu'elle ressorte plus loin sous une forme méconnaissable. Voilà pourquoi un panic vaut mieux qu'un recover qui masque : le panic est honnête, il s'arrête net et te pointe la ligne fautive ; le recover nu est un mensonge, il prétend que tout va bien sur les ruines d'un invariant rompu. La règle est donc inverse de l'intuition : on ne récupère pas pour cacher un panic, on récupère pour le rendre visible autrement — le journaliser avec sa trace, le convertir en une erreur que l'appelant verra, décider en connaissance de cause. Recover n'est légitime que s'il ne perd aucune information. Dès qu'il en perd, il transforme un crash réparable en un bug fantôme.People often think a panic is the enemy, and recover is there to neutralize it. It's a misreading, and it produces the language's worst pattern: the bare recover, a defer followed by a closure that calls recover without doing anything with its value, placed 'so it doesn't crash.' Look at what it causes. A function dereferences a nil pointer — a real bug, a programmer error — and panics. The bare recover intercepts that panic, throws away its value, and lets the function finish as if nothing happened. No log, no surfaced error, no trace: the bug has been perfectly erased. Except the work wasn't done — the configuration was never applied, the transaction is half-written, the state is inconsistent. And the program continues, dragging this silent corruption, until it resurfaces further on in an unrecognizable form. That's why a panic is better than a recover that masks: the panic is honest, it stops dead and points you to the faulty line; the bare recover is a lie, it pretends all is well on the ruins of a broken invariant. So the rule is the opposite of intuition: you don't recover to hide a panic, you recover to make it visible otherwise — log it with its trace, convert it into an error the caller will see, decide knowingly. Recover is only legitimate if it loses no information. The moment it loses some, it turns a fixable crash into a phantom bug.

Le recover nu : un bug parfaitement effacéThe bare recover: a bug perfectly erased
func process(data []byte) {
    defer func() { recover() }()   // « pour éviter les crashs »… recover nu, jeté

    cfg := parse(data)             // si parse renvoie nil et qu'on déréférence…
    apply(cfg.Settings)            // … panic : nil pointer dereference
}
// recover l'avale, process « réussit » en silence — rien n'a été appliqué.
// aucun log, aucune erreur, un état à moitié traité qui continue sa route.

Le recover() nu fait exactement ce qu'il dit : il récupère, et c'est tout. La valeur du panic — qui contenait le type de l'erreur, la trace, la ligne — part à la poubelle. Un déréférencement nil, qui aurait dû crasher bruyamment et être corrigé en une heure, devient un travail silencieusement à moitié fait. C'est le contraire de la robustesse : on a échangé un échec visible et réparable contre une corruption invisible et durable. Ce motif mérite une revue de code systématiquement bloquante.The bare recover() does exactly what it says: it recovers, and that's all. The panic's value — which held the error's type, the trace, the line — goes to the trash. A nil dereference, which should have crashed loudly and been fixed in an hour, becomes silently half-done work. It's the opposite of robustness: you traded a visible, fixable failure for an invisible, lasting corruption. This pattern deserves a systematically blocking code review.

Un panic est honnête ; un recover nu mentA panic is honest; a bare recover lies

Renverse l'intuition une bonne fois. Un panic non récupéré est un bon citoyen : il s'arrête à la première incohérence, te donne la pile exacte, et t'empêche de propager un état corrompu. Le recover() nu fait l'inverse de chacun de ces services : il continue malgré l'incohérence, efface la pile, et propage l'état corrompu. La question n'est jamais « comment empêcher le panic ? » mais « cette unité de travail a-t-elle une frontière où un échec peut être contenu sans être caché ? ». Si oui, récupère en remontant tout. Si non, laisse le panic faire son travail — il vaut mieux qu'un mensonge.Reverse the intuition once and for all. An unrecovered panic is a good citizen: it stops at the first inconsistency, gives you the exact stack, and prevents you from propagating a corrupt state. The bare recover() does the opposite of each of these services: it continues despite the inconsistency, erases the stack, and propagates the corrupt state. The question is never "how do I prevent the panic?" but "does this unit of work have a boundary where a failure can be contained without being hidden?". If yes, recover surfacing everything. If no, let the panic do its job — it's better than a lie.

Un panic te montre où c'est cassé. Un recover() nu efface la preuve et laisse le programme mentir.A panic shows you where it broke. A bare recover() erases the evidence and lets the program lie.
№ 03La mécaniqueThe mechanics5 min

Récupérer, c'est classer : convertir ce que tu reconnais en erreur, re-paniquer ce que tu ne reconnais pas.Recovering is classifying: convert what you recognize into an error, re-panic what you don't.

Un recover correct ne se contente pas d'attraper — il trie. La valeur que recover renvoie est de type any, ce qui force à l'inspecter avant d'en faire quoi que ce soit : c'est l'assertion de type du volume 3, appliquée à la valeur d'un panic. Deux mécaniques en découlent, complémentaires. La première est la conversion : on transforme la rupture en une erreur de retour, proprement, en s'appuyant sur un retour nommé. Si la valeur récupérée est déjà une error, on la remonte telle quelle ; sinon, on l'emballe dans une error avec un message. Le panic, d'événement exceptionnel, redevient une valeur ordinaire que l'appelant traitera avec le même if err != nil que partout ailleurs. La seconde mécanique, plus fine, est le re-panic sélectif. Quand une fonction utilise le panic en interne — un analyseur récursif profond qui remonte une erreur de syntaxe en paniquant plutôt qu'en propageant une erreur à chaque niveau — son recover de frontière doit récupérer uniquement son propre type de panic, et re-paniquer tout le reste. Pourquoi ? Parce que tout le reste — un nil deref, un index hors bornes — n'est pas une erreur de syntaxe attendue, c'est un vrai bug, et le masquer serait exactement la faute du chapitre 2. On vérifie donc le type de la valeur : si c'est le panic qu'on a soi-même émis, on le convertit en erreur ; sinon, on relance le panic intact, pour qu'il poursuive son déroulement et finisse par s'arrêter là où il le doit. Récupérer son propre signal, laisser passer les bugs des autres : c'est la discipline qui sépare un recover chirurgical d'un filet qui attrape tout.A correct recover doesn't just catch — it sorts. The value recover returns is of type any, which forces you to inspect it before doing anything with it: it's volume 3's type assertion, applied to a panic's value. Two mechanics follow, complementary. The first is conversion: you turn the rupture into a return error, cleanly, leaning on a named return. If the recovered value is already an error, you surface it as is; otherwise, you wrap it in an error with a message. The panic, from exceptional event, becomes again an ordinary value the caller will handle with the same if err != nil as everywhere else. The second mechanic, subtler, is selective re-panic. When a function uses panic internally — a deep recursive parser that surfaces a syntax error by panicking rather than propagating an error at each level — its boundary recover must recover only its own panic type, and re-panic everything else. Why? Because everything else — a nil deref, an out-of-bounds index — isn't an expected syntax error, it's a real bug, and masking it would be exactly chapter 2's fault. So you check the value's type: if it's the panic you yourself emitted, you convert it into an error; otherwise, you re-throw the panic intact, so it continues unwinding and ends up stopping where it should. Recover your own signal, let others' bugs through: that's the discipline separating a surgical recover from a net that catches everything.

Convertir le panic en erreur de retour, par typeConvert the panic into a return error, by type
func safeRun(task func()) (err error) {   // retour NOMMÉ
    defer func() {
        switch v := recover().(type) {
        case nil:
            // pas de panic : err reste nil
        case error:
            err = v                           // un panic(err) remonte comme erreur
        default:
            err = fmt.Errorf("panic : %v", v) // tout le reste, emballé proprement
        }
    }()

    task()
    return nil
}

Le switch de type sur recover() fait trois choses d'un coup : il distingue l'absence de panic (nil), le panic qui portait déjà une error, et tout autre cas qu'on emballe. Le retour nommé err est ce qui rend la conversion possible — la fermeture l'assigne, et l'appelant reçoit une erreur normale. C'est le pont direct avec le volume 3 : la valeur d'un panic est un any, et on ne la manipule qu'après l'avoir interrogée sur son type.The type switch on recover() does three things at once: it distinguishes the absence of panic (nil), the panic that already carried an error, and any other case that you wrap. The named return err is what makes the conversion possible — the closure assigns it, and the caller receives a normal error. It's the direct bridge with volume 3: a panic's value is an any, and you only handle it after querying its type.

La valeur d'un panic est un any : interroge-la. Convertis ce que tu reconnais, re-panique ce qui ne t'appartient pas.A panic's value is an any: interrogate it. Convert what you recognize, re-panic what isn't yours.
№ 04Le piègeThe trap4 min

Un recover ne couvre que sa propre pile. Le panic d'une goroutine lancée tue tout le process — sauf si elle se protège.A recover only covers its own stack. A spawned goroutine's panic kills the whole process — unless it guards itself.

Voici le piège qui rassemble tout le volume, et qui prolonge une leçon du volume 4 : un recover ne protège que la pile dans laquelle il se trouve. On l'oublie dès qu'on lance des goroutines. Tu places un beau recover de frontière dans main, ou dans ton handler, persuadé d'avoir couvert tes arrières — puis tu démarres des goroutines de travail, et l'une d'elles panique. Surprise : le recover du parent ne l'attrape pas. Une goroutine a sa propre pile, indépendante ; le déroulement de son panic ne remonte jamais jusqu'au recover du parent, parce qu'ils ne sont pas sur la même pile. Et un panic non récupéré dans n'importe quelle goroutine arrête le processus entier. Le résultat est brutal : une seule goroutine fautive, et tout le serveur tombe, recover de main ou pas. La règle qui en découle est nette et sans exception : chaque goroutine que tu lances et qui peut paniquer doit porter sa propre frontière de recover, à son sommet. Concrètement, on n'écrit jamais go faireQuelqueChose() pour du travail qui peut planter ; on écrit go worker(...), où worker commence par un defer de récupération qui journalise, isole l'échec de ce job, et laisse les autres goroutines vivre. C'est la généralisation de tout ce qu'on a vu : la frontière de recover doit envelopper chaque unité d'exécution indépendante, et une goroutine est exactement cela — une unité d'exécution indépendante. Au-delà du serveur HTTP, c'est le motif de tous les pools de workers, files de jobs et démons de fond robustes.Here's the trap that gathers the whole volume, and extends a volume 4 lesson: a recover only protects the stack it sits in. You forget it the moment you spawn goroutines. You place a fine boundary recover in main, or in your handler, convinced you've covered your back — then you start worker goroutines, and one of them panics. Surprise: the parent's recover doesn't catch it. A goroutine has its own, independent stack; its panic's unwind never climbs up to the parent's recover, because they're not on the same stack. And an unrecovered panic in any goroutine stops the whole process. The result is brutal: a single faulty goroutine, and the entire server falls, main's recover or not. The resulting rule is sharp and without exception: every goroutine you spawn that can panic must carry its own recover boundary, at its top. Concretely, you never write go doSomething() for work that can crash; you write go worker(...), where worker starts with a recovery defer that logs, isolates that job's failure, and lets the other goroutines live. It's the generalization of everything we've seen: the recover boundary must wrap each independent unit of execution, and a goroutine is exactly that — an independent unit of execution. Beyond the HTTP server, it's the pattern of all robust worker pools, job queues, and background daemons.

Le recover du parent n'atteint pas la pile de la goroutineThe parent's recover doesn't reach the goroutine's stack
func main() {
    defer func() { recover() }()   // ne protège QUE main, PAS les goroutines

    for _, job := range jobs {
        go func() {
            process(job)           // si process panique ici…
        }()                        // … aucun recover ne l'attrape → tout le process meurt
    }
}
// le recover de main est inutile : il ne couvre pas la pile des goroutines lancées.

Le recover dans main donne une fausse assurance : il couvre la pile de main, pas celles des goroutines. Le panic d'un seul job remonte sa propre pile, ne trouve aucun recover, et fait tomber le processus entier — emportant tous les autres jobs en cours. C'est le prolongement direct du volume 4 : on ne récupère pas le panic d'autrui, et une goroutine est, à cet égard, une autre pile. La protection doit voyager avec l'unité d'exécution, pas rester chez le parent.The recover in main gives false assurance: it covers main's stack, not the goroutines'. A single job's panic climbs its own stack, finds no recover, and brings down the whole process — taking all the other in-flight jobs with it. It's the direct extension of volume 4: you don't recover another's panic, and a goroutine is, in this respect, another stack. The protection must travel with the unit of execution, not stay with the parent.

La discipline, en un paragrapheThe discipline, in one paragraph

Trois frontières méritent un recover, et presque aucune autre : l'entrée d'une requête (middleware), le sommet d'une goroutine de travail, et l'appel d'un code qu'on ne maîtrise pas (greffon). À chacune, le même rituel : journaliser avec la trace, convertir en erreur ou en réponse d'échec, isoler l'unité. Jamais avaler. Partout ailleurs — au cœur de la logique métier — on laisse les panics remonter, car ce sont des bugs qu'on veut voir crasher en développement. Le recover n'est pas un outil de gestion d'erreurs ; c'est un outil d'isolation de pannes.Three boundaries deserve a recover, and almost no other: a request's entry (middleware), a worker goroutine's top, and the call of code you don't control (plugin). At each, the same ritual: log with the trace, convert into an error or a failure response, isolate the unit. Never swallow. Everywhere else — in the heart of business logic — you let panics climb, because they're bugs you want to crash in development. recover isn't an error-handling tool; it's a fault-isolation tool.

defer et recover gardent une sortie. Reste à coordonner toutes les sorties.defer and recover guard one exit. There remain all the exits to coordinate.

Tout ce volume a parlé de la sortie d'une fonction : la planifier avec defer, comprendre ce qu'elle capture, en reprendre la main avec recover à la bonne frontière. C'est le contrôle local — une fonction, une goroutine, qui s'arrête proprement. Mais un programme concurrent réel a des dizaines de goroutines en arbre, et quand le haut décide d'arrêter — la requête est annulée, le délai est dépassé, l'utilisateur a fermé l'onglet — il faut que tout ce qui travaille en dessous l'apprenne et s'arrête à son tour. recover protège une pile ; il ne dit rien à dix goroutines de cesser leur travail. Ce signal qui descend, du sommet vers tout ce qui en dépend, c'est l'objet du prochain volume. context.Context est le câble qui traverse les couches et porte l'annulation. Vol. 8 №01 — context.Context, l'annulation qui descend.This whole volume spoke of a function's exit: scheduling it with defer, understanding what it captures, taking back control with recover at the right boundary. It's local control — one function, one goroutine, stopping cleanly. But a real concurrent program has dozens of goroutines in a tree, and when the top decides to stop — the request is canceled, the deadline passed, the user closed the tab — everything working below must learn it and stop in turn. recover protects one stack; it tells nothing to ten goroutines to cease their work. That signal flowing down, from the top to everything depending on it, is the next volume's subject. context.Context is the cable threading through the layers and carrying cancellation. Vol. 8 №01 — context.Context, cancellation flowing down.

Le recover de main ne sauvera pas tes goroutines. Chaque unité d'exécution porte sa propre frontière — ou n'en a aucune.main's recover won't save your goroutines. Each unit of execution carries its own boundary — or has none at all.
№ 05Bilan & éditoWrap-up & editorial2 min

Le bon recover ne fait pas disparaître l'échec. Il le déplace à une frontière, le journalise, et le convertit.The right recover doesn't make the failure disappear. It moves it to a boundary, logs it, and converts it.

Ce numéro a fermé le volume sur la faculté la plus délicate de defer : reprendre la main sur un panic, sans trahir. Le volume 4 donnait la mécanique de recover ; celui-ci donne la discipline. recover a un seul bon emplacement, la frontière d'une unité de travail — entrée de requête, sommet de goroutine, appel de greffon — où l'on contient un échec pour qu'il ne contamine pas le reste. Le danger n'est jamais le panic, qui est honnête ; c'est le recover() nu qui avale sa valeur, efface la trace, et laisse le programme continuer corrompu. Récupérer correctement, c'est ne rien perdre : interroger la valeur, qui est un any ; convertir en erreur ce qu'on reconnaît, via un retour nommé ; re-paniquer ce qu'on ne possède pas, pour ne pas déguiser un bug en condition attendue. Et comme un recover ne couvre que sa propre pile, chaque goroutine lancée porte sa propre frontière — sinon une seule fautive emporte tout le processus. Avec defer pour planifier la sortie, la règle de capture pour savoir ce qu'on emporte, et recover de frontière pour isoler sans masquer, le volume a couvert toute la discipline de la sortie d'une fonction. Reste à coordonner les sorties entre elles — c'est le volume suivant.This issue closed the volume on defer's most delicate faculty: taking back control of a panic, without betraying. Volume 4 gave recover's mechanics; this one gives the discipline. recover has a single good location, the boundary of a unit of work — request entry, goroutine top, plugin call — where you contain a failure so it doesn't contaminate the rest. The danger is never the panic, which is honest; it's the bare recover() that swallows its value, erases the trace, and lets the program continue corrupted. Recovering correctly is losing nothing: interrogate the value, which is an any; convert into an error what you recognize, via a named return; re-panic what you don't own, so as not to disguise a bug as an expected condition. And since a recover only covers its own stack, every spawned goroutine carries its own boundary — otherwise a single faulty one takes down the whole process. With defer to schedule the exit, the capture rule to know what you carry, and a boundary recover to isolate without masking, the volume covered the whole discipline of a function's exit. There remains coordinating the exits with one another — that's the next volume.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
La frontièreThe boundaryrecover à la frontière d'une unité — requête, goroutine, greffon — pas ailleurs.recover at a unit's boundary — request, goroutine, plugin — not elsewhere.Un try/catch dispersé qui masque au lieu d'isoler.A scattered try/catch that masks instead of isolating.
Ne pas masquerDon't maskJournalise la trace et convertis ; le recover() nu est proscrit.Log the trace and convert; the bare recover() is banned.Un bug effacé, un état corrompu qui poursuit sa route.An erased bug, a corrupt state continuing on its way.
Classer la valeurClassify the valueLa valeur est un any : convertis le connu, re-panique le reste.The value is an any: convert the known, re-panic the rest.Un nil deref déguisé en erreur métier attendue.A nil deref disguised as an expected business error.
Par goroutinePer goroutineChaque goroutine lancée porte sa propre frontière de recover.Every spawned goroutine carries its own recover boundary.Une goroutine fautive arrête le processus entier.One faulty goroutine stops the whole process.
Récupérer un panic n'est pas le faire taire. C'est l'amener à une frontière où l'échec peut être vu, tracé, et contenu — jamais effacé.Recovering a panic isn't silencing it. It's bringing it to a boundary where the failure can be seen, traced, and contained — never erased.
Mot de l'éditeur · clôture du volume 7From the editor · closing volume 7

Le volume 7 portait sur l'art de quitter une fonction. La vraie leçon : une sortie propre se prépare, elle ne s'improvise pas.Volume 7 was about the art of leaving a function. The real lesson: a clean exit is prepared, not improvised.

Trois numéros sur un même geste, regardé de plus en plus près : sortir d'une fonction. defer prépare la sortie en planifiant la libération à côté de l'acquisition, et garantit qu'elle aura lieu par n'importe quelle porte — retour ou panic. La règle de capture précise ce qu'on emporte dans cette sortie : un instantané figé à l'instant du defer, ou une fenêtre sur l'état final, selon qu'on passe un argument ou une fermeture. Et recover, à la frontière, décide de ce qu'on fait quand la sortie est une rupture plutôt qu'un retour : contenir l'échec sans le cacher. Ce qui relie les trois, c'est une idée discrète mais centrale : en Go, la fin d'une fonction n'est pas un simple point final, c'est un moment qui a sa propre logique, ses propres garanties, ses propres pièges. La plupart des langages traitent le nettoyage comme une corvée annexe ; Go en fait un citoyen de première classe, avec un mot-clé dédié et des règles précises. Maîtriser la sortie, c'est écrire des programmes qui ne fuient pas, ne mentent pas, et ne s'effondrent pas en chaîne — trois propriétés qu'on ne remarque que par leur absence.Three issues on the same gesture, looked at ever more closely: leaving a function. defer prepares the exit by scheduling the release next to the acquisition, and guarantees it happens through any door — return or panic. The capture rule clarifies what you carry into that exit: a snapshot frozen at the instant of defer, or a window onto the final state, depending on whether you pass an argument or a closure. And recover, at the boundary, decides what you do when the exit is a rupture rather than a return: contain the failure without hiding it. What links the three is a quiet but central idea: in Go, a function's end isn't a mere full stop, it's a moment with its own logic, its own guarantees, its own traps. Most languages treat cleanup as a side chore; Go makes it a first-class citizen, with a dedicated keyword and precise rules. Mastering the exit is writing programs that don't leak, don't lie, and don't collapse in a chain — three properties you only notice by their absence.

Mais tout ce qu'on a vu reste local : une fonction, une goroutine, qui gère sa propre fin. Le prochain volume change d'échelle et passe du local au distribué. Un vrai programme concurrent n'est pas une fonction, c'est un arbre de goroutines — un handler qui appelle un service qui interroge une base, chacun sur sa pile, tous lancés pour une même tâche. Quand cette tâche doit cesser — la requête est annulée, le délai expire, l'utilisateur part — il ne suffit pas que la fonction du sommet sorte proprement ; il faut que le signal d'arrêt descende jusqu'à la dernière goroutine, et que chacune l'entende et se range. recover protège une pile, defer nettoie une fonction ; aucun des deux ne sait parler à un arbre. L'outil qui porte ce signal vers le bas, de couche en couche, c'est context.Context — le câble d'annulation que tout programme Go sérieux fait passer du handler HTTP jusqu'à la requête SQL. On quitte la sortie d'une fonction pour l'arrêt coordonné de tout un arbre de travail. Vol. 8 №01 — context.Context, l'annulation qui descend.But everything we've seen stays local: one function, one goroutine, handling its own end. The next volume shifts scale and moves from the local to the distributed. A real concurrent program isn't a function, it's a tree of goroutines — a handler calling a service querying a database, each on its stack, all launched for one task. When that task must cease — the request canceled, the deadline expired, the user gone — it's not enough for the top function to exit cleanly; the stop signal must flow down to the last goroutine, and each must hear it and fall in line. recover protects one stack, defer cleans one function; neither knows how to speak to a tree. The tool carrying that signal downward, layer by layer, is context.Context — the cancellation cable every serious Go program threads from the HTTP handler down to the SQL query. We leave a function's exit for the coordinated stop of a whole tree of work. Vol. 8 №01 — context.Context, cancellation flowing down.