History of Go — Find the Bug¶

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    r := strings.NewReader("Hello from Go history!")
    // io.ReadAll replaced ioutil.ReadAll in Go 1.16
    data, err := io.ReadAll(r)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(string(data))
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // os.MkdirTemp replaced ioutil.TempDir in Go 1.16
    dir, err := os.MkdirTemp("", "myapp-")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer os.RemoveAll(dir)
    fmt.Println("Temp dir created:", dir)
}

package main

import (
    "fmt"
)

func main() {
    s := "Go was created in 2007"

    // Simple, safe conversion — Go compiler optimizes this well
    b := []byte(s)

    fmt.Println("Length:", len(b))
    fmt.Println("Content:", string(b))
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        // Fix 1: Pass i as a parameter to the closure (works in ALL Go versions)
        go func(n int) {
            defer wg.Done()
            fmt.Println("goroutine:", n)
        }(i)
    }

    wg.Wait()
}

package main

import "fmt"

type Version struct {
    Number string
    Year   int
}

func main() {
    versions := []Version{
        {"Go 1.0", 2012},
        {"Go 1.11", 2018},
        {"Go 1.22", 2024},
    }

    var ptrs []*Version
    for i := range versions {
        // Take pointer to the slice element directly, not the loop variable
        ptrs = append(ptrs, &versions[i])
    }

    for _, p := range ptrs {
        fmt.Printf("%s (%d)\n", p.Number, p.Year)
    }
}

package main

import (
    "errors"
    "fmt"
    "os"
)

type wrappedError struct {
    msg string
    err error
}

func (e *wrappedError) Error() string { return e.msg + ": " + e.err.Error() }
func (e *wrappedError) Unwrap() error { return e.err }

func openConfig() error {
    _, err := os.Open("/nonexistent/config.yaml")
    if err != nil {
        return &wrappedError{msg: "failed to open config", err: err}
    }
    return nil
}

func main() {
    err := openConfig()
    if err != nil {
        // Go 1.13+ style: errors.Is traverses the error chain via Unwrap()
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Config file not found, using defaults")
        } else {
            fmt.Println("Unexpected error:", err)
        }
    }
}

package main

import "fmt"

// Use interface{} for compatibility with Go versions before 1.18
func printType(v interface{}) {
    fmt.Printf("Type: %T, Value: %v\n", v, v)
}

func main() {
    printType(42)
    printType("Go 1.18 introduced generics")
    printType(true)
}

package main

import "fmt"

type Resource struct {
    Name string
}

func (r *Resource) Close() {
    fmt.Printf("Closing resource: %s\n", r.Name)
}

func openResource(name string) *Resource {
    fmt.Printf("Opening resource: %s\n", name)
    return &Resource{Name: name}
}

func main() {
    names := []string{"database", "cache", "queue"}

    for _, name := range names {
        r := openResource(name)
        // Fix: call Close directly without a closure, passing r as a bound argument
        defer r.Close()
    }
}

package main

import (
    "context"
    "fmt"
    "time"
)

// Properly context-aware function
func fetchFromDatabase(ctx context.Context, query string) (string, error) {
    // Use select to respect context cancellation
    select {
    case <-time.After(3 * time.Second): // Simulate slow query
        return "result for: " + query, nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

func handleRequest(timeout time.Duration) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    result, err := fetchFromDatabase(ctx, "SELECT * FROM versions")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Got:", result)
}

func main() {
    start := time.Now()
    handleRequest(500 * time.Millisecond)
    fmt.Printf("Took: %v\n", time.Since(start).Round(time.Millisecond))
}

package main

import (
    "context"
    "fmt"
    "time"
)

func fetchVersion(ctx context.Context, source string, delay time.Duration) (string, error) {
    select {
    case <-time.After(delay):
        return fmt.Sprintf("Go 1.22 (from %s)", source), nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

func getFirstResult() string {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel() // Cancels context, causing all goroutines to exit

    // Buffered channel: goroutines can send even if nobody reads
    ch := make(chan string, 3)

    sources := []struct {
        name  string
        delay time.Duration
    }{
        {"mirror-1", 2 * time.Second},
        {"mirror-2", 100 * time.Millisecond},
        {"mirror-3", 5 * time.Second},
    }

    for _, s := range sources {
        go func(name string, d time.Duration) {
            result, err := fetchVersion(ctx, name, d)
            if err != nil {
                return // Context cancelled, exit goroutine cleanly
            }
            ch <- result
        }(s.name, s.delay)
    }

    return <-ch
}

func main() {
    result := getFirstResult()
    fmt.Println("Result:", result)

    time.Sleep(1 * time.Second)
    fmt.Println("Done — no leaked goroutines!")
}