go

Go Patterns

Reference for Go-specific patterns, idioms, and best practices. Full bibliography: references/sources.md.

Iron Law

ERRORS ARE VALUES [5][7]

Never ignore errors. if err != nil is correctness, not boilerplate. Every error return must be checked, wrapped with context, or explicitly documented as intentionally ignored with _ = fn(). "Errors are values. Values can be programmed." — Rob Pike [5]

When This Skill Activates

Working with Go codebases — error handling, interfaces, goroutines, channels, packages.

---

Error Handling [5][6]

// BAD: return err  — caller loses context
// GOOD: return fmt.Errorf("reading config %s: %w", path, err)

var ErrNotFound = errors.New("not found")

func FindUser(id string) (*User, error) {
    u, err := db.Get(id)
    if err != nil {
        return nil, fmt.Errorf("finding user %s: %w", id, err)
    }
    if u == nil { return nil, ErrNotFound }
    return u, nil
}
// Caller: if errors.Is(err, ErrNotFound) { ... }

---

Interface Design [7][14]

// "The bigger the interface, the weaker the abstraction" — Rob Pike [7]
// BAD: func NewService(repo *PostgresRepo) *Service
// GOOD: func NewService(repo Repository) *Service — accept interfaces [14]

// Small interfaces compose cleanly [1]
type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }
type ReadWriter interface { Reader; Writer }

---

Concurrency [9][10][13]

CSP (Hoare [9]): "Do not communicate by sharing memory; share memory by communicating." [10]

// Context cancellation with errgroup [16][22]
func Process(ctx context.Context, items []Item) error {
    g, ctx := errgroup.WithContext(ctx)
    for _, item := range items {
        g.Go(func() error { return processItem(ctx, item) })
    }
    return g.Wait()
}

// Channel direction prevents misuse at compile time [1][8]
func producer(ch chan<- int) { ch <- 42 }
func consumer(ch <-chan int) { v := <-ch; _ = v }