Go Programming Expertise

Key Principles

• Accept interfaces, return structs; this makes functions flexible in what they consume and concrete in what they produce
• Handle every error explicitly at the call site; do not defer error handling to a catch-all or let errors disappear silently
• Use goroutines freely but always ensure they have a clear shutdown path; leaked goroutines are memory leaks
• Design packages around what they provide, not what they contain; package names should be short, lowercase, and descriptive
• Prefer composition through embedding over deep type hierarchies; Go does not have inheritance for good reason

Techniques

• Use

  context.Context

  as the first parameter of every function that does I/O or long-running work; propagate cancellation and deadlines through the call chain
• Apply the fan-out/fan-in pattern: spawn N worker goroutines reading from a shared input channel and sending results to an output channel collected by a single consumer
• Use

  errgroup.Group

  from

  golang.org/x/sync/errgroup

  to manage groups of goroutines with shared error propagation and context cancellation
• Wrap errors with

  fmt.Errorf("operation failed: %w", err)

  to build error chains; check with

  errors.Is()

  and

  errors.As()

  for specific error types
• Write table-driven tests with

  []struct{ name string; input T; want U }

  slices and

  t.Run(tc.name, ...)

  subtests for clear, maintainable test suites
• Use

  sync.Once

  for lazy initialization,

  sync.Map

  only for append-heavy concurrent maps, and

  sync.Pool

  for reducing GC pressure on frequently allocated objects

Common Patterns

• Done Channel: Pass a

  done <-chan struct{}

  to goroutines; when the channel is closed, all goroutines reading from it receive the zero value and can exit cleanly
• Functional Options: Define

  type Option func(*Config)

  and provide functions like

  WithTimeout(d time.Duration) Option

  for flexible, backwards-compatible API configuration
• Middleware Chain: Compose HTTP handlers as

  func(next http.Handler) http.Handler

  closures that wrap each other for logging, authentication, and rate limiting
• Worker Pool: Create a fixed-size pool with a buffered channel as a semaphore: send to acquire, receive to release, limiting concurrent resource usage

Pitfalls to Avoid

• Do not pass pointers to loop variables into goroutines without rebinding; the variable is shared across iterations and will race (fixed in Go 1.22+ but be explicit for clarity)
• Do not use

  init()

  functions for complex setup; they make testing difficult, hide dependencies, and run in unpredictable order across packages
• Do not reach for channels when a mutex is simpler; channels are for communication between goroutines, mutexes are for protecting shared state
• Do not return concrete types from interfaces in exported APIs; this creates tight coupling and prevents consumers from providing test doubles