append, la réallocation qui surprend append, the realloc that surprises

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.

Audience
Dev qui append à une sous-slice et corrompt l'originale sans comprendre pourquoi Dev who appends to a sub-slice and corrupts the original without knowing why
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●●○
Date
Juil 2027 Jul 2027

appendRéallocationPiège

SommaireContents ·
№ 01CadrageFraming3 min

append n'ajoute pas à ta slice. Il en retourne une nouvelle — que tu dois récupérer.append doesn't add to your slice. It returns a new one — which you must keep.

Le numéro précédent a posé la slice comme une vue de trois mots sur un tableau, et l'a laissée immobile. append est l'opération qui la fait grandir — et c'est là que tout se complique. Le piège commence par sa signature : append ne modifie pas la slice en place, il en renvoie une, qu'il faut réassigner. La forme s = append(s, x) n'est pas un tic de style ; elle est obligatoire, parce que append peut être amené à changer les trois mots de l'en-tête. Pourquoi ? Parce qu'un tableau a une taille fixe. Tant qu'il reste de la place — de la capacité — append écrit dans le tableau existant et se contente d'augmenter la longueur. Mais dès que le tableau est plein, il n'y a pas de « l'agrandir sur place » : append doit allouer un tableau neuf, plus grand, y recopier tout, et te rendre un en-tête qui pointe désormais ailleurs. Deux comportements radicalement différents, derrière un seul appel — et c'est à toi de toujours récupérer le résultat, parce que tu ne sais pas lequel des deux vient d'avoir lieu.The previous issue laid down the slice as a three-word view over an array, and left it still. append is the operation that grows it — and that's where everything gets complicated. The trap starts with its signature: append doesn't modify the slice in place, it returns one, which you must reassign. The form s = append(s, x) isn't a style tic; it's mandatory, because append may have to change all three words of the header. Why? Because an array has a fixed size. While there's room — capacity — append writes into the existing array and merely bumps the length. But the moment the array is full, there's no 'grow it in place': append must allocate a new, larger array, copy everything into it, and hand you a header now pointing elsewhere. Two radically different behaviors behind a single call — and it's on you to always keep the result, because you don't know which of the two just happened.

Ignorer le retour : les ajouts s'évaporentIgnore the return: the additions evaporate
func push(s []int, x int) {
    s = append(s, x)     // met à jour la COPIE LOCALE de l'en-tête
}                        // ce nouvel en-tête meurt à la fin de push

s := make([]int, 0, 4)
push(s, 1)
push(s, 2)
fmt.Println(s, len(s))   // [] 0 — l'appelant n'a rien vu.
Réassigner le retour : la seule forme correcteReassign the return: the only correct form
func push(s []int, x int) []int {
    return append(s, x)  // on RENVOIE le nouvel en-tête
}

s := make([]int, 0, 4)
s = push(s, 1)           // … et l'appelant le RÉASSIGNE
s = push(s, 2)
fmt.Println(s, len(s))   // [1 2] 2 — la règle : le résultat remonte jusqu'à toi.
Deux chemins, selon la capacité restanteTwo paths, by remaining capacity
len < cap
écrit en place
même tableau · len + 1 · ptr inchangé
|
len == cap
réalloue
tableau neuf · copie tout · ptr différent

Le même append(s, x) emprunte l'un ou l'autre chemin selon une seule donnée : reste-t-il de la capacité ? Tu ne le vois pas dans le code — cap n'apparaît nulle part — et pourtant c'est lui qui décide si ton tableau est partagé ou détaché. D'où l'unique règle de survie : s = append(s, x), toujours.The same append(s, x) takes one path or the other by a single datum: is there capacity left? You don't see it in the code — cap appears nowhere — yet it decides whether your array is shared or detached. Hence the one survival rule: s = append(s, x), always.

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

