La map, ni ordonnée ni concurrente The map, neither ordered nor concurrent

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.

Audience
Dev surpris par l'ordre d'itération aléatoire, le panic sur map nil, ou le crash concurrent Dev caught off guard by random iteration order, the nil-map panic, or the concurrent crash
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●●○○
Date
Août 2027 Aug 2027

MapsConcurrencenil

SommaireContents ·
№ 01CadrageFraming3 min

La slice te piège par ce qu'elle partage en silence. La map te piège par ce qu'elle refuse, ouvertement.The slice traps you by what it silently shares. The map traps you by what it openly refuses.

La map est l'autre pilier du modèle de données de Go, et on l'utilise chaque jour : une table de hachage qui associe des clés à des valeurs, avec une lecture et une écriture en temps constant. Mais là où la slice cachait son danger — un cap invisible, un tableau partagé sans le dire — la map affiche le sien. Elle refuse trois choses que la plupart des langages offrent par confort, et elle le fait sciemment, parfois brutalement. D'abord, elle n'ordonne pas ses clés : deux parcours de la même map peuvent te les rendre dans deux ordres différents, et c'est voulu. Ensuite, sa valeur zéro — une map nil — se laisse lire mais pas écrire : la moindre assignation panique. Enfin, elle interdit l'accès concurrent : si une goroutine lit pendant qu'une autre écrit, le runtime n'essaie pas de réparer, il arrête net le programme. Trois refus, trois surprises — mais aucune n'est un accident. Chacune protège une vérité que d'autres langages préfèrent te cacher : sur le hachage, sur l'initialisation, sur la concurrence. Ce numéro prend les refus un par un, et montre ce qu'on met à la place.The map is the other pillar of Go's data model, and you use it every day: a hash table mapping keys to values, with constant-time read and write. But where the slice hid its danger — an invisible cap, an array shared without saying so — the map flaunts its own. It refuses three things most languages offer for comfort, and it does so knowingly, sometimes brutally. First, it doesn't order its keys: two passes over the same map can return them in two different orders, and that's intended. Second, its zero value — a nil map — can be read but not written: the slightest assignment panics. Third, it forbids concurrent access: if one goroutine reads while another writes, the runtime doesn't try to repair, it stops the program outright. Three refusals, three surprises — but none is an accident. Each protects a truth other languages prefer to hide from you: about hashing, about initialization, about concurrency. This issue takes the refusals one by one, and shows what you put in their place.

Les trois refus, en une vueThe three refusals, at a glance
m := map[string]int{"a": 1, "b": 2}   // une table de hachage, prête

// 1. l'ordre d'itération est tiré au hasard à chaque parcours
for k := range m { use(k) }           // "a","b" ? "b","a" ? jamais garanti

// 2. sa valeur zéro est nil — lisible, mais pas inscriptible
var z map[string]int                  // nil
z["x"] = 1                            // panic: assignment to entry in nil map

// 3. lue ET écrite par deux goroutines en même temps :
//    fatal error: concurrent map read and map write  ← le runtime te tue
Trois refus, trois vérités gardéesThree refusals, three guarded truths
refus 1
l'ordre
le hachage n'a pas d'ordre — et Go t'empêche d'en inventer un
refus 2
la map nil
écrire exige une structure allouée — make, ou littéral
refus 3
la concurrence
une map n'est pas thread-safe — protège-la, ou choisis autre chose

Aucun de ces refus n'est un oubli. Chacun rend visible une contrainte réelle que d'autres langages masquent — au prix d'un ordre illusoire, d'une initialisation magique, ou d'une corruption silencieuse. La map de Go préfère te dire non tout de suite.None of these refusals is an oversight. Each makes a real constraint visible that other languages mask — at the cost of an illusory order, a magic initialization, or a silent corruption. Go's map prefers to say no up front.

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

« Une map refuse exprès ; chaque refus garde une vérité — et m'indique quoi faire à la place. » On ne combat pas ces refus, on les lit. L'ordre ? trie les clés. La map nil ? alloue-la. La concurrence ? verrouille, ou prends un type fait pour ça. Trois surprises au premier contact, trois automatismes ensuite. Le numéro déplie chacune jusqu'à ce qu'elle devienne évidente."A map refuses on purpose; each refusal guards a truth — and tells me what to do instead." You don't fight these refusals, you read them. Order? sort the keys. Nil map? allocate it. Concurrency? lock it, or take a type built for it. Three surprises on first contact, three reflexes afterward. The issue unfolds each until it becomes obvious.

