La slice, une vue sur un tableau The slice, a view over an array

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.

Audience
Dev qui croit qu'une sous-slice est une copie, et se fait surprendre par l'aliasing Dev who thinks a sub-slice is a copy, and gets surprised by aliasing
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Juin 2027 Jun 2027

SlicesAliasing

SommaireContents ·
№ 01CadrageFraming3 min

Une slice n'est pas un tableau. C'est une vue sur un tableau — trois mots, pas des données.A slice isn't an array. It's a view over an array — three words, not data.

Quatre volumes durant, on a déplacé des valeurs sans jamais regarder ce qu'elles sont, physiquement, en mémoire. Le volume 5 ouvre cette boîte, et commence par l'objet le plus quotidien de Go — celui qu'on utilise chaque heure et qu'on se représente presque toujours faux. La slice n'est pas un tableau qui grandit. C'est une structure minuscule de trois champs : un pointeur vers un tableau sous-jacent, une longueur, et une capacité. Le tableau, lui, vit ailleurs. Cette distinction n'est pas un détail d'implémentation à oublier : elle gouverne tout le comportement de la slice. Affecter une slice à une autre variable, la passer à une fonction, la trancher — aucune de ces opérations ne copie les données. Elles copient les trois mots, et te laissent deux vues sur le même tableau. Comprendre cela, c'est comprendre d'avance toutes les surprises du volume.For four volumes, we moved values without ever looking at what they physically are in memory. Volume 5 opens that box, and starts with Go's most everyday object — the one you use hourly and almost always picture wrong. A slice isn't an array that grows. It's a tiny structure of three fields: a pointer to an underlying array, a length, and a capacity. The array itself lives elsewhere. This distinction isn't an implementation detail to forget: it governs the slice's entire behavior. Assigning a slice to another variable, passing it to a function, slicing it — none of these operations copy the data. They copy the three words, and leave you two views over the same array. To understand this is to understand, in advance, every surprise in the volume.

Le tableau : une valeur, copiée en entierThe array: a value, copied whole
// un tableau : une VALEUR de taille fixe. L'affecter copie tout.
a := [3]int{10, 20, 30}
b := a            // b est une copie complète des trois éléments
b[0] = 99
fmt.Println(a, b)   // [10 20 30] [99 20 30] — b est indépendant
La slice : un en-tête, copié — le tableau, partagéThe slice: a header, copied — the array, shared
// une slice : une VUE de trois mots, posée sur un tableau sous-jacent.
a := []int{10, 20, 30}   // pas de taille dans le type : c'est une vue
b := a            // b copie les trois mots (ptr, len, cap), pas les données
b[0] = 99         // b.ptr et a.ptr visent le MÊME tableau
fmt.Println(a, b)   // [99 20 30] [99 20 30] — a a changé aussi
Une slice = trois mots qui pointent ailleursA slice = three words pointing elsewhere
l'en-tête
ptr
len 3
cap 3
→
le tableau sous-jacent
10
20
30

Quand tu copies une slice, tu copies la boîte de gauche — trois mots — jamais celle de droite. Deux slices peuvent avoir des en-têtes différents (len, cap, point de départ) tout en visant le même tableau. La donnée est partagée par défaut ; c'est le cœur de tout ce qui suit.When you copy a slice, you copy the left box — three words — never the right one. Two slices can have different headers (len, cap, starting point) while pointing at the same array. The data is shared by default; that's the heart of everything that follows.

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

« Une slice est une vue ; la copier copie la vue, pas les données. » Tout le confort de la slice — trancher en O(1), passer sans coût, partager un tampon — vient de là. Tous ses pièges aussi. Le même fait — c'est une vue, pas un conteneur — explique l'élégance et le danger. Le volume ne fait que décliner cette phrase : sur le partage (ce numéro), sur la croissance (le n°2), sur le cas particulier de la map (le n°3)."A slice is a view; copying it copies the view, not the data." All the slice's comfort — O(1) slicing, free passing, sharing a buffer — comes from this. So do all its traps. The same fact — it's a view, not a container — explains the elegance and the danger. The volume just conjugates that sentence: over sharing (this issue), over growth (issue 2), over the map's special case (issue 3).