« append rend un en-tête ; je le réassigne, et je me méfie du tableau d'origine. » Le numéro 1 a montré le partage immobile ; celui-ci montre l'opération qui peut le rompre — ou pire, l'exploiter pour corrompre. Le bug le plus subtil de Go vit ici, sur la frontière entre « écrit en place » et « réalloue », une frontière qu'aucune ligne ne rend visible. Tout le numéro consiste à la rendre lisible."append returns a header; I reassign it, and I distrust the original array." Issue 1 showed the still sharing; this one shows the operation that can break it — or worse, exploit it to corrupt. Go's subtlest bug lives here, on the boundary between "writes in place" and "reallocates," a boundary no line makes visible. The whole issue is about making it readable.

Pourquoi pas « agrandir le tableau » ?Why not just 'grow the array'?

Parce qu'un tableau, en mémoire, est un bloc contigu de taille fixe : ses éléments se suivent sans trou. « L'agrandir » voudrait dire que les octets juste après lui sont libres — ce que rien ne garantit ; ils appartiennent peut-être déjà à autre chose. La seule opération sûre est donc d'allouer un bloc neuf, assez grand, et d'y recopier l'existant. C'est pour ça qu'append ne peut pas promettre d'écrire en place : il le fait quand la capacité pré-réservée le permet, et bascule sur une réallocation sinon. Toute la mécanique du numéro découle de cette contrainte physique — la mémoire contiguë ne s'étire pas, elle se recopie ailleurs.Because an array, in memory, is a fixed-size contiguous block: its elements follow with no gap. 'Growing it' would mean the bytes right after it are free — which nothing guarantees; they may already belong to something else. So the only safe operation is to allocate a fresh block, big enough, and copy the existing into it. That's why append can't promise to write in place: it does when pre-reserved capacity allows, and falls back to a reallocation otherwise. The whole issue's machinery follows from that physical constraint — contiguous memory doesn't stretch, it's recopied elsewhere.

№ 02La surpriseThe surprise4 min

Le même append corrompt a dans un cas, le laisse intact dans l'autre. Seul le cap change.The same append corrupts a in one case, leaves it intact in the other. Only the cap differs.

Voici le bug que beaucoup considèrent comme le plus retors de Go, parce qu'il est invisible et intermittent. Tu tranches une slice b à partir d'une slice a, tu fais b = append(b, x) — un geste anodin — et selon la capacité de a, deux choses opposées se produisent. S'il reste de la place dans le tableau de a, append y écrit directement : la nouvelle valeur de b atterrit dans une case qui appartenait aussi à a, et tu corromps a sans même mentionner son nom. S'il ne reste pas de place, append réalloue : b part sur son propre tableau, a reste intact, et tout se passe bien. Le piège n'est pas qu'un comportement soit faux — les deux sont corrects — c'est que rien dans le code ne dit lequel tu obtiens. La frontière est gouvernée par cap, un nombre qui n'apparaît dans aucune ligne. D'où des bugs qui ne se manifestent que pour certaines tailles d'entrée, disparaissent au débogage, et reviennent en production : le partage tient tant que le tableau a de la marge, et casse silencieusement quand il n'en a plus.Here's the bug many consider Go's most devious, because it's invisible and intermittent. You slice a slice b from a slice a, you do b = append(b, x) — an innocent move — and depending on a's capacity, two opposite things happen. If there's room left in a's array, append writes there directly: b's new value lands in a cell that also belonged to a, and you corrupt a without even naming it. If there's no room, append reallocates: b gets its own array, a stays intact, and all is well. The trap isn't that one behavior is wrong — both are correct — it's that nothing in the code says which you get. The boundary is governed by cap, a number appearing in no line. Hence bugs that surface only for certain input sizes, vanish under debugging, and return in production: the sharing holds while the array has slack, and breaks silently when it runs out.

De la place : append écrit dans le tableau de aRoom left: append writes into a's array
// cas A : il reste de la capacité dans le tableau partagé
a := []int{1, 2, 3, 4, 5}   // len 5, cap 5
b := a[:2]                  // len 2, cap 5  ← b voit tout le tableau de a

