Intro

// ===== The values =====
// - Small spec, easy to read across teams
// - Static typing without ceremony
// - Built-in concurrency (goroutines + channels)
// - Excellent standard library (net/http, encoding/json, testing)
// - Single binary deploys, no runtime to ship

// ===== Hello, world =====
package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}

// Build + run:
//   go run .
//   go build -o app && ./app

// ===== A tiny HTTP server =====
package main

import (
    "encoding/json"
    "net/http"
)

func main() {
    http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("content-type", "application/json")
        json.NewEncoder(w).Encode(map[string]any{"ok": true})
    })
    http.ListenAndServe(":8080", nil)
}

// ===== Goroutines + channels =====
package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    out := make(chan int)

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            out <- n * n
        }(i)
    }
    go func() { wg.Wait(); close(out) }()
    for v := range out { fmt.Println(v) }
}

// ===== When Go wins =====
// - APIs and microservices
// - CLI tools (single binary, cross-compile)
// - Networking + concurrency
// - Replacing Python services that need speed

// ===== When Go hurts =====
// - Heavy generic algorithms (improving with generics, still verbose)
// - GUI / desktop (immature ecosystem)
// - Data science (Python wins here)

// ===== Patterns to internalise =====
// - Errors as values; if err != nil { return err }
// - Small interfaces; satisfy implicitly
// - go fmt + go vet + staticcheck on save
// - context.Context as the first param of any I/O function

// ===== Pitfalls =====
// - Goroutines without bounded concurrency -> resource exhaustion
// - Ignoring err -> silent failures
// - Slice gotchas (shared backing arrays)
// - Capturing loop variables in closures (Go 1.22+ fixed; still appears in older code)

// Go is statically typed, compiled, garbage-collected.
// Designed at Google in 2007 for fast servers and tooling.