Le tableau existe encore — on l'a juste caché.The array still exists — we just hid it.

Go a des tableaux de taille fixe — [3]int — mais on les croise rarement directement, parce qu'ils sont rigides : la taille fait partie du type, [3]int et [4]int sont incompatibles, et les affecter copie tout. La slice est la couche pratique posée par-dessus : une fenêtre redimensionnable sur un tableau qu'on ne nomme presque jamais. Quand tu écris une slice littérale, Go alloue silencieusement le tableau sous-jacent et te rend une vue dessus. Le tableau n'a pas disparu ; il est devenu invisible. Et c'est précisément parce qu'on ne le voit plus qu'on oublie qu'il est partagé — l'oubli d'où naissent toutes les surprises qui suivent.Go has fixed-size arrays — [3]int — but you rarely meet them directly, because they're rigid: the size is part of the type, [3]int and [4]int are incompatible, and assigning them copies everything. The slice is the practical layer laid on top: a resizable window over an array you almost never name. When you write a slice literal, Go silently allocates the underlying array and hands you a view over it. The array hasn't vanished; it's become invisible. And it's precisely because you no longer see it that you forget it's shared — the forgetting from which every following surprise is born.

№ 02La surpriseThe surprise4 min

Tu écris dans b := a[1:3]. Et c'est a qui change. Le partage n'était pas optionnel.You write into b := a[1:3]. And it's a that changes. The sharing wasn't optional.

Voici la surprise fondatrice du volume, celle dont tout le reste découle. Tu prends une slice a, tu en tranches une portion, b := a[1:3], pour travailler tranquillement sur un bout. Tu modifies b — et a se met à changer sous tes yeux, à des indices que tu n'as pas touchés. Aucun bug dans ton code, aucune erreur de frappe : c'est le comportement défini de Go. Trancher une slice ne crée pas une nouvelle slice avec ses propres données. Ça crée un nouvel en-tête — un nouveau pointeur, une nouvelle longueur — qui vise le même tableau sous-jacent, simplement décalé. b[0] n'est pas une copie de a[1] : c'est exactement la même case mémoire, vue par deux fenêtres. Écrire par l'une, c'est écrire pour l'autre. Le partage que le chapitre 1 décrivait en théorie, tu viens de le rencontrer en pratique — et il n'y a aucun moyen de trancher sans lui.Here's the volume's founding surprise, the one everything else flows from. You take a slice a, slice a portion of it, b := a[1:3], to work calmly on one piece. You modify b — and a starts changing before your eyes, at indices you never touched. No bug in your code, no typo: it's Go's defined behavior. Slicing a slice doesn't create a new slice with its own data. It creates a new header — a new pointer, a new length — pointing at the same underlying array, simply offset. b[0] isn't a copy of a[1]: it's exactly the same memory cell, seen through two windows. Writing through one is writing for the other. The sharing chapter 1 described in theory, you've just met in practice — and there's no way to slice without it.

Écrire dans b modifie a, à un indice qu'on n'a pas touchéWriting into b modifies a, at an index you never touched
a := []int{10, 20, 30, 40, 50}
b := a[1:3]          // b « contient » [20 30]

b[0] = 99            // on écrit dans b, à son indice 0…

fmt.Println(b)       // [99 30]
fmt.Println(a)       // [10 99 30 40 50]  ← a a changé, à l'indice 1 !
// b[0] et a[1] sont la MÊME case mémoire. Trancher n'a rien copié.

