Une seule tension du modèle Go,
disséquée jusqu'à l'os. One tension in Go's model,
dissected to the bone.

Deux lettres — go — et une fonction part vivre sa vie en parallèle. Le code naïf croit avoir lancé un travail ; il a surtout perdu le fil. Si main finit avant elle, la goroutine meurt sans un mot. Lancer est trivial ; tout le modèle de Go tient dans la question d'après : qui l'attend ? Two letters — go — and a function leaves to live in parallel. Naive code thinks it started a job; mostly it lost the thread. If main finishes first, the goroutine dies without a word. Launching is trivial; all of Go's model lives in the next question: who waits for it?

Lancer N goroutines est facile ; savoir qu'elles ont toutes fini l'est moins. Le WaitGroup compte, attend, et te rend la main — à condition de l'incrémenter au bon endroit. Le piège classique : Add dans la boucle, et une variable capturée par référence. Launching N goroutines is easy; knowing they've all finished, less so. The WaitGroup counts, waits, and hands control back — provided you increment it in the right place. The classic trap: Add inside the loop, and a variable captured by reference.

Une goroutine bloquée sur un envoi que plus personne ne lit ne plante pas : elle reste, vivante et inutile, jusqu'à l'arrêt du process. La fuite la plus silencieuse de Go. On la voit, on la mesure, et on la ferme — par un channel de sortie ou un contexte. A goroutine blocked on a send nobody reads doesn't crash: it lingers, alive and useless, until the process dies. Go's quietest leak. We make it visible, measure it, and shut it down — with a done channel or a context.

Un channel n'est pas une file d'attente : c'est un point de rendez-vous où la propriété d'une donnée passe d'une goroutine à l'autre. Bufferisé ou non, c'est la même idée — envoyer plutôt que partager derrière un verrou. Le cœur du slogan : partage la mémoire en communiquant. A channel isn't a queue: it's a rendezvous where a value's ownership passes from one goroutine to another. Buffered or not, same idea — send rather than share behind a lock. The heart of the slogan: share memory by communicating.

Quand plusieurs channels parlent en même temps, select choisit celui qui est prêt. Avec default, il n'attend pas ; avec time.After, il pose un délai. Et un select{} sans cas, c'est le blocage éternel — parfois voulu, souvent un bug. When several channels speak at once, select picks the one that's ready. With default, it doesn't wait; with time.After, it sets a deadline. And a select{} with no case is an eternal block — sometimes intended, often a bug.

close ne détruit pas un channel : il annonce qu'il n'y aura plus rien. Tous les récepteurs en range sortent, tous les <-ch rendent la valeur nulle et ok=false. Mais envoyer sur un channel fermé panique — d'où la règle : seul l'émetteur ferme, jamais le récepteur. close doesn't destroy a channel: it announces nothing more is coming. Every range receiver exits, every <-ch returns the zero value and ok=false. But sending on a closed channel panics — hence the rule: only the sender closes, never the receiver.

En Go, un type satisfait une interface sans jamais le déclarer — il suffit qu'il ait les méthodes. L'abstraction appartient à celui qui consomme, pas à celui qui fournit. D'où la règle : accepte des interfaces, retourne des structs. In Go, a type satisfies an interface without ever declaring it — having the methods is enough. The abstraction belongs to the consumer, not the provider. Hence the rule: accept interfaces, return structs.

Un *T nil rangé dans une interface n'est pas == nil : l'interface porte un type, donc elle est non vide. Le piège trahit le réflexe le plus sacré de Go — if err != nil — et fait passer une erreur absente pour présente. On le voit, on l'explique, on l'évite. A nil *T stored in an interface is not == nil: the interface carries a type, so it's non-empty. The trap betrays Go's most sacred reflex — if err != nil — making an absent error look present. We make it visible, explain it, avoid it.

Une interface, c'est une paire (type, valeur). L'assertion x.(T) et le type switch la rouvrent ; le boxing et l'indirection la paient. Quand any sauve la mise, et quand il faut s'en passer. An interface is a (type, value) pair. The x.(T) assertion and the type switch reopen it; boxing and indirection pay for it. When any saves the day, and when to do without it.

Go n'a pas d'exceptions pour le flot normal : une erreur est une valeur, qu'on inspecte et qu'on propage à la main. La verbosité est le prix de l'explicite — et le _ = qui jette l'erreur est le seul vrai danger. Go has no exceptions for the normal path: an error is a value you inspect and propagate by hand. Verbosity is the price of being explicit — and the _ = that throws the error away is the only real danger.

fmt.Errorf("%w", err) emballe une erreur dans un contexte sans la perdre ; errors.Is et errors.As la retrouvent au fond de la pile. Sentinelle ou typée, l'essentiel est de ne jamais casser la chaîne. fmt.Errorf("%w", err) wraps an error in context without losing it; errors.Is and errors.As find it back at the bottom of the stack. Sentinel or typed, the point is never to break the chain.

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.

Une slice est trois mots — pointeur, longueur, capacité — posés sur un tableau. La copier copie la vue, pas les données. D'où la surprise : modifier b := a[1:3] modifie a, car les deux regardent le même tableau. A slice is three words — pointer, length, capacity — laid over an array. Copying it copies the view, not the data. Hence the surprise: changing b := a[1:3] changes a, because both look at the same array.