Pourquoi une table de hachage refuse l'ordreWhy a hash table refuses order

Une map range ses clés selon leur hachage : un nombre calculé à partir de la clé, qui détermine dans quel « casier » (bucket) elle atterrit. Cet emplacement n'a rien à voir avec l'ordre d'insertion, ni avec un quelconque tri — c'est une dispersion, faite pour répartir uniformément, pas pour ranger. Quand la map grandit, elle réorganise ses casiers, et les positions changent encore. Il n'existe donc pas d'ordre « naturel » à exposer : tout ordre qu'on observerait serait un artefact de l'implémentation du moment. Go pousse la logique au bout — il randomise volontairement le point de départ du parcours — pour t'interdire de t'appuyer sur un ordre qui n'existe pas vraiment.A map arranges its keys by their hash: a number computed from the key, deciding which 'bucket' it lands in. That spot has nothing to do with insertion order, nor with any sorting — it's a dispersion, made to spread evenly, not to arrange. When the map grows, it reorganizes its buckets, and positions shift again. So there's no 'natural' order to expose: any order you'd observe would be an artifact of the current implementation. Go takes the logic to its end — it deliberately randomizes the iteration's starting point — to forbid you from leaning on an order that doesn't truly exist.

№ 02La surpriseThe surprise4 min

Deux parcours de la même map te rendent les clés dans deux ordres différents. Ce n'est pas un bug — c'est volontaire.Two passes over the same map hand you the keys in two different orders. It's not a bug — it's deliberate.

La première surprise frappe dès qu'on affiche le contenu d'une map dans une boucle : l'ordre semble aléatoire. Et il l'est, littéralement. Là où d'autres langages te donnent l'ordre d'insertion, ou un ordre trié, ou simplement un ordre stable d'un parcours à l'autre, Go ne te promet rien — et va plus loin : il randomise activement le point de départ de chaque range sur une map. Lance deux fois le même programme, sur la même map, et tu obtiendras potentiellement deux ordres distincts. Ce n'est pas une négligence ; c'est une décision de conception, prise tôt et tenue fermement. Le but est pédagogique autant que technique : empêcher le moindre code de dépendre, par accident, d'un ordre qui n'est pas garanti. Car un ordre d'itération qui « marche » par hasard est une bombe à retardement — il tient jusqu'à ce que la map grandisse, qu'on change de version de Go, ou qu'un détail d'implémentation bouge, et alors un code lointain casse sans raison apparente. En te montrant le désordre tout de suite, à chaque exécution, Go t'interdit d'écrire ce bug. Si tu veux un ordre, tu dois le demander.The first surprise hits the moment you print a map's contents in a loop: the order looks random. And it is, literally. Where other languages give you insertion order, or a sorted order, or simply a stable order from one pass to the next, Go promises nothing — and goes further: it actively randomizes the starting point of each range over a map. Run the same program twice, on the same map, and you may get two distinct orders. This isn't negligence; it's a design decision, taken early and held firmly. The goal is pedagogical as much as technical: to stop any code from accidentally depending on an order that isn't guaranteed. Because an iteration order that 'works' by chance is a time bomb — it holds until the map grows, until you change Go versions, or until an implementation detail shifts, and then some distant code breaks for no apparent reason. By showing you the disorder right away, on every run, Go forbids you from writing that bug. If you want an order, you must ask for it.

Parcours direct : un ordre différent à chaque lancementDirect range: a different order each run
m := map[string]int{"alice": 1, "bob": 2, "carol": 3}

for k, v := range m {
    fmt.Println(k, v)
}
// exécution 1 :          exécution 2 :         exécution 3 :
//   carol 3                bob 2                 alice 1
//   alice 1                carol 3               carol 3
//   bob 2                  alice 1               bob 2
// MÊME map, MÊME binaire — l'ordre change à chaque lancement. Voulu.

