Ardan Labs Go Training 拆解：机械同情 + 数据导向设计 + 一致性哲学

gotraining/
├── topics/
│   ├── go/                       # 核心教学材料（Ultimate Go 课程主线）
│   │   ├── language/             #   18 章：变量 / 指针 / 数组 / slice / map / 接口 ...
│   │   ├── concurrency/          #   goroutine / channel / pattern / data race
│   │   ├── design/               #   composition / error_handling / packaging
│   │   ├── profiling/            #   pprof / trace / godebug / mutex / block
│   │   ├── testing/              #   tests / benchmark / fuzzing
│   │   ├── packages/             #   context / io / encoding / reflection / logging
│   │   ├── algorithms/           #   simulations (pi / sha256sum)
│   │   ├── exercises/            #   chatbot / sha256sum / contributors
│   │   ├── generics/             #   Go 1.18+ 泛型
│   │   └── videos/               #   配套视频索引
│   └── courses/go/                # 课程编排（README 链接）
├── reading/                      # 推荐阅读清单
├── env/                          # 课程环境配置（vim + zsh + tmux）
├── tools/                        # 教学用辅助脚本
├── vendor/                       # 依赖快照（教学环境离线可跑）
├── go.mod / go.sum
├── Opening.md                    # 课程开场白（必读）
└── README.md

// fanOut: 父 goroutine 创建 2000 个子 goroutine，等待它们都返回
func fanOut() {
    children := 2000
    ch := make(chan string, children)  // buffered，容量 = children，避免 send 阻塞

    for c := 0; c < children; c++ {
        go func(child int) {
            time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
            ch <- "data"
            fmt.Println("child : sent signal :", child)
        }(c)
    }

    for children > 0 {
        d := <-ch
        children--
        fmt.Println("parent : recv'd signal :", children)
    }
}

// pooling: 父 goroutine 把 100 个任务分发到一个 worker pool
func pooling() {
    ch := make(chan string)

    g := runtime.GOMAXPROCS(0)   // 取逻辑 processor 数
    for c := 0; c < g; c++ {
        go func(child int) {
            for d := range ch {        // 循环接收直到 channel close
                fmt.Printf("child %d : recv'd signal : %s\n", child, d)
            }
            fmt.Printf("child %d : recv'd shutdown signal\n", child)
        }(c)
    }

    const work = 100
    for w := 0; w < work; w++ {
        ch <- "data"
    }

    close(ch)   // 关键！没有 close，所有 worker 永远阻塞在 range
}

// cancellation: 父 goroutine 最多等 150ms，超过就放弃
func cancellation() {
    duration := 150 * time.Millisecond
    ctx, cancel := context.WithTimeout(context.Background(), duration)
    defer cancel()

    ch := make(chan string, 1)

    go func() {
        time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
        ch <- "data"
    }()

    select {
    case d := <-ch:
        fmt.Println("work complete", d)
    case <-ctx.Done():
        fmt.Println("work cancelled")
    }
}

// fanOutSem: 给 fan-out 加信号量，限制同时跑的子 goroutine 数
func fanOutSem() {
    children := 2000
    ch := make(chan string, children)

    g := runtime.GOMAXPROCS(0)
    sem := make(chan bool, g)   // 信号量：buffered channel 当 mutex 用

    for c := 0; c < children; c++ {
        go func(child int) {
            sem <- true        // 获取令牌
            {
                t := time.Duration(rand.Intn(200)) * time.Millisecond
                time.Sleep(t)
                ch <- "data"
                fmt.Println("child : sent signal :", child)
            }
            <-sem               // 释放令牌
        }(c)
    }
    // ... 接收部分同上 ...
}

// drop: 当子 goroutine 处理不过来时，主动丢弃任务
func drop() {
    const cap = 100
    ch := make(chan string, cap)

    go func() {
        for p := range ch {
            fmt.Println("child : recv'd signal :", p)
        }
    }()

    const work = 2000
    for w := 0; w < work; w++ {
        select {
        case ch <- "data":
            fmt.Println("parent : sent signal :", w)
        default:
            fmt.Println("parent : dropped data :", w)   // 满了就丢，不要阻塞父
        }
    }

    close(ch)
}

