History of Go — Optimize the Code¶

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

// Fast version — uses os package (Go 1.16+ style)
func readAllFiles(dir string) (int, error) {
    // os.ReadDir returns []os.DirEntry — no stat call per entry
    entries, err := os.ReadDir(dir)
    if err != nil {
        return 0, err
    }

    totalBytes := 0
    for _, entry := range entries {
        if entry.IsDir() {
            continue
        }
        // os.ReadFile replaced ioutil.ReadFile since Go 1.16
        data, err := os.ReadFile(filepath.Join(dir, entry.Name()))
        if err != nil {
            return 0, err
        }
        totalBytes += len(data)
    }
    return totalBytes, nil
}

func main() {
    n, err := readAllFiles("/tmp/testdata")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("Total bytes read: %d\n", n)
}

package main

import (
    "fmt"
    "strconv"
    "strings"
)

type Record struct {
    ID   int
    Name string
    Age  int
}

// Fast version — strings.Builder (Go 1.10+)
func buildCSV(records []Record) string {
    var b strings.Builder
    // Pre-allocate: ~20 bytes per record + header
    b.Grow(len(records)*20 + 12)

    b.WriteString("id,name,age\n")
    for _, r := range records {
        b.WriteString(strconv.Itoa(r.ID))
        b.WriteByte(',')
        b.WriteString(r.Name)
        b.WriteByte(',')
        b.WriteString(strconv.Itoa(r.Age))
        b.WriteByte('\n')
    }
    return b.String()
}

func main() {
    records := make([]Record, 10000)
    for i := range records {
        records[i] = Record{ID: i, Name: "user", Age: 25}
    }
    csv := buildCSV(records)
    fmt.Printf("CSV length: %d\n", len(csv))
}

package main

import (
    "errors"
    "fmt"
    "strconv"
)

// Fast version — Go 1.13+ error wrapping with %w
func parseUserID(s string) (int, error) {
    id, err := strconv.Atoi(s)
    if err != nil {
        // Go 1.13+: %w wraps the error, preserving the chain
        return 0, fmt.Errorf("parseUserID: invalid id %q: %w", s, err)
    }
    if id <= 0 {
        return 0, fmt.Errorf("parseUserID: id must be positive, got %d", id)
    }
    return id, nil
}

func loadUser(idStr string) (string, error) {
    id, err := parseUserID(idStr)
    if err != nil {
        // %w instead of %s — preserves error chain
        return "", fmt.Errorf("loadUser failed: %w", err)
    }
    if id == 42 {
        return "", fmt.Errorf("loadUser: user %d is banned", id)
    }
    return fmt.Sprintf("User-%d", id), nil
}

func handleRequest(idStr string) error {
    _, err := loadUser(idStr)
    if err != nil {
        return fmt.Errorf("handleRequest error: %w", err)
    }
    return nil
}

func main() {
    err := handleRequest("abc")
    if err != nil {
        fmt.Println("Error:", err)
        // Now errors.As works because the chain is preserved
        var numErr *strconv.NumError
        fmt.Println("Is NumError?", errors.As(err, &numErr)) // true!
        if numErr != nil {
            fmt.Println("Original error:", numErr)
        }
    }
}

package main

import (
    "fmt"
    "math"
)

type Point struct {
    X, Y float64
}

type ProcessedPoint struct {
    X, Y     float64
    Distance float64
    Quadrant int
}

// Fast version — pre-allocated slice capacity
func processPoints(points []Point) []ProcessedPoint {
    // Pre-allocate to max possible size — one allocation, no copies
    result := make([]ProcessedPoint, 0, len(points))

    for _, p := range points {
        dist := math.Sqrt(p.X*p.X + p.Y*p.Y)
        if dist < 1.0 {
            continue
        }

        quadrant := 0
        if p.X >= 0 && p.Y >= 0 {
            quadrant = 1
        } else if p.X < 0 && p.Y >= 0 {
            quadrant = 2
        } else if p.X < 0 && p.Y < 0 {
            quadrant = 3
        } else {
            quadrant = 4
        }

        result = append(result, ProcessedPoint{
            X:        p.X,
            Y:        p.Y,
            Distance: dist,
            Quadrant: quadrant,
        })
    }

    return result
}