Le piège n'est pas que l'ordre soit aléatoire — c'est qu'on l'oublie. On code un parcours, on teste une fois, l'ordre « tombe bien », et on tient pour acquis ce que Go n'a jamais promis. Afficher les paires d'une map dans l'ordre du range pour comparer deux sorties, écrire un test qui attend une ligne en premier, construire une chaîne en concaténant les valeurs — autant de bugs qui passent mille fois puis échouent une. Go randomise précisément pour que cette « mille et unième » fois arrive dès la deuxième exécution, sous tes yeux, et non en production.The trap isn't that the order is random — it's that you forget it. You code a loop, you test once, the order "comes out nicely," and you take for granted what Go never promised. Printing a map's pairs in range order to compare two outputs, writing a test that expects one line first, building a string by concatenating values — each a bug that passes a thousand times then fails once. Go randomizes precisely so that this "thousand-and-first" time happens on the second run, before your eyes, not in production.

Un refus qui te protège d'un bug futurA refusal that shields you from a future bug

Compare avec la slice : son danger se cachait derrière un cap invisible, et ne se révélait qu'à certaines tailles d'entrée. Le désordre de la map fait l'inverse — il s'expose à chaque exécution, le plus tôt possible. C'est une philosophie de conception cohérente : rendre les erreurs probables visibles tôt plutôt que rares et tardives. Un ordre stable « gratuit » t'aurait laissé construire une dépendance fragile sans le savoir ; le désordre forcé te l'interdit le deuxième jour. Le refus n'est pas une limite de la map — c'est un garde-fou qu'on a mis là pour toi.Compare with the slice: its danger hid behind an invisible cap, surfacing only at certain input sizes. The map's disorder does the opposite — it exposes itself on every run, as early as possible. It's a coherent design philosophy: make likely errors visible early rather than rare and late. A "free" stable order would have let you build a fragile dependency without knowing; the forced disorder forbids it on day two. The refusal isn't a limit of the map — it's a guardrail put there for you.

Go ne te cache pas que le hachage est désordonné. Il te le montre à chaque lancement — pour que tu n'en dépendes jamais par accident.Go doesn't hide that hashing is unordered. It shows you on every run — so you never depend on it by accident.
№ 03La mécaniqueThe mechanics5 min

Une map nil se laisse lire comme une map vide. La première écriture, elle, panique.A nil map lets you read it like an empty map. The first write, though, panics.

Le deuxième refus tient à la valeur zéro de la map. Déclarer var m map[string]int ne crée pas une map vide : ça crée une map nil — un en-tête qui ne pointe vers aucune structure de hachage, aucun casier. Et Go traite cette map nil de façon asymétrique, ce qui déroute au début mais suit une logique stricte. En lecture, tout est permis : interroger une clé rend la valeur zéro du type, len vaut 0, un range ne tourne pas, et rien ne panique. Une map nil se comporte exactement comme une map vide en lecture seule — un choix de confort qui évite mille tests nil défensifs. En écriture, c'est l'inverse : la moindre assignation m[k] = v panique avec « assignment to entry in nil map ». La raison est physique. Lire une clé absente peut se résoudre sans rien stocker : on renvoie le zéro. Mais écrire exige une place où ranger la paire — un casier dans une table allouée — et cette table n'existe pas encore. Go pourrait l'allouer à la volée, comme il le fait pour append sur une slice nil ; il a choisi de ne pas le faire, et de te forcer à initialiser explicitement. Le contraste avec la slice est frappant et instructif : append(nilSlice, x) marche, m[k] = v sur une map nil panique.The second refusal lies in the map's zero value. Declaring var m map[string]int doesn't create an empty map: it creates a nil map — a header pointing at no hash structure, no bucket. And Go treats this nil map asymmetrically, which disorients at first but follows a strict logic. On reading, everything is allowed: querying a key returns the type's zero value, len is 0, a range doesn't run, and nothing panics. A nil map behaves exactly like an empty map, read-only — a comfort choice that spares a thousand defensive nil checks. On writing, it's the reverse: the slightest assignment m[k] = v panics with 'assignment to entry in nil map.' The reason is physical. Reading an absent key can resolve without storing anything: you return the zero. But writing requires a place to store the pair — a bucket in an allocated table — and that table doesn't exist yet. Go could allocate it on the fly, as it does for append on a nil slice; it chose not to, and to force you to initialize explicitly. The contrast with the slice is striking and instructive: append(nilSlice, x) works, m[k] = v on a nil map panics.