b = append(b, 99)           // len 2 < cap 5 : place libre → écrit EN PLACE
//                             … à l'indice 2 du tableau de a.
fmt.Println(b)              // [1 2 99]
fmt.Println(a)              // [1 2 99 4 5]   ← a[2] écrasé, sans qu'on le veuille

Quand b := a[:2], le cap de b couvre tout le tableau de a — c'est ce qu'on a vu au numéro 1. Donc append(b, 99) trouve de la place et écrit à l'indice 2… qui est a[2]. Tu as muté a sans jamais l'écrire, en croyant ne toucher que b. C'est le scénario classique d'une fonction qui reçoit une sous-slice, lui append deux ou trois éléments « à elle », et piétine en réalité les données suivantes de l'appelant.When b := a[:2], b's cap covers all of a's array — as we saw in issue 1. So append(b, 99) finds room and writes at index 2… which is a[2]. You mutated a without ever writing to it, thinking you touched only b. It's the classic scenario of a function receiving a sub-slice, appending two or three elements "of its own," and actually trampling the caller's following data.

Un bug qui dépend de la taille des donnéesA bug that depends on data size

C'est ce qui rend ce bug si coûteux : il est fonction de l'état du tableau, pas du texte du programme. Avec dix éléments, le cap est plein, ça réalloue, tout va bien ; avec huit, il reste de la marge, ça écrit en place, et la corruption commence. Les tests sur petits jeux passent, le débogueur pas à pas (qui change parfois les allocations) ne reproduit rien, et le rapport de bug dit « ça plante seulement avec les gros fichiers ». La leçon est nette : ne déduis jamais le comportement d'append de ce que tu observes une fois. Si deux slices partagent un tableau, traite tout append sur l'une comme une menace pour l'autre — quelle que soit la capacité du jour.That's what makes this bug so costly: it's a function of the array's state, not the program's text. With ten elements, cap is full, it reallocates, all is well; with eight, slack remains, it writes in place, and corruption begins. Tests on small sets pass, the step debugger (which sometimes changes allocations) reproduces nothing, and the bug report says "it only crashes with big files." The lesson is sharp: never infer append's behavior from what you observe once. If two slices share an array, treat any append on one as a threat to the other — whatever the day's capacity.

Le bug n'est pas dans ton code. Il est dans un nombre — cap — que ton code ne montre nulle part.The bug isn't in your code. It's in a number — cap — your code shows nowhere.
№ 03La mécaniqueThe mechanics5 min

Tant qu'il reste du cap, append est presque gratuit. Quand il s'épuise, il recopie tout.While cap remains, append is nearly free. When it runs out, it recopies everything.

Sous l'apparente simplicité d'append se cache un algorithme d'amortissement, le même que derrière les tableaux dynamiques de la plupart des langages. Quand tu appends et qu'il reste de la capacité, l'opération est minuscule : écrire un élément, incrémenter la longueur. Le pointeur ne bouge pas, le tableau reste partagé. Quand la capacité est épuisée, append change de régime : il alloue un nouveau tableau plus grand — grossièrement le double pour les petites slices, une croissance plus douce pour les grosses — y recopie tous les éléments existants, ajoute le nouveau, et renvoie un en-tête qui pointe sur ce tableau neuf. Cette copie coûte, en proportion de la taille. Mais comme elle n'arrive que lorsqu'on double, elle se dilue : sur N appends successifs, le coût total des recopies reste de l'ordre de N, soit un coût amorti constant par append. La conséquence pratique est double. D'abord, append est efficace même appelé en boucle, sans qu'on s'en soucie. Ensuite, si l'on connaît la taille finale, on peut supprimer toutes les réallocations d'un coup en pré-réservant la capacité — et c'est presque toujours ce qu'il faut faire.Beneath append's apparent simplicity hides an amortization algorithm, the same one behind most languages' dynamic arrays. When you append and capacity remains, the operation is tiny: write an element, increment the length. The pointer doesn't move, the array stays shared. When capacity is exhausted, append changes regime: it allocates a new, larger array — roughly double for small slices, a gentler growth for big ones — copies all existing elements into it, adds the new one, and returns a header pointing at that fresh array. This copy costs, in proportion to size. But since it only happens on doubling, it dilutes: over N successive appends, the total copy cost stays on the order of N, an amortized constant cost per append. The practical consequence is twofold. First, append is efficient even called in a loop, without you worrying. Second, if you know the final size, you can wipe out all reallocations at once by pre-reserving capacity — and that's almost always what you should do.

