panic / recover, la frontière panic / recover, the boundary

panic n'est pas un try/catch : on panique quand un invariant est rompu, pas pour une erreur attendue. recover ne se pose qu'à la lisière — une requête, une goroutine — et un panic non rattrapé emporte tout le process. panic isn't a try/catch: you panic when an invariant breaks, not for an expected error. recover sits only at the boundary — a request, a goroutine — and an uncaught panic takes the whole process down.

Audience
Dev tenté d'utiliser panic/recover comme un try/catch, surpris qu'une goroutine non gardée tue tout Dev tempted to use panic/recover as a try/catch, surprised an unguarded goroutine kills everything
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●●○
Date
Mai 2027 May 2027

panicrecoverInvariants

SommaireContents ·
№ 01CadrageFraming3 min

panic n'est pas le try/catch de Go. C'est la ligne où la valeur cesse.panic isn't Go's try/catch. It's the line where the value stops.

Tout le volume a tenu une promesse : l'échec est une valeur qu'on rend, qu'on teste, qu'on enveloppe. panic semble la rompre — il déroule la pile, saute par-dessus le code, ressemble à s'y méprendre à l'exception qu'on disait absente. C'est un piège de lecture. panic et error ne sont pas deux outils pour le même travail ; ils répondent à deux registres incompatibles. Une error est un échec attendu : le fichier manquant, la connexion perdue, l'entrée malformée. Le programme a prévu ce cas, et l'appelant peut décider quoi en faire. Un panic est un échec impossible : un invariant rompu, un état qui ne devait jamais exister, un bug du programme contre lui-même. Là, il n'y a rien à décider — l'appelant ne peut pas « gérer » un programme devenu incohérent. La règle tient en une question : est-ce une situation que le code aurait dû anticiper, ou la preuve qu'il est déjà cassé ? La première se rend. La seconde panique.The whole volume kept one promise: failure is a value you return, test, wrap. panic seems to break it — it unwinds the stack, leaps over code, looks exactly like the exception we said was absent. That's a reading trap. panic and error aren't two tools for the same job; they answer two incompatible registers. An error is an expected failure: the missing file, the lost connection, the malformed input. The program planned for this case, and the caller can decide what to do. A panic is an impossible failure: a broken invariant, a state that should never have existed, a bug of the program against itself. There, there's nothing to decide — the caller can't 'handle' a program gone incoherent. The rule fits in one question: is this a situation the code should have anticipated, or proof that it's already broken? The first is returned. The second panics.

L'échec attendu : une valeur que l'appelant gèreThe expected failure: a value the caller handles
// échec ATTENDU : le fichier peut ne pas exister. C'est une valeur.
f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("open %s: %w", path, err)   // on REND l'erreur
}
// l'appelant DÉCIDE : réessayer, valeur par défaut, abandonner.
L'échec impossible : un invariant rompu, on s'arrêteThe impossible failure: a broken invariant, you stop
// échec IMPOSSIBLE : cet index est censé être valide, toujours.
// s'il ne l'est pas, c'est un BUG du programme, pas une entrée invalide.
i := id % len(s.shards)        // invariant : i est forcément dans les bornes
shard := s.shards[i]
if shard == nil {
    panic("shard nil : invariant rompu")   // rien à RENDRE — on STOPPE
}
// personne ne peut « gérer » un programme incohérent avec lui-même.
Deux registres, jamais interchangeablesTwo registers, never interchangeable
error
échec attendu
l'appelant décide
|
panic
invariant rompu
le programme s'arrête

La frontière n'est pas technique, elle est sémantique : qui peut décider de la suite ? Si quelqu'un, en amont, peut raisonnablement réagir, c'est une error. Si la seule réponse sensée est « ce programme a un bug, arrête-toi », c'est un panic.The boundary isn't technical, it's semantic: who can decide what comes next? If someone, upstream, can reasonably react, it's an error. If the only sane answer is "this program has a bug, stop," it's a panic.

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