Lecture d'une map nil : comme une map videReading a nil map: like an empty map
var m map[string]int        // valeur zéro : nil, AUCUN casier alloué

v := m["absente"]           // 0  — lire une clé absente rend la valeur zéro
v, ok := m["absente"]       // 0, false  — ok distingue « absente » de « = 0 »
n := len(m)                 // 0
for k := range m { use(k) } // ne tourne pas une seule fois
// lire une map nil ne panique JAMAIS : elle se comporte comme une map vide.

Cette tolérance en lecture est précieuse : une fonction qui reçoit une map peut la parcourir sans vérifier qu'elle est non-nil, et un champ map jamais initialisé se lit sans planter. Note au passage l'idiome v, ok := m[k] : le second retour, un booléen, distingue « la clé existe et vaut 0 » de « la clé est absente ». C'est indispensable dès que zéro est une valeur légitime — un compteur à 0, un solde nul. Sans le ok, tu confonds l'absence et le zéro, et c'est une source de bugs aussi silencieuse que le cap de la slice.This read tolerance is precious: a function receiving a map can range over it without checking it's non-nil, and a never-initialized map field reads without crashing. Note in passing the idiom v, ok := m[k]: the second return, a boolean, distinguishes "the key exists and equals 0" from "the key is absent." It's indispensable as soon as zero is a legitimate value — a counter at 0, a null balance. Without the ok, you conflate absence and zero, a bug source as silent as the slice's cap.

Initialiser : make, ou littéral — jamais la valeur zéroInitialize: make, or literal — never the zero value
m := make(map[string]int)        // map vide mais ALLOUÉE — écriture OK
m["x"] = 1                       // ✓

m2 := map[string]int{}           // littéral vide : même effet, allouée
m3 := map[string]int{"a": 1}     // littéral avec données

// dans une struct, le champ map vaut nil tant qu'on ne l'a pas initialisé :
type Cache struct{ items map[string]int }
var c Cache                      // c.items est nil
c.items["k"] = 1                 // panic — il faut c.items = make(...) d'abord

Trois façons d'obtenir une map utilisable, toutes équivalentes pour l'écriture : make, le littéral vide map[K]V, ou le littéral peuplé. La seule à éviter est l'absence d'initialisation. Pourquoi Go n'auto-alloue-t-il pas, comme pour append ? Parce que ce serait incohérent : append retourne la slice, donc peut substituer un en-tête neuf ; une assignation m[k] = v ne retourne rien, elle ne pourrait pas remonter une map fraîchement allouée jusqu'à la variable de l'appelant. Le refus d'écrire dans une map nil est le prix de la cohérence du modèle — pas un caprice.Three ways to get a usable map, all equivalent for writing: make, the empty literal map[K]V, or the populated literal. The only one to avoid is no initialization at all. Why doesn't Go auto-allocate, as it does for append? Because it would be inconsistent: append returns the slice, so it can substitute a fresh header; an assignment m[k] = v returns nothing, it couldn't propagate a freshly allocated map back to the caller's variable. The refusal to write into a nil map is the price of the model's consistency — not a whim.

La map nil n'est pas une map vide. Elle se lit comme telle, mais s'écrire exige qu'on l'ait d'abord allouée — make, ou littéral.A nil map isn't an empty map. It reads like one, but writing demands you allocated it first — make, or a literal.
№ 04Le piègeThe trap4 min

Lire et écrire une map depuis deux goroutines ne corrompt pas en silence. Le runtime tue le programme — exprès.Reading and writing a map from two goroutines doesn't corrupt silently. The runtime kills the program — on purpose.