Place disponible : on écrit, on incrémente lenRoom available: write, bump len
s := make([]int, 2, 4)      // len 2, cap 4
fmt.Println(len(s), cap(s)) // 2 4

s = append(s, 9)            // len 2 < cap 4 :
//   • écrit dans le tableau existant, à l'indice 2
//   • len passe à 3, le pointeur NE BOUGE PAS, cap reste 4
fmt.Println(len(s), cap(s)) // 3 4  ← même tableau, juste len + 1

Le cas heureux et fréquent. len passe de 2 à 3, cap reste à 4, le pointeur est inchangé : c'est exactement le même tableau, avec une case de plus utilisée. Coût : une écriture. Et c'est précisément ce cas qui rend le partage dangereux — puisque le tableau ne bouge pas, toute autre slice qui le regardait voit, elle aussi, la nouvelle valeur. L'efficacité de l'append en place et le bug du chapitre 2 sont la même propriété, vue sous deux angles.The happy, frequent case. len goes from 2 to 3, cap stays at 4, the pointer is unchanged: it's exactly the same array, with one more cell used. Cost: one write. And it's precisely this case that makes sharing dangerous — since the array doesn't move, any other slice that was watching it also sees the new value. In-place append's efficiency and chapter 2's bug are the same property, seen from two angles.

Le corollaire pratique : pré-dimensionner quand la taille est connueThe practical corollary: pre-size when the size is known
// taille connue : on va produire len(src) éléments
out := make([]int, 0, len(src))   // une seule alloc, cap suffisante d'emblée
for _, v := range src {
    out = append(out, transform(v))   // jamais de réalloc dans la boucle
}
// sans le cap initial (make([]int, 0)), append réallouerait ~log2(n) fois,
// recopiant tout le contenu à chaque doublement. Le pré-dimensionnement l'évite.

make([]T, 0, n) crée une slice vide (len 0) mais dotée d'une capacité n : les append qui suivent écrivent tous en place, sans une seule réallocation. Pour transformer une liste, lire des lignes en nombre connu, bâtir un résultat de taille prévisible, c'est le réflexe par défaut — une allocation au lieu de plusieurs, zéro recopie intermédiaire. Attention au piège jumeau : make([]T, n) (sans le 0) crée n éléments à zéro, et append ajoute après — tu obtiens n zéros suivis de tes données. Pour pré-réserver, c'est make([]T, 0, n).make([]T, 0, n) creates an empty slice (len 0) but with capacity n: the following appends all write in place, without a single reallocation. To transform a list, read a known number of lines, build a result of predictable size, it's the default reflex — one allocation instead of several, zero intermediate copies. Beware the twin trap: make([]T, n) (without the 0) creates n zeroed elements, and append adds after — you get n zeros followed by your data. To pre-reserve, it's make([]T, 0, n).

Ne suppose jamais le cap qu'append te donnera. Si tu connais la taille finale, impose-le toi-même avec make([]T, 0, n).Never assume the cap append will give you. If you know the final size, impose it yourself with make([]T, 0, n).
№ 04Le piègeThe trap4 min

Pour qu'un append ne touche jamais le tableau d'autrui, prive-le de capacité — ou clone.To stop an append from ever touching someone else's array, starve it of capacity — or clone.