« Une entrée invalide se rend ; un programme invalide panique. » Le débutant venu d'un langage à exceptions a le réflexe inverse : paniquer pour tout échec, rattraper partout. Le numéro défend la discipline opposée — panic est rare, réservé à l'irrécupérable : un index hors bornes, un nil qui ne devait jamais l'être, une assertion de programme. Pour tout le reste, il y a la valeur qu'on rend."Invalid input is returned; an invalid program panics." The beginner from an exception language has the opposite reflex: panic on every failure, catch everywhere. The issue argues the opposite discipline — panic is rare, reserved for the unrecoverable: an out-of-bounds index, a nil that should never have been, a program assertion. For everything else, there's the value you return.

Le runtime panique déjà pour toi.The runtime already panics for you.

Tu n'as souvent même pas besoin d'écrire panic : le runtime le fait à ta place quand un invariant fondamental casse. Accéder à un index hors bornes, déréférencer un pointeur nil, diviser par zéro, écrire dans une map nil — autant de panics levés par le langage lui-même. Ce ne sont pas des erreurs que tu aurais dû renvoyer : ce sont des bugs, signalés bruyamment plutôt que masqués. C'est cohérent avec tout le reste du langage : Go préfère un crash net, localisé, à un comportement indéfini qui pourrirait en silence. Quand tu écris panic toi-même, tu ne fais qu'étendre ce mécanisme à tes propres invariants.You often don't even need to write panic: the runtime does it for you when a fundamental invariant breaks. Indexing out of bounds, dereferencing a nil pointer, dividing by zero, writing to a nil map — all panics raised by the language itself. These aren't errors you should have returned: they're bugs, signaled loudly rather than hidden. It fits the rest of the language: Go prefers a clean, localized crash to undefined behavior rotting in silence. When you write panic yourself, you're just extending that mechanism to your own invariants.

№ 02La surpriseThe surprise4 min

Tu ne peux pas rattraper le panic d'une autre goroutine. Un seul oubli, et tout le process meurt.You can't catch another goroutine's panic. One miss, and the whole process dies.

Le réflexe venu des exceptions, c'est d'entourer le programme d'un grand filet et de dormir tranquille. En Go, ce filet a deux limites que personne ne voit venir. La première : recover ne fonctionne qu'à l'intérieur d'une fonction différée. Appelé ailleurs — directement dans le corps d'une fonction — il rend nil et ne rattrape rien. La seconde, plus brutale : un recover ne protège que sa propre goroutine. Le panic ne traverse pas les frontières entre goroutines ; il déroule la pile de celle où il est né, et si aucun defer de cette pile ne le rattrape, le runtime arrête le programme entier — pas seulement la goroutine fautive. Lance mille goroutines, oublie le recover dans une seule, et son panic emporte les neuf cent quatre-vingt-dix-neuf autres avec lui. C'est le revers du modèle : chaque goroutine est responsable de ses propres ruptures, parce que personne d'autre ne peut l'être à sa place.The reflex from exceptions is to wrap the program in one big net and sleep easy. In Go, that net has two limits nobody sees coming. The first: recover only works inside a deferred function. Called anywhere else — directly in a function's body — it returns nil and catches nothing. The second, more brutal: a recover protects only its own goroutine. A panic doesn't cross goroutine boundaries; it unwinds the stack of the one where it was born, and if no defer on that stack catches it, the runtime stops the entire program — not just the offending goroutine. Launch a thousand goroutines, forget the recover in just one, and its panic takes the other nine hundred ninety-nine with it. That's the flip side of the model: each goroutine owns its own ruptures, because no one else can.

Le recover de main ne voit pas la goroutinemain's recover can't see the goroutine
func main() {
    defer func() {
        if r := recover(); r != nil {       // on croit se protéger…
            log.Println("rattrapé:", r)
        }
    }()

    go worker()                  // … mais le panic naît dans une AUTRE goroutine
    time.Sleep(time.Second)
}

func worker() {
    panic("boom")     // ce panic n'atteint JAMAIS le recover de main.
}                     // il déroule la pile de worker, ne trouve rien → tout le process meurt.