Le troisième refus est le plus tranchant. Une map Go n'est pas sûre pour l'accès concurrent : si une goroutine écrit pendant qu'une autre lit ou écrit la même map, sans synchronisation, le comportement n'est pas « peut-être une valeur incohérente ». C'est un fatal error: concurrent map read and map write, et le programme s'arrête immédiatement. Deux choses sont remarquables ici. D'abord, ce n'est pas un panic : c'est un fatal error, d'un cran au-dessus. recover() ne l'intercepte pas, aucun defer ne le rattrape, le process meurt sans appel. Ensuite, ce n'est pas un accident de timing qu'on aurait la chance d'éviter : le runtime de Go embarque un détecteur léger qui surveille les accès concurrents aux maps, et quand il en repère un, il choisit délibérément de crasher plutôt que de continuer. C'est un refus actif, pas une absence de protection. La logique est la même que pour les deux autres refus, poussée à l'extrême : plutôt qu'une corruption silencieuse de la table de hachage — des paires perdues, des lectures qui renvoient n'importe quoi, un état impossible à déboguer — Go préfère t'arrêter net et te dire pourquoi. Un crash bruyant vaut mieux qu'une donnée fausse qui se propage.The third refusal is the sharpest. A Go map isn't safe for concurrent access: if one goroutine writes while another reads or writes the same map, without synchronization, the behavior isn't 'maybe an inconsistent value.' It's a fatal error: concurrent map read and map write, and the program stops immediately. Two things stand out here. First, it's not a panic: it's a fatal error, one notch above. recover() doesn't intercept it, no defer catches it, the process dies with no appeal. Second, it's not a timing accident you might be lucky enough to dodge: Go's runtime embeds a light detector watching concurrent map accesses, and when it spots one, it deliberately chooses to crash rather than continue. It's an active refusal, not an absence of protection. The logic is the same as the other two refusals, taken to the extreme: rather than a silent corruption of the hash table — lost pairs, reads returning garbage, an undebuggable state — Go prefers to stop you dead and tell you why. A loud crash beats false data that spreads.

Deux goroutines, une map, aucune synchro : le crashTwo goroutines, one map, no sync: the crash
m := map[string]int{}

go func() {                        // goroutine A : écrit en boucle
    for i := 0; ; i++ { m["k"] = i }
}()
go func() {                        // goroutine B : lit en boucle
    for { use(m["k"]) }
}()

// fatal error: concurrent map read and map write
//   ← PAS un panic : un fatal error. recover() ne l'attrape pas.
//     le runtime a détecté l'accès concurrent et tué le process.

Que ce soit un fatal error et non un panic est un message en soi. Go te dit : ceci n'est pas une erreur que ton programme a le droit de gérer et de continuer — c'est une faute de structure qui rend tout état ultérieur suspect. La rattraper avec recover() n'aurait aucun sens, puisque la map est peut-être déjà à moitié corrompue. Le détecteur n'attrape pas toutes les courses (il est volontairement léger, pour ne pas coûter en performance), mais il en attrape assez pour transformer un bug de concurrence diffus en un crash daté et localisé. C'est exactement ce qu'on veut d'un bug pareil.That it's a fatal error and not a panic is a message in itself. Go tells you: this isn't an error your program is allowed to handle and continue from — it's a structural fault making any later state suspect. Catching it with recover() would make no sense, since the map may already be half-corrupted. The detector doesn't catch every race (it's deliberately light, to avoid a performance cost), but it catches enough to turn a diffuse concurrency bug into a dated, located crash. That's exactly what you want from a bug like this.

Trois refus, une seule philosophieThree refusals, one philosophy

Désordre exposé, écriture nil interdite, concurrence fatale : les trois refus de la map disent la même chose. Go refuse de simuler une garantie qu'il ne peut pas tenir honnêtement. Pas d'ordre, parce que le hachage n'en a pas. Pas d'écriture sur nil, parce qu'il n'y a pas de table. Pas d'accès concurrent libre, parce qu'il corromprait en silence. Chaque « non » t'épargne une illusion — et te laisse choisir la vraie solution, en pleine conscience.Exposed disorder, forbidden nil write, fatal concurrency: the map's three refusals say the same thing. Go refuses to fake a guarantee it can't honestly keep. No order, because hashing has none. No write on nil, because there's no table. No free concurrent access, because it would corrupt in silence. Each "no" spares you an illusion — and leaves you to choose the real solution, fully aware.

On a fini de partager. On va parler de copier.We're done sharing. We're going to talk about copying.

