❓ Что выведет программа?

И объясни, почему вывод - НЕ тот, который ожидает большинство 🙂

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4}
    t := s[:2]   // [1 2]
    u := s[2:]   // [3 4]

    // Изменяем через t
    t = append(t, 9)

    // Изменяем через u
    u[0] = 99

    fmt.Println("s:", s)
    fmt.Println("t:", t)
    fmt.Println("u:", u)
}

🔥 Разбор

t := s[:2] и u := s[2:] смотрят на один и тот же underlying array

но append(t, 9) может либо
• дописать в тот же массив, либо
• выделить новый, если capacity закончилась

Именно тут начинается путаница:

если capacity исходного s >= 5 — append изменит исходный массив, и s, t, u будут видеть изменения друг друга

если capacity = 4 — append создаст новый backing array, и t “оторвётся” от s и u

То есть вывод зависит от capacity, а её большинство разработчиков не проверяют, но предполагают.

✔️ Добавим интриги — сделай capacity явной 👇
s := make([]int, 4, 4) // capacity = length
copy(s, []int{1,2,3,4})


Теперь:

- append(t, 9) создаёт новый массив

и t уже не связан с s

Вывод будет:

```
s: [1 2 99 4]
t: [1 2 9]
u: [99 4]

```
Но если capacity увеличить:

```go
s := make([]int, 4, 10) // capacity > length
copy(s, []int{1,2,3,4})

```

Мы получим:


```
s: [1 2 9 99]
t: [1 2 9]
u: [99 4]

```

Потому что в этот раз append записал в тот же underlying array.

В Go поведение slice зависит от capacity --и два, казалось бы, одинаковых куска кода могут работать по-разному без единой строки изменения.

👉 Запустить код

🚀 Как Go 1.26 ловит утечки горутин

Перед тобой классический пример утечки goroutine, который долгое время было сложно отлавливать автоматически.

Проблема возникает, когда:
- используются небуферизированные каналы
- запускаются goroutine в цикле
- происходит ранний return по ошибке

В такой ситуации часть goroutine продолжает попытки записи в канал, но получателя уже нет — они зависают навсегда.

Раньше такие баги:
- проявлялись только под нагрузкой
- маскировались как рост памяти или странные тайминги
- находились уже в продакшене

В Go 1.26 runtime научился детектить такие утечки автоматически, если включено профилирование.

func fetchUsers(ids []int) ([]*User, error) {
    ch := make(chan *User)

    for _, id := range ids {
        go func(id int) {
            user := fetchUser(id)
            ch <- user // блокируется навсегда при раннем return
        }(id)
    }

    for range ids {
        user := <-ch
        if user == nil {
            return nil, errors.New("failed") // LEAK: другие goroutine зависли
        }
    }
    return nil, nil
}

Запуск с детекцией утечек goroutine
GOEXPERIMENT=goroutineleakprofile go run main.go

Проверка профиля
curl https://localhost:6060/debug/pprof/goroutineleak

https://www.youtube.com/shorts/Wvimjygw_ys