func main() {
    points := make([]Point, 100000)
    for i := range points {
        points[i] = Point{X: float64(i%200 - 100), Y: float64(i%300 - 150)}
    }
    result := processPoints(points)
    fmt.Printf("Processed %d points\n", len(result))
}

package main

import (
    "cmp"
    "fmt"
    "slices"
)

type Employee struct {
    Name       string
    Department string
    Salary     int
    YearsExp   int
}

// Fast version — slices.SortFunc with generics (Go 1.21+)
func sortEmployees(employees []Employee) {
    slices.SortFunc(employees, func(a, b Employee) int {
        // Descending by salary
        if c := cmp.Compare(b.Salary, a.Salary); c != 0 {
            return c
        }
        // Ascending by name as tiebreaker
        return cmp.Compare(a.Name, b.Name)
    })
}

func main() {
    employees := make([]Employee, 50000)
    for i := range employees {
        employees[i] = Employee{
            Name:       fmt.Sprintf("Employee-%05d", i),
            Department: fmt.Sprintf("Dept-%d", i%20),
            Salary:     30000 + (i%100)*1000,
            YearsExp:   i % 30,
        }
    }
    sortEmployees(employees)
    fmt.Printf("Top salary: %s = %d\n", employees[0].Name, employees[0].Salary)
}

package main

import (
    "context"
    "fmt"
    "math/rand"
    "sync"
    "time"
)

type Result struct {
    WorkerID int
    Data     string
}

// Fast version — context.WithTimeout (Go 1.7+)
func fetchAll(ctx context.Context, urls []string) []Result {
    resultCh := make(chan Result, len(urls))
    var wg sync.WaitGroup

    for i, url := range urls {
        wg.Add(1)
        go func(id int, u string) {
            defer wg.Done()
            // Simulate work
            workTime := time.Duration(rand.Intn(100)) * time.Millisecond

            select {
            case <-ctx.Done():
                return // context cancelled or timed out
            case <-time.After(workTime):
                // Work completed
            }

            select {
            case <-ctx.Done():
                return
            case resultCh <- Result{WorkerID: id, Data: u + "-fetched"}:
            }
        }(i, url)
    }

    go func() {
        wg.Wait()
        close(resultCh)
    }()

    var results []Result
    for r := range resultCh {
        results = append(results, r)
    }
    return results
}

func main() {
    urls := make([]string, 100)
    for i := range urls {
        urls[i] = fmt.Sprintf("https://api.example.com/data/%d", i)
    }

    // Context handles timeout + cleanup automatically
    ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
    defer cancel() // Always call cancel to release resources

    results := fetchAll(ctx, urls)
    fmt.Printf("Got %d results\n", len(results))
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

// Fast version — streaming I/O with buffering
func filterLogFile(inputPath, outputPath, keyword string) error {
    inFile, err := os.Open(inputPath)
    if err != nil {
        return fmt.Errorf("opening input: %w", err)
    }
    defer inFile.Close()

    outFile, err := os.Create(outputPath)
    if err != nil {
        return fmt.Errorf("creating output: %w", err)
    }
    defer outFile.Close()

    // Buffered writer — batches writes, reduces syscalls
    writer := bufio.NewWriterSize(outFile, 64*1024) // 64KB buffer
    defer writer.Flush()

    // Streaming scanner — reads line by line, never loads full file
    scanner := bufio.NewScanner(inFile)
    // Increase scanner buffer for long lines
    scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)

    for scanner.Scan() {
        line := scanner.Text()
        if strings.Contains(line, keyword) {
            writer.WriteString(line)
            writer.WriteByte('\n')
        }
    }

    if err := scanner.Err(); err != nil {
        return fmt.Errorf("scanning: %w", err)
    }
    return nil
}

