8. Tricky Slices

The Core Problem

When you use append(), it can either:

• Reuse the existing underlying array (if there's room)

• Create a new array (if it's full)

The tricky part is you can't always predict which one will happen, which leads to surprising bugs.

Let's Start Simple: What is Capacity?

slice := make([]int, 3, 8)
//                   ^  ^
//                   |  |
//              length  capacity

• Length = how many elements are currently in the slice (3)

• Capacity = how much total space is allocated in the underlying array (8)

Think of it like a parking lot:

• Length = cars currently parked (3 cars)

• Capacity = total parking spaces (8 spaces)

• You have 5 empty spaces available

Example 1: Why It Works

a := make([]int, 3)  // length=3, capacity=3 (full!)

Visual representation:

a → [0][0][0]  (all 3 spaces full)

Now append to create b:

b := append(a, 4)  // a is full, so create NEW array

What happens:

a → [0][0][0]           (original array, unchanged)

b → [0][0][0][4]        (NEW array, bigger)

Since a was full (length = capacity), append creates a new array for b. They're completely separate now!

Then:

c := append(a, 5)  // a is still full, create ANOTHER new array

Result:

a → [0][0][0]           (original, still unchanged)
b → [0][0][0][4]        (its own array)
c → [0][0][0][5]        (its own array)

✅ Everyone has their own array. No surprises!

Example 2: The Trap

i := make([]int, 3, 8)  // length=3, capacity=8 (5 empty spaces!)

Visual representation:

i → [0][0][0][_][_][_][_][_]
     ^^^^^^^  ^^^^^^^^^^^^^^^^
     length=3  capacity=8 (5 empty spots)

Now append to create j:

j := append(i, 4)  // i has room, so REUSE the same array

What happens:

Same underlying array:
[0][0][0][4][_][_][_][_]
 ^^^^^^^                  i still sees these 3
 ^^^^^^^^^^               j now sees these 4 (SAME ARRAY!)

Key point: They're sharing the same underlying array!

Now the dangerous part:

g := append(i, 5)  // i still has room, REUSE again

What happens:

Same underlying array:
[0][0][0][5][_][_][_][_]
 ^^^^^^^                  i still sees these 3
 ^^^^^^^^^^               j sees these 4 (but [3] changed!)
 ^^^^^^^^^^               g sees these 4

i → [0, 0, 0]      (sees first 3)
j → [0, 0, 0, 5]   (sees first 4, including the 5!)
g → [0, 0, 0, 5]   (sees first 4, including the 5!)

❌ The 5 overwrote the 4! Both j and g now show 5 because they're looking at the same array.

The Memory Address Proof

fmt.Println("addr of j:", &j[0])  // 0x454000
fmt.Println("addr of g:", &g[0])  // 0x454000  ← SAME ADDRESS!

Same address = same underlying array = changes affect both!

Why This Happens

someSlice = append(otherSlice, element)  // ❌ DANGEROUS!

The problem:

• append(otherSlice, element) might reuse otherSlice's array

• You assign the result to someSlice (different variable)

• Now someSlice and otherSlice secretly share an array

• Changes to one affect the other!

Safe Pattern

mySlice = append(mySlice, element)  // ✅ SAFE

Why this is safe:

• You're assigning back to the same variable

• No confusion about who "owns" the underlying array

• If a new array is created, mySlice points to it

• No other variable is affected

Real-World Analogy

Imagine you have a notebook with 10 pages, but only 3 are written on:

Dangerous way:

notebook1 := myNotebook                    // 3 pages used, 7 blank
notebook2 := append(notebook1, "page 4")   // writes on page 4
notebook3 := append(notebook1, "page 4")   // OVERWRITES page 4!

Both notebook2 and notebook3 point to the same physical notebook, so they see the same page 4!

Safe way:

myNotebook := myNotebook                   // 3 pages used
myNotebook = append(myNotebook, "page 4")  // write on page 4
myNotebook = append(myNotebook, "page 5")  // write on page 5

Only one variable, one notebook, no confusion!

Questions to Check Your Understanding

1. If a slice has len=5 and cap=10, will append create a new array?

No, it will reuse the existing array because there's room (5 empty spaces left).

2. If a slice has len=10 and cap=10, will append create a new array?

Yes, it's full, so append must create a bigger array.

3. Why is b = append(a, x) dangerous?

If `a` has spare capacity, `b` will share `a`'s underlying array, so changes can affect both unexpectedly.