Tout le volume 5 a tourné autour de structures qui partagent une mémoire sous-jacente : la slice partage un tableau, la map partage une table de hachage. Deux exceptions, en réalité — car le comportement par défaut de Go est l'inverse exact. Passer une valeur, en Go, c'est la copier : un int, une struct, un tableau, tout est dupliqué champ par champ au passage. La slice et la map ne « partagent » que parce qu'elles sont, au fond, de minces en-têtes qui pointent ailleurs ; ce qu'on copie d'elles, c'est le pointeur, pas le contenu. Le volume 6 part de la règle générale, celle qui gouverne tout le reste : tout est copié. Et il montre quand cette copie est un cadeau, quand elle est un coût, et comment la slice et la map se logent dans ce modèle. Vol. 6 №01 — Tout est copié.All of volume 5 revolved around structures that share an underlying memory: the slice shares an array, the map shares a hash table. Two exceptions, really — because Go's default behavior is the exact opposite. Passing a value, in Go, copies it: an int, a struct, an array, all duplicated field by field on the way through. The slice and the map only 'share' because they are, at heart, thin headers pointing elsewhere; what you copy of them is the pointer, not the content. Volume 6 starts from the general rule, the one governing all the rest: everything is copied. And it shows when that copy is a gift, when it's a cost, and how the slice and the map fit into this model. Vol. 6 №01 — Everything is copied.

Une map partagée sans verrou n'est pas un risque, c'est un crash garanti dès que Go le voit. Si tu partages, synchronise — ou prends un type fait pour ça.A map shared without a lock isn't a risk, it's a guaranteed crash the moment Go sees it. If you share, synchronize — or take a type built for it.
№ 05Bilan & éditoWrap-up & editorial2 min

La map ne te surprend pas par ce qu'elle cache, mais par ce qu'elle refuse. Lis le refus : il te dit quoi faire.The map surprises you not by what it hides, but by what it refuses. Read the refusal: it tells you what to do.

Ce numéro a pris la map par ses trois refus. Elle n'ordonne pas ses clés — le hachage n'a pas d'ordre, et Go randomise le parcours pour t'empêcher d'en inventer un ; quand tu veux un ordre, tu collectes les clés et tu les tries. Elle interdit l'écriture sur sa valeur zéro — une map nil se lit comme une map vide mais panique à la première assignation, car il n'y a pas de table allouée ; on l'initialise avec make ou un littéral, et on n'oublie pas les champs map des structs. Elle refuse l'accès concurrent — lire et écrire depuis deux goroutines déclenche un fatal error que recover n'attrape pas, le runtime préférant tuer le programme plutôt que corrompre en silence ; on protège la map d'un sync.RWMutex, ou l'on prend sync.Map. Trois surprises, une seule logique : Go refuse de simuler une garantie qu'il ne peut pas tenir honnêtement, et te montre la contrainte réelle au lieu de la maquiller. Avec la slice du numéro précédent, la map complète le tableau du modèle de données — et clôt le volume.This issue took the map by its three refusals. It doesn't order its keys — hashing has no order, and Go randomizes the pass to stop you inventing one; when you want order, you collect the keys and sort them. It forbids writing to its zero value — a nil map reads like an empty map but panics on the first assignment, since no table is allocated; you initialize it with make or a literal, and you don't forget structs' map fields. It refuses concurrent access — reading and writing from two goroutines triggers a fatal error recover doesn't catch, the runtime preferring to kill the program rather than corrupt in silence; you guard the map with a sync.RWMutex, or take sync.Map. Three surprises, one logic: Go refuses to fake a guarantee it can't honestly keep, and shows you the real constraint instead of papering over it. With the previous issue's slice, the map completes the data model's picture — and closes the volume.

Le refusThe refusalLa règleThe ruleSi tu la ratesIf you miss it
L'ordreOrderItération randomisée à dessein ; pour un ordre, collecte les clés et sort.Iteration randomized by design; for an order, collect the keys and sort.Un test ou une sortie qui passe mille fois, casse une fois.A test or output that passes a thousand times, breaks once.
La map nilThe nil mapLisible comme vide, mais l'écriture panique ; make ou littéral d'abord.Readable as empty, but writing panics; make or a literal first.« assignment to entry in nil map » — souvent via un champ de struct.'assignment to entry in nil map' — often via a struct field.
La concurrenceConcurrencyAccès concurrent = fatal error ; encadre d'un RWMutex ou prends sync.Map.Concurrent access = fatal error; guard with a RWMutex or take sync.Map.Crash non récupérable — que recover ne rattrapera pas.An unrecoverable crash — recover won't catch it.
Le pourquoiThe whyChaque refus rend visible une contrainte réelle, au lieu de la masquer.Each refusal makes a real constraint visible, instead of masking it.Tu prends pour une garantie l'illusion qu'offre un autre langage.You mistake another language's illusion for a guarantee.
La slice cachait son piège dans un nombre. La map affiche les siens à voix haute — et chaque refus est déjà la moitié de la solution.The slice hid its trap in a number. The map states its own out loud — and each refusal is already half the solution.
Mot de l'éditeur · clôture du volume 5From the editor · closing volume 5