Une fois le danger compris, deux outils suffisent à le neutraliser, selon l'intention. Le premier répond à « je veux pouvoir append sans risquer d'écraser le tableau partagé » : l'expression à trois indices, base[bas:haut:haut], qui borne la capacité à la longueur. Une telle slice n'a aucune marge ; le prochain append est donc forcé de réallouer, et ne peut, par construction, écrire dans le tableau d'origine. C'est l'outil idéal quand on dérive une slice d'une donnée qu'on ne veut surtout pas corrompre — découper un buffer, exposer une portion. Le second répond à « je veux une slice totalement indépendante, tout de suite » : slices.Clone, ou le classique make + copy. Là, on ne se contente pas de forcer la future réallocation : on duplique immédiatement les données dans un tableau neuf, et le lien est rompu net. La règle de choix est simple. Si tu veux seulement empêcher un débordement à la croissance, borne le cap. Si tu veux deux jeux de données qui n'ont plus rien à voir, clone. Dans les deux cas, tu remplaces un partage implicite et fragile par une décision explicite.Once the danger is understood, two tools suffice to neutralize it, by intent. The first answers 'I want to append without risking overwriting the shared array': the three-index expression, base[low:high:high], which bounds the capacity to the length. Such a slice has no slack; the next append is thus forced to reallocate, and cannot, by construction, write into the original array. It's the ideal tool when deriving a slice from data you absolutely don't want to corrupt — carving a buffer, exposing a portion. The second answers 'I want a fully independent slice, right now': slices.Clone, or the classic make + copy. There, you don't just force the future reallocation: you immediately duplicate the data into a fresh array, and the link is cut clean. The choice rule is simple. If you only want to prevent an overflow on growth, bound the cap. If you want two datasets that have nothing to do with each other, clone. Either way, you replace an implicit, fragile sharing with an explicit decision.

Deux append sur une base à cap large : collisionTwo appends on a wide-cap base: collision
base := []int{1, 2, 3, 4}    // len 4, cap 4

// on dérive deux slices d'une base commune, et on append à chacune
a := append(base[:2], 9)     // base[:2] a cap 4 → écrit base[2] EN PLACE
b := append(base[:2], 8)     // refait pareil → base[2] = 8, écrase le 9 de a !

fmt.Println(a, b)            // [1 2 8] [1 2 8]  ← a et b se marchent dessus
// les deux append visent la même case du tableau de base. Aucune copie.

Le motif est traître parce qu'il a l'air de produire deux slices distinctes — a et b sont bien deux variables. Mais leurs append visent la même case libre du tableau de base, et le second écrase le premier. On le rencontre dès qu'on bâtit plusieurs résultats à partir d'un préfixe commun — un nœud d'arbre dont on dérive les enfants, un chemin qu'on prolonge de deux façons. Tant que la base garde de la capacité, ces dérivations ne sont pas indépendantes : elles se disputent la même mémoire.The pattern is treacherous because it looks like it produces two distinct slices — a and b are indeed two variables. But their appends target the same free cell of base's array, and the second overwrites the first. You meet it whenever you build several results from a common prefix — a tree node whose children you derive, a path you extend two ways. As long as the base keeps capacity, these derivations aren't independent: they fight over the same memory.

slices.Clone : rompre le lien, maintenantslices.Clone: cut the link, now

Borner le cap empêche un futur append de déborder, mais les deux slices regardent encore le même tableau jusqu'à cette croissance — modifier a[0] se verrait toujours dans base. Quand tu veux la séparation immédiate et totale, c'est slices.Clone(s) (Go 1.21), ou son équivalent manuel make + copy vu au numéro 1. Borne le cap pour la sécurité à la croissance ; clone pour l'indépendance des données. Ce sont deux niveaux de rupture : l'un agit au prochain append, l'autre tout de suite, sur chaque case.Bounding the cap stops a future append from overflowing, but the two slices still watch the same array until that growth — modifying a[0] would still show in base. When you want immediate, total separation, it's slices.Clone(s) (Go 1.21), or its manual equivalent make + copy from issue 1. Bound the cap for growth safety; clone for data independence. They're two levels of severance: one acts on the next append, the other right away, on every cell.