append écrit parfois en place, parfois dans un tableau tout neuf — selon la capacité restante. Tant qu'on partage le cap, deux slices se marchent dessus ; dès qu'on réalloue, elles divergent. Le bug le plus subtil de Go tient dans cette frontière. append sometimes writes in place, sometimes into a brand-new array — depending on remaining capacity. While the cap is shared, two slices clobber each other; once it reallocates, they diverge. Go's subtlest bug lives on that boundary.

L'itération d'une map est aléatoire par conception ; écrire dans une map nil panique ; lire et écrire en concurrence plante le programme avec un message sans appel. Trois garanties que Go refuse exprès — et ce qu'on met à la place. Map iteration is random by design; writing to a nil map panics; concurrent read-write crashes the program with a blunt message. Three guarantees Go deliberately refuses — and what you put in their place.

En Go, passer une valeur, c'est la copier — struct comprise, champ par champ. Parfois c'est un service (une copie ne peut pas être mutée ailleurs), parfois c'est un coût (une grosse struct recopiée à chaque appel). Savoir lequel, c'est tout l'art. In Go, passing a value copies it — structs included, field by field. Sometimes that's a gift (a copy can't be mutated elsewhere), sometimes a cost (a big struct re-copied on every call). Knowing which is the whole craft.

func (t T) ou func (t *T) ? Le receveur valeur travaille sur une copie et ne mute rien ; le receveur pointeur mute l'original. Le choix décide aussi du jeu de méthodes — et de ce qui satisfait une interface. func (t T) or func (t *T)? A value receiver works on a copy and mutates nothing; a pointer receiver mutates the original. The choice also decides the method set — and what satisfies an interface.

Copier une struct qui contient un sync.Mutex, c'est copier un verrou à moitié pris — et go vet te l'interdit pour de bonnes raisons. WaitGroup, slices partagées : certains types ne survivent pas à une copie. La règle copylocks, et pourquoi. Copying a struct that holds a sync.Mutex copies a half-held lock — and go vet forbids it for good reason. WaitGroup, shared slices: some types don't survive a copy. The copylocks rule, and why.

defer planifie du code pour la sortie de fonction, quelle que soit la sortie — en pile LIFO. On libère une ressource juste à côté de son acquisition. Reste un piège : l'erreur de defer f.Close() qu'on laisse filer sans la regarder. defer schedules code for the function's exit, whatever the exit — LIFO order. You free a resource right next to where you acquired it. One trap remains: the error from defer f.Close() that slips away unlooked-at.

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.

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.

context.Context est le câble qui traverse les couches : du handler HTTP jusqu'à la requête SQL. Premier argument, jamais stocké, toujours propagé. Quand le haut annule, tout ce qui en dépend l'apprend par Done(). context.Context is the cable threading through layers: from the HTTP handler down to the SQL query. First argument, never stored, always propagated. When the top cancels, everything below hears it through Done().

WithTimeout et WithDeadline posent une limite de temps à un arbre de goroutines. Le defer cancel() n'est pas optionnel : l'oublier, c'est fuir un contexte et les ressources qu'il tenait. Le délai qui descend, et le nettoyage qui remonte. WithTimeout and WithDeadline put a time limit on a tree of goroutines. The defer cancel() isn't optional: forgetting it leaks a context and the resources it held. The deadline flowing down, the cleanup flowing back up.

WithValue glisse une donnée dans le contexte — pratique, et dangereux. Clés typées, jamais une string nue ; un request ID y a sa place, une dépendance non. Le contexte n'est pas un sac à injection. WithValue slips a datum into the context — handy, and dangerous. Typed keys, never a bare string; a request ID belongs there, a dependency doesn't. The context is not an injection bag.

Le compilateur décide, seul, si une valeur vit sur la pile (gratuite) ou s'échappe vers le tas (allouée, ramassée plus tard). Retourner &x l'envoie au tas ; une interface peut l'y pousser aussi. -gcflags=-m te montre la décision. The compiler alone decides whether a value lives on the stack (free) or escapes to the heap (allocated, collected later). Returning &x sends it to the heap; an interface can push it there too. -gcflags=-m shows you the decision.

Le ramasse-miettes de Go est concurrent et discret — la bonne réponse est rarement de le tuner, presque toujours d'allouer moins. sync.Pool, mesures avant optimisation, pprof. On regarde le coût au lieu de l'imaginer. Go's garbage collector is concurrent and quiet — the right answer is rarely to tune it, almost always to allocate less. sync.Pool, measure before optimizing, pprof. We look at the cost instead of guessing it.

Des centaines de milliers de goroutines tiennent sur une poignée de threads OS — c'est le scheduler M:N qui les fait danser. GOMAXPROCS, préemption, et la vieille histoire de la goroutine en boucle serrée qui affamait les autres (et pourquoi c'est presque fini). Hundreds of thousands of goroutines ride on a handful of OS threads — the M:N scheduler makes them dance. GOMAXPROCS, preemption, and the old tale of the tight-loop goroutine that starved the others (and why that's nearly over).