func main() {
    err := filterLogFile("/var/log/syslog", "/tmp/filtered.log", "ERROR")
    if err != nil {
        fmt.Println("Error:", err)
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "math/rand"
    "sync"
)

type Request struct {
    UserID int      `json:"user_id"`
    Tags   []string `json:"tags"`
}

type Response struct {
    Message string `json:"message"`
    Score   int    `json:"score"`
}

// Pool for reusable byte buffers
var bufPool = sync.Pool{
    New: func() any {
        return bytes.NewBuffer(make([]byte, 0, 256))
    },
}

// Pool for reusable response byte slices
var respBufPool = sync.Pool{
    New: func() any {
        return bytes.NewBuffer(make([]byte, 0, 512))
    },
}

// Fast version — sync.Pool reuses buffers across calls
func processRequest(reqData []byte) ([]byte, error) {
    var req Request
    if err := json.Unmarshal(reqData, &req); err != nil {
        return nil, err
    }

    // Get buffer from pool instead of allocating
    buf := bufPool.Get().(*bytes.Buffer)
    buf.Reset()

    buf.WriteString("Processed user ")
    fmt.Fprintf(buf, "%d", req.UserID)
    buf.WriteString(" with tags: ")
    for i, tag := range req.Tags {
        if i > 0 {
            buf.WriteString(", ")
        }
        buf.WriteString(tag)
    }

    resp := Response{
        Message: buf.String(),
        Score:   rand.Intn(100),
    }

    // Return buffer to pool
    bufPool.Put(buf)

    // Use pooled buffer for JSON encoding
    respBuf := respBufPool.Get().(*bytes.Buffer)
    respBuf.Reset()

    encoder := json.NewEncoder(respBuf)
    if err := encoder.Encode(resp); err != nil {
        respBufPool.Put(respBuf)
        return nil, err
    }

    // Copy result before returning buffer to pool
    result := make([]byte, respBuf.Len()-1) // -1 to strip trailing newline
    copy(result, respBuf.Bytes())
    respBufPool.Put(respBuf)

    return result, nil
}

func main() {
    for i := 0; i < 100000; i++ {
        reqData := []byte(fmt.Sprintf(`{"user_id":%d,"tags":["go","perf","opt"]}`, i))
        _, err := processRequest(reqData)
        if err != nil {
            fmt.Println("Error:", err)
        }
    }
    fmt.Println("Done processing 100000 requests")
}

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// Fast version — atomic operations (Go 1.19+ typed atomics)
type Metrics struct {
    RequestCount   atomic.Int64
    ErrorCount     atomic.Int64
    BytesProcessed atomic.Int64
    ActiveRequests atomic.Int64
}

func (m *Metrics) RecordRequest(bytes int64) {
    m.RequestCount.Add(1)
    m.BytesProcessed.Add(bytes)
    m.ActiveRequests.Add(1)
}

func (m *Metrics) RecordError() {
    m.ErrorCount.Add(1)
}

func (m *Metrics) RequestDone() {
    m.ActiveRequests.Add(-1)
}

func (m *Metrics) Snapshot() (requests, errors, bytes, active int64) {
    // Each Load is atomic; snapshot is eventually consistent
    return m.RequestCount.Load(),
        m.ErrorCount.Load(),
        m.BytesProcessed.Load(),
        m.ActiveRequests.Load()
}

func main() {
    m := &Metrics{}
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 10000; j++ {
                m.RecordRequest(256)
                if j%10 == 0 {
                    m.RecordError()
                }
                m.RequestDone()
            }
        }(i)
    }

    wg.Wait()
    reqs, errs, bytes, active := m.Snapshot()
    fmt.Printf("Requests: %d, Errors: %d, Bytes: %d, Active: %d\n",
        reqs, errs, bytes, active)
}