Le volume 5 portait sur la mémoire que tes données partagent. Mais le partage est l'exception. La règle, c'est la copie — et c'est le volume 6.Volume 5 was about the memory your data shares. But sharing is the exception. The rule is the copy — and that's volume 6.

Trois numéros pour deux structures. La slice nous a occupés deux fois parce qu'elle ment par omission : elle partage un tableau sans le dire, et son piège se cache dans un cap qu'aucune ligne n'affiche. La map, elle, a tenu en un numéro parce qu'elle ne ment pas du tout : ses dangers, elle les crie. Pas d'ordre, écriture nil interdite, concurrence fatale — trois refus francs, chacun gardant une vérité sur le hachage, l'initialisation ou la concurrence. C'est le contraste qui clôt le volume : deux piliers du modèle de données, l'un qui piège par discrétion, l'autre par franchise, mais tous deux refusant de te vendre une abstraction confortable et fausse. La slice te demande de comprendre ce qu'elle partage ; la map te demande d'accepter ce qu'elle refuse. Dans les deux cas, Go te traite en adulte : il te montre la mémoire telle qu'elle est, à charge pour toi de la manipuler juste.Three issues for two structures. The slice occupied us twice because it lies by omission: it shares an array without saying so, and its trap hides in a cap no line displays. The map, by contrast, held in one issue because it doesn't lie at all: its dangers, it shouts. No order, forbidden nil write, fatal concurrency — three blunt refusals, each guarding a truth about hashing, initialization, or concurrency. It's the contrast that closes the volume: two pillars of the data model, one trapping by discretion, the other by frankness, but both refusing to sell you a comfortable, false abstraction. The slice asks you to understand what it shares; the map asks you to accept what it refuses. Either way, Go treats you as an adult: it shows you memory as it is, and leaves it to you to handle it right.

Et c'est précisément là que le prochain volume retourne le décor. Tout le volume 5 a parlé de structures qui partagent une mémoire sous-jacente — une slice partage son tableau, une map sa table de hachage. On finit par croire que partager est la norme en Go. C'est l'inverse exact. Le comportement par défaut du langage, celui qui gouverne tout le reste, c'est la copie : passer une valeur à une fonction, l'assigner à une autre variable, la ranger dans un tableau — chaque fois, Go en duplique le contenu, champ par champ. La slice et la map ne font exception que parce qu'elles sont, au fond, de minces en-têtes : ce qu'on copie d'elles, c'est le pointeur vers la mémoire partagée, pas la mémoire. Comprendre cela, c'est tenir le fil qui relie tout ce qu'on a vu — pourquoi une struct passée par valeur est protégée, pourquoi une slice passée par valeur ne l'est pas. Le volume 6 part de cette règle première et en déroule les conséquences : quand la copie est un cadeau, quand elle est un coût, et comment choisir. On quitte ce que les données partagent pour ce que le langage, partout ailleurs, duplique. Vol. 6 №01 — Tout est copié.And that's precisely where the next volume flips the set. All of volume 5 spoke of structures that share an underlying memory — a slice shares its array, a map its hash table. You end up believing sharing is the norm in Go. It's the exact opposite. The language's default behavior, the one governing all the rest, is the copy: pass a value to a function, assign it to another variable, store it in an array — each time, Go duplicates its content, field by field. The slice and the map are exceptions only because they are, at heart, thin headers: what you copy of them is the pointer to the shared memory, not the memory. Grasping this is to hold the thread linking everything we've seen — why a struct passed by value is protected, why a slice passed by value is not. Volume 6 starts from that first rule and unfolds its consequences: when the copy is a gift, when it's a cost, and how to choose. We leave what data shares for what the language, everywhere else, duplicates. Vol. 6 №01 — Everything is copied.