Le piège est d'autant plus vicieux qu'il est silencieux et décalé : b[0] = 99 a l'air parfaitement local, et la corruption apparaît dans a, à l'indice 1, peut-être lue mille lignes plus loin par du code qui n'a jamais entendu parler de b. Le réflexe venu d'autres langages — « une sous-liste est une nouvelle liste » — est faux en Go. Tant qu'on ne se le redit pas, on écrit des fonctions qui « empruntent » une slice pour la trier, la filtrer, la normaliser, et qui saccagent au passage la donnée de l'appelant.The trap is all the more vicious for being silent and offset: b[0] = 99 looks perfectly local, and the corruption surfaces in a, at index 1, perhaps read a thousand lines later by code that never heard of b. The reflex from other languages — "a sub-list is a new list" — is false in Go. Until you re-tell yourself this, you write functions that "borrow" a slice to sort, filter, normalize it, and trash the caller's data along the way.

Le même fait, vu comme une forceThe same fact, seen as a strength

Ce partage n'est pas qu'un piège : c'est ce qui rend les slices rapides. Trancher un tableau d'un million d'éléments en deux moitiés ne coûte rien — deux en-têtes, zéro octet copié. Parcourir, dé-piler, fenêtrer un gros tampon se fait sans allocation. Quand tu veux partager — découper un buffer réseau, passer une portion à traiter — l'aliasing est exactement le bon outil. Le danger n'apparaît que quand tu croyais avoir une copie indépendante. La compétence n'est pas d'éviter le partage, mais de savoir, à chaque s[i:j], si tu le veux ou non — et d'agir en conséquence (chapitre 4).This sharing isn't only a trap: it's what makes slices fast. Slicing a million-element array into two halves costs nothing — two headers, zero bytes copied. Iterating, popping, windowing a big buffer happens without allocation. When you want to share — carving a network buffer, passing a portion to process — aliasing is exactly the right tool. The danger only appears when you thought you had an independent copy. The skill isn't avoiding sharing, but knowing, at each s[i:j], whether you want it — and acting accordingly (chapter 4).

Trancher une slice ne copie rien. Ça ouvre une seconde fenêtre sur le même tableau — et les deux écrivent dedans.Slicing a slice copies nothing. It opens a second window over the same array — and both write into it.
№ 03La mécaniqueThe mechanics5 min

len est ce que tu vois. cap est ce que tu peux encore atteindre dans le tableau.len is what you see. cap is what you can still reach in the array.

Des trois mots de l'en-tête, le pointeur est facile : il dit où commence la fenêtre. Restent len et cap, qu'on confond tant qu'on n'a pas saisi qu'ils répondent à deux questions différentes. len(s) est la longueur visible : le nombre d'éléments que tu peux indexer, parcourir, afficher — la taille de la fenêtre. cap(s) est la capacité : le nombre d'éléments atteignables dans le tableau sous-jacent à partir du début de la fenêtre, jusqu'au bout du tableau. Quand tu tranches a[1:3], tu fixes len à 2, mais cap s'étend jusqu'à la fin du tableau de a — parce que ces cases existent encore, au-delà de ta fenêtre. C'est ce qui autorise à re-trancher une slice plus loin que sa longueur, dans la limite de sa capacité : la mémoire est là, simplement cachée. Et c'est aussi ce qui rend l'expression à trois indices, a[1:3:3], utile : elle borne la capacité, scelle le reste du tableau, et transforme une vue ouverte en vue close.Of the header's three words, the pointer is easy: it says where the window starts. That leaves len and cap, which you conflate until you grasp that they answer two different questions. len(s) is the visible length: the number of elements you can index, iterate, print — the window's size. cap(s) is the capacity: the number of elements reachable in the underlying array from the window's start, to the end of the array. When you slice a[1:3], you set len to 2, but cap extends to the end of a's array — because those cells still exist, beyond your window. That's what lets you re-slice a slice past its length, within its capacity: the memory is there, just hidden. And it's also what makes the three-index expression, a[1:3:3], useful: it bounds the capacity, seals the rest of the array, and turns an open view into a closed one.