Le defer de main paraît blinder le programme — il n'en protège que la goroutine principale. Le panic de worker vit sur une autre pile ; en la déroulant sans trouver de recover, le runtime conclut qu'un panic non rattrapé existe, et termine le process complet, main compris. C'est la trahison la plus coûteuse pour qui vient de Java ou Python : là-bas, un thread qui plante ne tue pas les autres. Ici, une goroutine non gardée tue le programme.main's defer looks like it armors the program — it only protects the main goroutine. worker's panic lives on another stack; unwinding it without finding a recover, the runtime concludes an unrecovered panic exists, and terminates the whole process, main included. It's the costliest betrayal for someone from Java or Python: there, a crashing thread doesn't kill the others. Here, one unguarded goroutine kills the program.

recover hors d'un defer ne fait rienrecover outside a defer does nothing

Pourquoi ce couplage à defer ? Parce que recover n'a de sens qu'au moment où la pile se déroule, et le seul code qui s'exécute pendant ce déroulement, ce sont les fonctions différées. Appelé n'importe où ailleurs, recover rend nil : il n'y a pas de panic à intercepter à cet instant. La forme canonique est donc invariable — defer func() { ... recover() ... }() — et toute tentative de la simplifier en appelant recover directement échoue en silence. recover n'est pas une instruction qu'on place où l'on veut : c'est une opération qui ne vit que dans la fenêtre étroite du déroulement de pile.Why the coupling to defer? Because recover only makes sense at the moment the stack unwinds, and the only code that runs during that unwinding is deferred functions. Called anywhere else, recover returns nil: there's no panic to intercept at that instant. So the canonical form is invariable — defer func() { ... recover() ... }() — and any attempt to simplify it by calling recover directly fails silently. recover isn't a statement you place wherever you like: it's an operation that lives only in the narrow window of stack unwinding.

Un thread qui plante, ailleurs, ne tue que lui-même. Une goroutine non gardée tue le programme entier.A crashing thread, elsewhere, kills only itself. An unguarded goroutine kills the entire program.
№ 03La mécaniqueThe mechanics5 min

Un panic ne saute pas : il déroule. Chaque defer s'exécute en chemin — c'est là qu'on l'arrête.A panic doesn't jump: it unwinds. Each defer runs on the way — that's where you stop it.

Le panic a l'air d'un saut, comme un throw qui atterrit dans un catch lointain. Le mécanisme réel est plus ordonné. Quand panic est appelé, la fonction courante s'arrête, mais avant de rendre la main, Go exécute toutes ses fonctions différées. Puis il remonte d'un cran, exécute les defer de l'appelant, et continue ainsi, de pile en pile, du plus profond vers le plus haut. C'est un déroulement contrôlé, pas une téléportation : tes defer — fermetures de fichiers, libérations de verrous — tournent tous, dans l'ordre inverse de leur déclaration. C'est dans cette fenêtre, et seulement là, que recover entre en jeu. Appelé depuis une fonction différée pendant le déroulement, il intercepte le panic en cours, rend la valeur qui lui a été passée, et stoppe net la remontée. L'exécution ne reprend pas où le panic a eu lieu : elle reprend après le defer qui a rattrapé, comme si la fonction s'était terminée normalement. La rupture, capturée à temps, redevient une valeur ordinaire.A panic looks like a jump, like a throw landing in a distant catch. The real mechanism is more orderly. When panic is called, the current function stops, but before yielding, Go runs all its deferred functions. Then it climbs one notch, runs the caller's defers, and continues this way, stack by stack, deepest to highest. It's a controlled unwinding, not a teleport: your defers — file closes, lock releases — all run, in reverse declaration order. It's in this window, and only there, that recover comes into play. Called from a deferred function during the unwinding, it intercepts the current panic, returns the value passed to it, and stops the climb cold. Execution doesn't resume where the panic happened: it resumes after the defer that caught it, as if the function had ended normally. The rupture, captured in time, becomes an ordinary value again.

