package main
import "fmt"

func binSearch(a []int, t int) bool {
    l, r := 0, len(a)-1
    for l <= r {
        m := (l + r) / 2
        if a[m] == t { return true }
        if a[m] < t { l = m + 1 } else { r = m - 1 }
    }
    return false
}

func main() {
    nums := []int{1,4,7,9,15,20,33,42}
    fmt.Println(binSearch(nums, 33))
    fmt.Println(binSearch(nums, 100))
}

package main

import (
    "fmt"
)

type S struct {
    v int
}

func (s S) Value() int {
    return s.v
}

type I interface {
    Value() int
}

func mutate(i I) {
    // Мы думаем, что меняем реальный объект...
    if s, ok := i.(S); ok {
        s.v = 100
    }
}

func main() {
    s := S{v: 10}
    var i I = s

    mutate(i)

    fmt.Println(s.v)  // ???
    fmt.Println(i.Value()) // ???
}

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)
}

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 http://localhost:6060/debug/pprof/goroutineleak

package main

import "fmt"

func main() {
    height := 8
    for i := 1; i <= height; i++ {
        // пробелы
        for s := 0; s < height-i; s++ {
            fmt.Print(" ")
        }
        // ветви
        for j := 0; j < 2*i-1; j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
    // ствол
    for i := 0; i < 2; i++ {
        for s := 0; s < height-1; s++ {
            fmt.Print(" ")
        }
        fmt.Println("|")
    }
}

package main

import "fmt"

func add(s []int) {
    s = append(s, 99)
}

func main() {
    a := make([]int, 2, 4)
    a[0], a[1] = 1, 2

    add(a)

    fmt.Println("a:", a)
    fmt.Println("a[:3]:", a[:3])
}

import "fmt"

func add(s []int) {
    s = append(s, 99)
    s[0] = 42
}

func main() {
    a := []int{1, 2}
    add(a)

    fmt.Println("a:", a)
}

var err error = nil
fmt.Println(err == nil) // true

var e *MyError = nil
var err error = e
fmt.Println(err == nil) // false (!)

2. Typed nil vs untyped nil
var p *int = nil
var s []int = nil
var m map[string]int = nil

3. Panic из-за nil внутри interface
type User struct{}

func (u *User) Name() string {
    return "John"
}

var u *User = nil
var i interface{} = u

i.(*User).Name() // panic

func do() error {
    var e *MyError = nil
    return e
}

func do() error {
    if somethingWrong {
        return &MyError{}
    }
    return nil
}

interface != nil, если внутри typed nil

package main

import (
 "fmt"
 "unsafe"
)

type Foo struct {
 A int64
}

type IFoo interface {
 Get() int64
}

func (f Foo) Get() int64 { return f.A }

func main() {
 var a int64 = 10
 var s Foo = Foo{A: 42}
 var i IFoo = s

 fmt.Println(unsafe.Sizeof(a))
 fmt.Println(unsafe.Sizeof(s))
 fmt.Println(unsafe.Sizeof(i))
}