len montre la fenêtre, cap garde le reste à portéelen shows the window, cap keeps the rest in reach
a := []int{10, 20, 30, 40, 50}   // len 5, cap 5
b := a[1:3]                      // len 2, cap 4

len(b)  // 2  → ce que b « contient » : ce qu'on indexe et parcourt
cap(b)  // 4  → ce qui reste ATTEIGNABLE dans le tableau, depuis b.ptr

// b ne montre que [20 30], mais le tableau dessous court jusqu'à 50.
// re-trancher au-delà de len, dans la limite de cap, est permis :
c := b[:4]                       // [20 30 40 50] — légal, on rouvre la vue

La distinction devient concrète quand tu re-tranches. b ne montre que deux éléments, mais comme son cap vaut 4, b[:4] est légal : tu rouvres la fenêtre sur des cases qui étaient là depuis le début, simplement hors de vue. len est une décision ; cap est une contrainte physique — la première, tu la choisis librement entre 0 et la seconde ; la seconde est dictée par le tableau réel. Tout ce que tu crois « hors » de ta slice peut, en réalité, être à un re-tranchage de distance.The distinction gets concrete when you re-slice. b shows only two elements, but since its cap is 4, b[:4] is legal: you reopen the window onto cells that were there all along, simply out of sight. len is a decision; cap is a physical constraint — the first you choose freely between 0 and the second; the second is dictated by the real array. Everything you think is "outside" your slice may in fact be one re-slice away.

Passer une slice : l'en-tête est copiéPassing a slice: the header is copied

Une slice passée à une fonction est passée par valeur — mais c'est l'en-tête qui est copié, pas le tableau. Conséquence à deux faces : écrire s[i] = x dans la fonction se voit chez l'appelant (même tableau), mais réaffecter s lui-même — un append, un re-tranchage — ne modifie que la copie locale du header et reste invisible. D'où l'idiome universel s = append(s, x) : on renvoie le nouvel en-tête, parce que la fonction ne pouvait pas le renvoyer à ta place.A slice passed to a function is passed by value — but it's the header that's copied, not the array. A two-faced consequence: writing s[i] = x in the function is seen by the caller (same array), but reassigning s itself — an append, a re-slice — modifies only the local copy of the header and stays invisible. Hence the universal idiom s = append(s, x): you return the new header, because the function couldn't return it for you.

cap est ce que append va lire.cap is what append will read.

Garde cap en tête, car c'est le chiffre que le numéro 2 met au centre. Quand tu fais append(s, x), Go regarde s'il reste de la capacité — len(s) < cap(s) — pour décider s'il écrit dans le tableau existant ou s'il en alloue un neuf. Tant qu'il y a du cap, append écrit en place, et toutes les slices qui partagent ce tableau voient la modification. Quand le cap est épuisé, append réalloue ailleurs, et la slice retournée se détache silencieusement des autres. Cette frontière — partagé tant qu'il y a du cap, divergent dès la réallocation — est le bug le plus subtil de Go, et le sujet entier du prochain numéro. Pour l'instant, retiens juste : len est ce que tu vois, cap est ce qu'append surveille.Keep cap in mind, because it's the number issue 2 puts at the center. When you do append(s, x), Go checks whether capacity remains — len(s) < cap(s) — to decide whether it writes into the existing array or allocates a new one. While there's cap, append writes in place, and every slice sharing that array sees the change. When cap is exhausted, append reallocates elsewhere, and the returned slice silently detaches from the others. That boundary — shared while there's cap, divergent once it reallocates — is Go's subtlest bug, and the whole subject of the next issue. For now, just remember: len is what you see, cap is what append watches.

Une slice ne contient pas ce qu'elle montre. Elle montre len éléments d'un tableau qui en tient cap — et le reste est juste hors champ.A slice doesn't contain what it shows. It shows len elements of an array that holds cap — and the rest is just off-frame.
№ 04Le piègeThe trap4 min