La pile se déroule, B puis A, jusqu'au sommetThe stack unwinds, B then A, to the top
func process() {
    defer fmt.Println("A · defer de process")   // s'exécute en remontant
    risky()
    fmt.Println("jamais atteint si risky panique")
}

func risky() {
    defer fmt.Println("B · defer de risky")     // s'exécute aussi
    panic("boom")
}
// au panic : la pile se déroule. Chaque defer rencontré s'exécute,
// du plus profond au plus haut — B, puis A — jusqu'à un recover…
// … ou le sommet de la goroutine, et alors le crash.

Le code après risky() dans process n'est jamais atteint — mais le defer de process, lui, s'exécute. C'est la garantie cruciale : un panic n'annule pas tes defer, il les déclenche au contraire, en remontant. Tes verrous se libèrent, tes fichiers se ferment, même quand tout part en vrille. Sans recover sur le chemin, le déroulement va jusqu'au sommet de la goroutine, et le runtime imprime la pile et arrête le programme. Le panic est ordonné jusqu'au bout, y compris dans sa façon de tout faire crasher.The code after risky() in process is never reached — but process's defer does run. That's the crucial guarantee: a panic doesn't cancel your defers, it triggers them, on the way up. Your locks release, your files close, even when everything goes sideways. Without a recover on the path, the unwinding goes to the top of the goroutine, and the runtime prints the stack and stops the program. The panic is orderly to the end, including in how it crashes everything.

recover sans pouvoir gérer ? Re-panique.recover but can't handle? Re-panic.

Rattraper n'oblige pas à tout absorber. Un recover honnête inspecte la valeur reçue : si c'est un panic qu'il sait traiter — le sien, à une frontière qu'il contrôle — il le convertit en erreur. Sinon, il re-panique en rappelant panic(r), relançant le déroulement vers le haut. C'est essentiel : un recover qui avale tout, sans regarder, transforme un vrai bug — un nil déréférencé par mégarde — en erreur silencieuse, et te prive du crash qui te l'aurait signalé. Rattrape ce que tu comprends ; laisse remonter ce que tu ne comprends pas.Catching doesn't oblige you to absorb everything. An honest recover inspects the received value: if it's a panic it knows how to handle — its own, at a boundary it controls — it converts it to an error. Otherwise, it re-panics by calling panic(r) again, relaunching the climb upward. This is essential: a recover that swallows everything, unlooking, turns a real bug — a nil dereferenced by accident — into a silent error, and robs you of the crash that would have flagged it. Catch what you understand; let what you don't climb on.

La valeur d'un panic est un any.A panic's value is an any.

panic accepte n'importe quelle valeur — une chaîne, une erreur, un struct — et recover la rend comme un any. Tu retrouves là, exactement, le volume 3 : pour savoir ce qu'on a rattrapé, on fait une assertion de type sur cette valeur. r.(error), ou un type switch sur r, pour distinguer un panic volontaire de ton code d'un panic du runtime. La convention idiomatique est de paniquer avec une valeur qui implémente error, justement pour que le recover puisse l'inspecter proprement. La boucle se referme : même au bord de la rupture, le réflexe Go reste le même — une valeur, son type, et ce qu'on peut en lire.panic accepts any value — a string, an error, a struct — and recover returns it as an any. There you find, exactly, Volume 3: to know what you caught, you type-assert on that value. r.(error), or a type switch on r, to tell a deliberate panic from your code apart from a runtime panic. The idiomatic convention is to panic with a value implementing error, precisely so recover can inspect it cleanly. The loop closes: even at the edge of rupture, the Go reflex stays the same — a value, its type, and what you can read from it.

Le panic déroule la pile et exécute tes defer en chemin. recover est le seul à pouvoir l'arrêter — et seulement de l'intérieur d'un defer.The panic unwinds the stack and runs your defers on the way. recover alone can stop it — and only from inside a defer.
№ 04Le piègeThe trap4 min

Le piège n'est pas de paniquer. C'est de rattraper trop large — et de masquer les vrais bugs.The trap isn't panicking. It's catching too wide — and hiding the real bugs.