La structure suivante refuse d'autres choses.The next structure refuses other things.

On a passé deux numéros sur la slice : un tableau partagé, une croissance qui réalloue, des pièges qui tiennent à un cap invisible. La map est l'autre structure qu'on utilise chaque jour — et elle a, elle aussi, ses surprises, mais d'une autre nature. Là où la slice piège par ce qu'elle partage en silence, la map piège par ce qu'elle refuse, exprès : son itération est volontairement désordonnée, écrire dans une map nil panique, et la lire et l'écrire depuis deux goroutines fait planter le programme d'un coup. Trois garanties que d'autres langages offrent et que Go retire sciemment — pour des raisons qu'on va voir. Vol. 5 №03 — La map, ni ordonnée ni concurrente.We've spent two issues on the slice: a shared array, a growth that reallocates, traps hinging on an invisible cap. The map is the other structure you use daily — and it too has surprises, but of another nature. Where the slice traps by what it silently shares, the map traps by what it refuses, on purpose: its iteration is deliberately unordered, writing to a nil map panics, and reading and writing it from two goroutines crashes the program outright. Three guarantees other languages offer and Go knowingly withdraws — for reasons we'll see. Vol. 5 №03 — The map, neither ordered nor concurrent.

Le partage par défaut est une optimisation, pas une intention. Quand tu veux l'indépendance, dis-le — borne le cap, ou clone.Sharing by default is an optimization, not an intent. When you want independence, say so — bound the cap, or clone.
№ 05Bilan & éditoWrap-up & editorial2 min

Tout append pose la même question muette : reste-t-il du cap ? Sa réponse décide de tout.Every append asks the same silent question: is there cap left? Its answer decides everything.

Ce numéro a déplié l'opération qui fait grandir une slice. append retourne un en-tête : on le réassigne, sans exception. Selon la capacité restante, il écrit en place dans le tableau partagé, ou réalloue dans un tableau neuf — et c'est ce basculement, gouverné par un cap invisible, qui produit le bug le plus retors de Go : le même code corrompt ou préserve les autres vues selon l'état du tableau. La mécanique est un amortissement par doublement, efficace en boucle, qu'on optimise d'un seul make([]T, 0, n) quand la taille est connue. Et pour neutraliser le partage : borner le cap à trois indices force la réallocation, slices.Clone rompt le lien tout de suite. Le fil du volume continue — une slice est une vue, et la faire grandir révèle, sans prévenir, jusqu'où cette vue allait.This issue unfolded the operation that grows a slice. append returns a header: you reassign it, no exception. By remaining capacity, it writes in place into the shared array, or reallocates into a fresh one — and it's that switch, governed by an invisible cap, that produces Go's most devious bug: the same code corrupts or preserves the other views by the array's state. The mechanic is an amortization by doubling, efficient in a loop, optimized with a single make([]T, 0, n) when the size is known. And to neutralize sharing: bounding the cap with three indices forces reallocation, slices.Clone cuts the link at once. The volume's thread continues — a slice is a view, and growing it reveals, without warning, how far that view reached.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
RéassigneReassigns = append(s, x), toujours — append rend un en-tête.s = append(s, x), always — append returns a header.Tes ajouts s'évaporent, ou ne remontent pas de la fonction.Your additions evaporate, or don't climb out of the function.
En place ou neufIn place or newlen<cap écrit dans le tableau partagé ; len==cap réalloue.len<cap writes the shared array; len==cap reallocates.Un append écrase une slice qui partageait le même tableau.An append clobbers a slice that shared the same array.
Le cap décideCap decidesMême code, effet opposé, selon un cap qu'on ne voit pas.Same code, opposite effect, by a cap you can't see.Un bug fonction de la taille des données, fuyant au débogage.A bug that's a function of data size, evasive under debugging.
Borne ou cloneBound or clonea[i:j:j] force la réalloc ; slices.Clone détache maintenant.a[i:j:j] forces realloc; slices.Clone detaches now.Corruption croisée entre des slices qu'on croyait séparées.Cross-corruption between slices you thought were separate.
Le numéro 1 t'a montré une vue immobile. Celui-ci montre ce qu'elle fait en grandissant : elle se détache, ou elle déborde — et jamais le code ne dit lequel.Issue 1 showed you a still view. This one shows what it does while growing: it detaches, or it overflows — and the code never says which.
Mot de l'éditeurFrom the editor

