Go Developer Interview Prep Guide

Unbuffered channels block until both sender and receiver are ready (synchronization point). Buffered channels block only when full (sender) or empty (receiver). For the worker pool: create a jobs channel, a results channel, spawn N goroutines that range over jobs, and use sync.WaitGroup for completion tracking. For graceful shutdown, use context.WithCancel and select on ctx.Done().

Use a sliding window counter backed by Redis MULTI/EXEC for atomicity across instances. In Go, implement with a clean interface, use sync.RWMutex for local cache, and goroutine-safe access. Discuss token bucket vs sliding window tradeoffs, how to handle Redis failures (fail open vs fail closed), and how to return proper HTTP 429 responses with Retry-After headers.

An interface in Go is a tuple of (type, value). A nil interface has both nil type and nil value. A nil pointer in an interface has a non-nil type but nil value, so it is not equal to nil. This is a common source of bugs: if you return (*MyError)(nil) from a function returning error, the error check != nil will be true. Always return nil explicitly instead of a typed nil pointer.

Use pprof heap profiles to identify allocation sources. Check for: goroutine leaks (goroutines blocked on channels or context that are never cancelled), growing maps (maps in Go do not shrink), unclosed HTTP response bodies, time.Ticker not stopped, and slice capacity retention. Use runtime.NumGoroutine() to monitor goroutine count. Profile with go tool pprof comparing two snapshots over time.

Use Go generics with type parameters for key and value. sync.RWMutex for concurrent access, a doubly-linked list for LRU ordering, and a map for O(1) lookups. For TTL, either use lazy expiration (check on access) or a background goroutine with time.Ticker. Show proper use of generics with comparable constraint for keys and any for values. Handle the cache being closed with a context or stop channel.

Discuss the standard project layout: cmd/ for entry points, internal/ for private packages, pkg/ for public libraries. Follow the dependency rule: packages should depend inward (handlers -> service -> repository). Use interfaces for dependency injection at package boundaries. Avoid package-level state and init() functions. Discuss go.work for multi-module workspaces and how to manage internal vs external dependencies.

Discuss Go strengths: fast compilation, small binary size for containers, built-in concurrency, strong standard library for networking, and simple deployment. Provide a specific example with metrics: performance benchmarks, build time comparisons, deployment size reduction, or developer onboarding time. Also acknowledge Go limitations you encountered and how you worked around them.

Use http.Handler middleware pattern with closures. Create a span from the incoming trace context, inject trace ID into structured logger (slog), and use defer with recover() for panic handling. Show how context propagation works through the request lifecycle. Discuss how this middleware integrates with a middleware chain and why the order of middleware matters.