// boundedWorkPooling: pool of workers service a fixed amount of work
func boundedWorkPooling() {
    work := []string{"paper", "paper", "paper", "paper", 2000: "paper"}  // 2004 个任务

    g := runtime.GOMAXPROCS(0)
    var wg sync.WaitGroup
    wg.Add(g)

    ch := make(chan string, g)

    for c := 0; c < g; c++ {
        go func(child int) {
            defer wg.Done()
            for wrk := range ch {
                fmt.Printf("child %d : recv'd signal : %s\n", child, wrk)
            }
        }(c)
    }

    for _, wrk := range work {
        ch <- wrk
    }
    close(ch)
    wg.Wait()
}

// topics/go/concurrency/goroutines/example1/example1.go

func init() {
    // 关键：只给 scheduler 1 个 logical processor
    // 这样能看清楚 goroutine 之间的协作/调度细节
    runtime.GOMAXPROCS(1)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    fmt.Println("Start Goroutines")

    go func() {
        lowercase()
        wg.Done()
    }()

    go func() {
        uppercase()
        wg.Done()
    }()

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("\nTerminating Program")
}

// topics/go/language/pointers/example1/example1.go

func main() {
    count := 10
    println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")

    increment(count)   // 传"值"，函数拿到的是拷贝

    println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
    // ↑ count 还是 10，因为 increment 改的是它的拷贝
}

func increment(inc int) {
    inc++
    println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]")
    // ↑ inc 是 11，但地址不同（栈帧不同）
}

// topics/go/language/interfaces/example1/example1.go

// reader 是接口，定义"读"这个动作
type reader interface {
    read(b []byte) (int, error)
}

// file 实现 reader
type file struct {
    name string
}

func (file) read(b []byte) (int, error) {
    s := "<rss><channel><title>Going Go Programming</title></channel></rss>"
    copy(b, s)
    return len(s), nil
}

// pipe 也实现 reader
type pipe struct {
    name string
}

func (pipe) read(b []byte) (int, error) {
    s := `{name: "bill", title: "developer"}`
    copy(b, s)
    return len(s), nil
}

func main() {
    f := file{"data.json"}
    p := pipe{"cfg_service"}

    retrieve(f)
    retrieve(p)
}

// retrieve 能处理任何实现了 reader 的类型
func retrieve(r reader) error {
    data := make([]byte, 100)
    len, err := r.read(data)
    if err != nil {
        return err
    }
    fmt.Println(string(data[:len]))
    return nil
}

// topics/go/design/error_handling/example1/example1.go

// 标准库的 error 接口（重新展示一下）
type error interface {
    Error() string
}

// 标准库的 errorString 类型
type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

// New 构造一个 error
func New(text string) error {
    return &errorString{text}
}

func main() {
    if err := webCall(); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Life is good")
}

func webCall() error {
    return New("Bad Request")
}

func TestCalculate(t *testing.T) {
    tests := []struct {
        name     string
        input    int
        expected int
    }{
        {"zero", 0, 0},
        {"one", 1, 1},
        {"negative", -5, -25},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Calculate(tt.input); got != tt.expected {
                t.Errorf("Calculate(%d) = %d, want %d", tt.input, got, tt.expected)
            }
        })
    }
}

// 一个泛型函数
func Map[T, U any](s []T, f func(T) U) []U {
    r := make([]U, len(s))
    for i, v := range s {
        r[i] = f(v)
    }
    return r
}

// 使用
nums := []int{1, 2, 3}
doubled := Map(nums, func(n int) int { return n * 2 })
// doubled == []int{2, 4, 6}

strs := []string{"a", "b", "c"}
upper := Map(strs, func(s string) string { return strings.ToUpper(s) })
// upper == []string{"A", "B", "C"}

第 1 周  language/variables → language/constants → language/functions
        （建立 Go 语法直觉）

第 2 周  language/pointers → language/struct_types → language/arrays
        （理解值语义和内存布局）

第 3 周  language/slices → language/maps → language/embedding
        （掌握内置容器 + 嵌入组合）

第 4 周  language/interfaces → language/methods
        （多态与"接口属于消费者"哲学）

第 5 周  design/composition → design/error_handling → design/packaging
        （从语法到设计哲学）

第 6 周  concurrency/goroutines → concurrency/channels
        （最重要的一章）

第 7 周  concurrency/patterns → concurrency/data_race
        （工业级模式 + race detector）

第 8 周  profiling/pprof → profiling/trace
        （性能分析与调度行为）

第 9 周  testing/tests → testing/benchmarks → testing/fuzzing
        （测试三件套）

第 10 周 generics → exercises/* → algorithms/*
        （泛型 + 综合练习）