Le bug d'append n'est pas un défaut de Go. C'est le prix, parfaitement assumé, de ne rien cacher de la mémoire.The append bug isn't a flaw in Go. It's the fully owned price of hiding nothing about memory.

On pourrait croire que ce piège trahit une négligence de conception. C'est l'inverse. D'autres langages effacent la question en rendant chaque liste indépendante par copie, ou en cachant le partage derrière des structures immuables — au prix d'allocations et de copies invisibles, que le programmeur ne contrôle pas. Go fait le choix opposé, le même que partout dans le langage : montrer la mémoire telle qu'elle est. Une slice partage un tableau parce que c'est ce qui se passe vraiment ; append écrit en place quand il le peut parce que recopier sans raison serait du gâchis. Le revers, c'est qu'on doit comprendre ce qu'on manipule — savoir qu'un cap existe, qu'il décide, qu'il est invisible. Le bug n'est pas dans le langage ; il est dans l'écart entre ce que la slice fait et l'image de « liste sûre » qu'on plaque dessus. Toute la série répète la même chose sous mille formes : Go préfère un modèle exact et exigeant à un modèle confortable et menteur.You might think this trap betrays a design oversight. It's the opposite. Other languages erase the question by making every list independent by copy, or by hiding sharing behind immutable structures — at the cost of invisible allocations and copies the programmer doesn't control. Go makes the opposite choice, the same one as everywhere in the language: show memory as it is. A slice shares an array because that's what really happens; append writes in place when it can because recopying for no reason would be waste. The flip side is that you must understand what you're handling — know a cap exists, that it decides, that it's invisible. The bug isn't in the language; it's in the gap between what the slice does and the 'safe list' image you paste onto it. The whole series repeats the same thing in a thousand forms: Go prefers an exact, demanding model to a comfortable, lying one.

La slice nous a occupés deux numéros parce qu'elle est l'archétype du modèle de données de Go : une indirection mince, rapide, partagée, qu'on doit se représenter juste sous peine de bugs muets. La map est l'autre pilier de ce modèle, et elle enseigne la leçon par l'autre bout. La slice surprend par ce qu'elle fait sans le dire — partager, déborder, réallouer. La map, elle, surprend par ce qu'elle refuse de faire, ouvertement : elle n'ordonne pas ses clés, elle ne tolère pas l'écriture concurrente, elle panique si on écrit dans sa version nil. Trois refus délibérés, chacun protégeant une vérité — sur le hachage, sur la concurrence, sur l'initialisation — que d'autres langages préfèrent te dissimuler. On quitte ce qui partage trop pour ce qui refuse exprès. Vol. 5 №03 — La map, ni ordonnée ni concurrente.The slice occupied us two issues because it's the archetype of Go's data model: a thin, fast, shared indirection you must picture right or suffer silent bugs. The map is the other pillar of that model, and it teaches the lesson from the other end. The slice surprises by what it does without saying — sharing, overflowing, reallocating. The map surprises by what it refuses to do, openly: it doesn't order its keys, it doesn't tolerate concurrent writing, it panics if you write to its nil version. Three deliberate refusals, each protecting a truth — about hashing, about concurrency, about initialization — that other languages prefer to conceal from you. We leave what shares too much for what refuses on purpose. Vol. 5 №03 — The map, neither ordered nor concurrent.