Renvoyer une sous-slice, c'est prêter ta mémoire. Quand tu veux la garder, copy.Returning a sub-slice lends out your memory. When you want to keep it, copy.

Le partage par défaut a deux conséquences pratiques qui mordent en production. La première est l'aliasing involontaire : une fonction qui renvoie b.data[:3] ne donne pas une copie des trois premiers éléments, elle donne une fenêtre sur son propre tampon interne. L'appelant peut écrire dedans et corrompre ton état, sans malice, en croyant manipuler ses propres données. La seconde est plus sournoise — une fuite mémoire. Une slice retient tout son tableau sous-jacent en vie, pas seulement les éléments qu'elle montre. Renvoie une vue de trois éléments découpée dans un tableau d'un million, et tant que cette petite vue existe, le million entier reste alloué, impossible à libérer pour le ramasse-miettes. Les deux problèmes ont le même remède, et c'est la seule façon d'obtenir une vraie indépendance en Go : copy. Allouer un tableau neuf avec make, y copier les éléments voulus, renvoyer ça. La copie coûte — c'est précisément pour ça que Go ne la fait pas pour toi — mais c'est le prix d'une slice qui ne partage plus rien.Sharing by default has two practical consequences that bite in production. The first is unintended aliasing: a function returning b.data[:3] doesn't give a copy of the first three elements, it gives a window onto its own internal buffer. The caller can write into it and corrupt your state, without malice, thinking they're handling their own data. The second is subtler — a memory leak. A slice keeps its entire underlying array alive, not just the elements it shows. Return a three-element view carved from a million-element array, and as long as that small view exists, the whole million stays allocated, impossible for the garbage collector to free. Both problems have the same remedy, and it's the only way to get true independence in Go: copy. Allocate a fresh array with make, copy the wanted elements into it, return that. The copy costs — which is precisely why Go doesn't do it for you — but it's the price of a slice that shares nothing anymore.

Trois éléments rendus, un million retenuThree elements returned, a million held
// renvoyer une sous-slice d'un tampon interne : deux fuites en une
func (b *Buffer) Head() []int {
    return b.data[:3]       // partage le tableau interne de b
}

h := buf.Head()
h[0] = 999                  // 1) l'appelant MUTE l'état interne de buf
// 2) tant que h vit, TOUT b.data reste en mémoire — même énorme :
//    une vue de 3 éléments peut retenir un tableau d'un million.

Les deux fuites cohabitent dans cette seule ligne return b.data[:3]. L'appelant tient une poignée sur ton tableau : il peut le réécrire (corruption d'état) et il l'empêche d'être collecté (rétention mémoire). Le second est traître parce qu'invisible — le programme ralentit, la RAM gonfle, et rien dans le code ne pointe la coupable : une petite slice innocente, quelque part, retient un océan. Une slice n'est pas légère parce qu'elle est courte ; elle pèse le poids du tableau qu'elle garde en vie.Both leaks coexist in this single line return b.data[:3]. The caller holds a handle on your array: they can rewrite it (state corruption) and they keep it from being collected (memory retention). The second is treacherous because invisible — the program slows, RAM swells, and nothing in the code points to the culprit: a small innocent slice, somewhere, holding back an ocean. A slice isn't light because it's short; it weighs the weight of the array it keeps alive.

Partager ou copier : une question de propriétéShare or copy: a question of ownership

On retrouve, dans la matière, la question qui traversait le volume 2 : qui possède cette donnée ? Quand tu renvoies une vue, tu renonces à la propriété exclusive — l'appelant et toi partagez le tableau, et chacun peut écraser l'autre. Quand tu renvoies une copy, tu transfères une propriété nette : ses octets sont à lui, les tiens restent à toi. Documenter ce choix fait partie du contrat d'une fonction autant que son type de retour. « Renvoie une vue, ne la mutez pas » et « renvoie une copie, faites-en ce que vous voulez » sont deux API différentes, même signature.You find, in matter, the question that ran through Volume 2: who owns this data? When you return a view, you give up exclusive ownership — the caller and you share the array, and each can clobber the other. When you return a copy, you transfer clean ownership: its bytes are theirs, yours stay yours. Documenting that choice is part of a function's contract as much as its return type. "Returns a view, don't mutate it" and "returns a copy, do as you like" are two different APIs, same signature.