Une fois recover compris, la tentation est de s'en servir comme d'un try/catch : paniquer pour remonter vite, rattraper tout en haut, et se débarrasser des if err != nil. Ça marche, et c'est précisément le danger. Deux pièges se referment. Le premier : un recover fourre-tout, qui rend err = fmt.Errorf de n'importe quoi, ne distingue plus le panic que tu as voulu — l'entrée invalide — du panic que tu n'as pas vu venir — un nil déréférencé trois fonctions plus bas. Il transforme un bug bruyant en erreur silencieuse, et tu perds le crash qui t'aurait mené droit à la cause. Le second, à l'inverse : laisser un panic interne franchir la frontière de ton paquet, infligeant à tes appelants un crash là où ils attendaient une valeur. La discipline résout les deux d'un même geste. À l'intérieur d'un paquet, panic est un raccourci légitime pour sortir d'une récursion profonde. À sa frontière, un seul recover, qui rattrape uniquement ton type de panic à toi, le convertit en error, et re-propage tout le reste. Le crash reste un crash pour les vrais bugs ; l'appelant ne voit jamais que des valeurs.Once recover is understood, the temptation is to use it as a try/catch: panic to climb fast, catch at the very top, and be rid of if err != nil. It works, and that's precisely the danger. Two traps close. The first: a catch-all recover, returning err = fmt.Errorf of anything, no longer telling apart the panic you wanted — invalid input — from the panic you didn't see coming — a nil dereferenced three functions down. It turns a loud bug into a silent error, and you lose the crash that would have led you straight to the cause. The second, conversely: letting an internal panic cross your package boundary, inflicting on your callers a crash where they expected a value. The discipline solves both in one move. Inside a package, panic is a legitimate shortcut to escape deep recursion. At its boundary, a single recover, catching only your own panic type, converts it to an error, and re-propagates everything else. The crash stays a crash for real bugs; the caller only ever sees values.

Rattraper tout, c'est masquer les vrais bugsCatching everything hides the real bugs
// ANTI-PATTERN : panic/recover comme flot de contrôle, pour fuir les if err
func parseAll(items []string) (out []int, err error) {
    defer func() {
        if r := recover(); r != nil {   // recover FOURRE-TOUT
            err = fmt.Errorf("%v", r)    // avale le panic d'entrée…
        }                                // … comme un vrai bug (nil deref ailleurs)
    }()
    for _, s := range items {
        out = append(out, mustParse(s))  // mustParse panique au lieu de rendre
    }
    return out, nil
}
// le recover trop large ne distingue plus l'erreur attendue du bug : il les masque tous deux.

Le code paraît élégant — plus de if err dans la boucle, tout est centralisé. Mais le recover ne regarde pas ce qu'il rattrape. Le jour où mustParse, ou n'importe quelle fonction qu'il appelle, déréférence un nil par erreur, ce panic-là aussi devient un err poli, remonté comme si de rien n'était. Tu as échangé une erreur de programmation contre une erreur de données, et personne ne le saura. Le panic existait pour rendre les bugs visibles ; un recover aveugle les rend invisibles.The code looks elegant — no more if err in the loop, everything centralized. But the recover doesn't look at what it catches. The day mustParse, or any function it calls, dereferences a nil by mistake, that panic too becomes a polite err, propagated as if nothing happened. You've swapped a programming error for a data error, and no one will know. Panic existed to make bugs visible; a blind recover makes them invisible.

Must : paniquer, mais au démarrage seulementMust: panic, but at startup only