Et quand le partage cesse tout seul.And when sharing stops on its own.

Tout ce numéro suppose un partage stable : deux slices regardent le même tableau, et le restent. Mais il existe une opération qui peut rompre ce lien sans prévenir — append. Tant qu'il reste de la capacité, append écrit dans le tableau partagé, et l'aliasing tient. Dès que la capacité est épuisée, append alloue un tableau neuf, recopie, et la slice retournée se détache : les autres vues, elles, regardent toujours l'ancien tableau. Si bien que deux slices peuvent partager leur mémoire à un instant, et diverger à l'instant suivant, selon un cap que tu ne vois pas. C'est la frontière la plus glissante de Go, et le sujet entier du prochain numéro. Vol. 5 №02 — append, la réallocation qui surprend.This whole issue assumes stable sharing: two slices look at the same array, and stay there. But there's an operation that can break that link without warning — append. While capacity remains, append writes into the shared array, and the aliasing holds. The moment capacity is exhausted, append allocates a fresh array, recopies, and the returned slice detaches: the other views still look at the old array. So two slices can share their memory one instant, and diverge the next, by a cap you can't see. It's Go's slipperiest boundary, and the whole subject of the next issue. Vol. 5 №02 — append, the realloc that surprises.

Une slice ne pèse pas ce qu'elle montre. Elle pèse le tableau qu'elle empêche de mourir — et copy est la seule coupure nette.A slice doesn't weigh what it shows. It weighs the array it keeps from dying — and copy is the only clean cut.
№ 05Bilan & éditoWrap-up & editorial2 min

Toute l'élégance des slices, et tous leurs pièges, tiennent dans un seul fait : c'est une vue.All the elegance of slices, and all their traps, hold in one fact: it's a view.

Le volume 5 ouvre sur le modèle de données, et la slice en est la porte parfaite : l'objet qu'on manipule sans cesse en se le représentant faux. Trois mots — pointeur, longueur, capacité — posés sur un tableau qui vit ailleurs. La copier copie ces trois mots, jamais les données : d'où b := a[1:3] qui, modifié, modifie a, car les deux fenêtrent le même tableau. len est ce qu'on voit, cap ce qu'on peut encore atteindre — et ce que append surveillera. Renvoyer une sous-slice prête sa mémoire et retient tout le tableau en vie ; copy est la seule coupure nette. Le fil tient en une phrase : une slice n'est pas un conteneur, c'est une vue — et tout le reste se déduit.Volume 5 opens on the data model, and the slice is its perfect doorway: the object you handle constantly while picturing it wrong. Three words — pointer, length, capacity — laid over an array living elsewhere. Copying it copies those three words, never the data: hence b := a[1:3] which, modified, modifies a, because both window the same array. len is what you see, cap what you can still reach — and what append will watch. Returning a sub-slice lends out your memory and keeps the whole array alive; copy is the only clean cut. The thread holds in one sentence: a slice isn't a container, it's a view — and everything else follows.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Trois motsThree wordsUne slice = ptr + len + cap, posés sur un tableau.A slice = ptr + len + cap, laid over an array.Tu la crois être le tableau, et tu attends une copie profonde.You think it is the array, and expect a deep copy.
Copier la vueCopy the viewAffecter ou trancher copie l'en-tête, partage le tableau.Assigning or slicing copies the header, shares the array.b := a[1:3] ; b[0] = … modifie a en silence.b := a[1:3]; b[0] = … silently modifies a.
len vs caplen vs caplen = ce qu'on voit ; cap = ce qu'on atteint dans le tableau.len = what you see; cap = what you reach in the array.Un re-tranchage ou un append te surprend par-derrière.A re-slice or an append surprises you from behind.
copy pour séparercopy to separatemake + copy quand tu veux une slice qui ne partage rien.make + copy when you want a slice that shares nothing.Mutations qui fuient, et un tableau géant retenu par 3 éléments.Leaking mutations, and a giant array held by 3 elements.
On a passé quatre volumes à déplacer des valeurs. Le cinquième regarde enfin de quoi elles sont faites — et la première, la slice, n'est pas ce qu'on croyait.We spent four volumes moving values. The fifth finally looks at what they're made of — and the first, the slice, isn't what we thought.
Mot de l'éditeurFrom the editor