Il reste un endroit où paniquer franchement est idiomatique : l'initialisation. regexp.MustCompile, template.Must — la convention MustXxx panique si son argument est invalide, parce qu'une regex codée en dur qui ne compile pas est un bug de programmeur, pas une donnée d'exécution. Et ça arrive au démarrage, avant que le programme ne serve quoi que ce soit. Échouer vite et fort y est préférable à propager une error que personne ne saurait gérer. La règle générale tient : panic pour ce qui doit empêcher le programme d'exister ; error pour ce qu'il rencontrera en vivant.One place remains where panicking outright is idiomatic: initialization. regexp.MustCompile, template.Must — the MustXxx convention panics if its argument is invalid, because a hard-coded regex that won't compile is a programmer bug, not runtime data. And it happens at startup, before the program serves anything. Failing fast and loud there beats propagating an error no one could handle. The general rule holds: panic for what must prevent the program from existing; error for what it'll meet while living.

Le volume se clôt, le suivant change de plan.The volume closes, the next changes plane.

Quatre volumes durant, on a suivi le contrôle : comment il passe d'une goroutine à l'autre par les channels, comment la propriété décide qui ferme et qui parle, comment les interfaces déplacent les décisions, comment l'erreur — et maintenant le panic — trace la limite de ce qui se rend et de ce qui s'arrête. On a parlé de mouvement. Le volume 5 change de question : non plus comment le contrôle circule, mais comment les données, elles, sont posées en mémoire. Ça commence par l'objet le plus quotidien et le plus mécompris de Go — la slice, qui n'est pas un tableau mais une vue sur un tableau, trois mots qui en cachent un quatrième. Vol. 5 №01 — La slice, une vue sur un tableau.For four volumes, we followed control: how it passes between goroutines through channels, how ownership decides who closes and who speaks, how interfaces move decisions, how the error — and now the panic — draws the line between what's returned and what stops. We talked about movement. Volume 5 changes the question: no longer how control flows, but how data itself is laid in memory. It starts with Go's most everyday and most misunderstood object — the slice, which isn't an array but a view over an array, three words hiding a fourth. Vol. 5 №01 — The slice, a view over an array.

Un recover qui rattrape tout ment sur l'état du programme. Ne rattrape que ce que tu as toi-même jeté ; laisse les vrais bugs crasher.A recover that catches everything lies about the program's state. Catch only what you threw yourself; let real bugs crash.
№ 05Bilan & éditoWrap-up & editorial2 min

Le volume disait : l'échec est une valeur. panic est la ligne où cette phrase s'arrête.The volume said: failure is a value. panic is the line where that sentence stops.

Ce numéro ferme le volume des erreurs en en traçant la limite. panic n'est pas le try/catch de Go : c'est le geste réservé à l'invariant rompu, au bug du programme contre lui-même, là où il n'y a plus rien à décider. recover ne vit que dans un defer, ne protège que sa propre goroutine — un oubli, et tout le process meurt. Le panic ne saute pas, il déroule la pile en exécutant tes defer, et recover ne l'arrête qu'en convertissant la rupture en valeur. Enfin, la discipline : rattraper trop large masque les vrais bugs ; à la frontière d'un paquet, on ne rattrape que le sien, on re-propage le reste. Le fil du volume tient jusqu'au bout — l'échec est une valeur qu'on rend, sauf quand il n'y a plus personne pour la recevoir.This issue closes the errors volume by drawing its limit. panic isn't Go's try/catch: it's the move reserved for the broken invariant, the program's bug against itself, where there's nothing left to decide. recover lives only in a defer, protects only its own goroutine — one miss, and the whole process dies. The panic doesn't jump, it unwinds the stack running your defers, and recover stops it only by converting the rupture into a value. Finally, the discipline: catching too wide hides the real bugs; at a package boundary, you catch only your own, re-propagate the rest. The volume's thread holds to the end — failure is a value you return, except when there's no one left to receive it.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
panic ≠ exceptionpanic ≠ exceptionPour un invariant rompu, un bug — pas un échec attendu.For a broken invariant, a bug — not an expected failure.Tu paniques pour une entrée invalide, et l'appelant ne peut rien gérer.You panic on invalid input, and the caller can handle nothing.
recover en deferrecover in a deferNe fonctionne que dans une fonction différée, pendant le déroulement.Only works in a deferred function, during the unwinding.recover appelé ailleurs rend nil, et le programme meurt quand même.recover called elsewhere returns nil, and the program dies anyway.
Une goroutine, un recoverOne goroutine, one recoverChaque goroutine garde la sienne ; le panic ne traverse pas.Each goroutine guards its own; the panic doesn't cross.Un panic dans une goroutine non protégée emporte tout le process.A panic in an unguarded goroutine takes the whole process down.
La frontièreThe boundaryRattrape ton type de panic, convertis en error, re-propage le reste.Catch your panic type, convert to error, re-propagate the rest.Un recover fourre-tout transforme un vrai bug en erreur silencieuse.A catch-all recover turns a real bug into a silent error.
Une error, c'est dire à l'appelant : « à toi de décider ». Un panic, c'est admettre qu'il n'y a plus rien à décider.An error tells the caller: "your call." A panic admits there's nothing left to decide.
Mot de l'éditeurFrom the editor