Une slice est honnête : elle ne t'a jamais promis une copie. C'est nous qui l'avons lue comme un tableau.A slice is honest: it never promised you a copy. We're the ones who read it as an array.

La slice est l'exemple parfait d'un objet qu'on croit simple parce qu'on s'en sert tous les jours, et qu'on n'a jamais vraiment regardé. On écrit s[i], on tranche s[1:3], on passe s à une fonction, et tout marche — jusqu'au jour où une donnée change toute seule, où la RAM gonfle sans raison, où une fonction « pure » corrompt son entrée. À chaque fois, la même cause, le même malentendu de départ : on a lu une vue comme un conteneur. Go n'a rien caché — la slice expose len, cap, elle se comporte exactement comme trois mots qui pointent ailleurs doivent se comporter. La surprise n'est pas dans le langage ; elle est dans l'image mentale qu'on a plaquée dessus, héritée de langages où une liste est une chose qui se possède. Comprendre la slice, c'est désapprendre cette image, et la remplacer par la bonne : une fenêtre, pas une boîte.The slice is the perfect example of an object you think simple because you use it daily, and have never really looked at. You write s[i], slice s[1:3], pass s to a function, and it all works — until the day a piece of data changes by itself, RAM swells for no reason, a 'pure' function corrupts its input. Each time, the same cause, the same initial misunderstanding: you read a view as a container. Go hid nothing — the slice exposes len, cap, it behaves exactly as three words pointing elsewhere must behave. The surprise isn't in the language; it's in the mental image we pasted onto it, inherited from languages where a list is a thing you own. To understand the slice is to unlearn that image, and replace it with the right one: a window, not a box.

Et nous n'avons regardé qu'une vue immobile. Le partage décrit ici est stable : deux slices visent un tableau, et le font tant qu'on les laisse tranquilles. Reste l'opération qui les fait grandir — et qui, ce faisant, peut rompre ce partage sans le moindre signal. append écrit dans le tableau partagé tant qu'il reste de la capacité ; puis, le cap épuisé, il en alloue un neuf, recopie, et la slice retournée se détache des autres en silence. Deux slices solidaires à une ligne deviennent indépendantes à la suivante, selon un cap invisible. C'est, de l'avis de beaucoup, le bug le plus subtil que Go autorise — précisément parce qu'il dépend d'un nombre, cap, qu'on ne voit pas dans le code. Le prochain numéro va le rendre visible. Vol. 5 №02 — append, la réallocation qui surprend. On a vu la vue ; on va voir ce qui arrive quand elle pousse.And we've only looked at a still view. The sharing described here is stable: two slices point at an array, and do so as long as you leave them be. There remains the operation that makes them grow — and, doing so, can break that sharing with no signal at all. append writes into the shared array while capacity remains; then, cap exhausted, it allocates a fresh one, recopies, and the returned slice detaches from the others in silence. Two slices joined on one line become independent on the next, by an invisible cap. It is, in many people's view, the subtlest bug Go allows — precisely because it depends on a number, cap, you don't see in the code. The next issue makes it visible. Vol. 5 №02 — append, the realloc that surprises. We've seen the view; we'll see what happens when it grows.