Quatre volumes pour suivre le contrôle. Le prochain regarde, enfin, ce que le contrôle déplace.Four volumes following control. The next, at last, looks at what control moves.

On peut relire toute la série comme une seule enquête sur le mouvement. Le volume 1 demandait comment une valeur passe d'une goroutine à l'autre — le channel. Le volume 2, qui décide de ce passage — la propriété, fermer, diffuser. Le volume 3, comment une décision se déplace sans connaître son destinataire — l'interface implicite. Le volume 4, ce qui arrive quand le mouvement échoue — l'erreur qu'on rend, qu'on enveloppe, qu'on déroule, et le panic qui marque la limite où il n'y a plus de valeur à transmettre. Quatre angles sur une même chose : comment le contrôle circule dans un programme Go. À chaque fois, la même réponse de fond — il circule explicitement, dans la main, sans magie. Le panic était le dernier mot de cette grammaire : même la rupture, en Go, est ordonnée, visible, et reconvertible en valeur.You can reread the whole series as a single inquiry into movement. Volume 1 asked how a value passes from one goroutine to another — the channel. Volume 2, who decides that passage — ownership, closing, broadcasting. Volume 3, how a decision moves without knowing its recipient — the implicit interface. Volume 4, what happens when the movement fails — the error you return, wrap, unroll, and the panic marking the limit where there's no value left to pass. Four angles on one thing: how control flows through a Go program. Each time, the same underlying answer — it flows explicitly, in the hand, without magic. The panic was that grammar's last word: even rupture, in Go, is orderly, visible, and reconvertible into a value.

Mais le contrôle déplace toujours quelque chose — une valeur. Et c'est cette valeur qu'on a tenue pour acquise pendant quatre volumes : on a dit « une valeur passe », « une erreur est une valeur », sans jamais regarder ce qu'est, physiquement, une valeur en Go. Comment est-elle posée en mémoire ? Que copie-t-on vraiment quand on la passe ? Le volume 5 retourne le télescope : on quitte la circulation pour la matière. Et il commence par l'objet que tout le monde croit connaître et que presque personne ne se représente juste — la slice. Pas un tableau : une vue sur un tableau, trois mots — pointeur, longueur, capacité — dont la copie copie la vue et non les données. D'où la surprise fondatrice du volume : modifier une sous-slice modifie l'originale, parce que les deux regardent la même mémoire. Vol. 5 №01 — La slice, une vue sur un tableau. On a passé quatre volumes à déplacer des valeurs ; il est temps de voir de quoi elles sont faites.But control always moves something — a value. And that value is what we took for granted across four volumes: we said 'a value passes,' 'an error is a value,' without ever looking at what a value physically is in Go. How is it laid in memory? What do you really copy when you pass it? Volume 5 flips the telescope: we leave circulation for matter. And it begins with the object everyone thinks they know and almost no one pictures right — the slice. Not an array: a view over an array, three words — pointer, length, capacity — whose copy copies the view, not the data. Hence the volume's founding surprise: changing a sub-slice changes the original, because both look at the same memory. Vol. 5 №01 — The slice, a view over an array. We spent four volumes moving values; it's time to see what they're made of.