Go · Intermediate interview

any (alias for interface{}) holds a value of any type, which you recover with a type assertion v, ok := x.(string) or a type switch to branch on the dynamic type. It's how you write generic-ish code pre-generics, but it loses static typing, so you prefer concrete types or generics where possible. The ok form avoids a panic when the assertion fails.

switch v := x.(type) {
case string: useString(v)
case int: useInt(v)
}

Embedding includes one type inside another (a struct or interface) so the outer type promotes the embedded type's fields and methods as if they were its own. It's composition, not inheritance — there's no subtype polymorphism, just method promotion and delegation. It's how Go reuses behaviour and builds bigger interfaces from smaller ones.

Generics (type parameters, added in Go 1.18) let you write functions and types that work over a set of types with compile-time safety, constrained by interfaces — e.g. a Map/Filter or a generic container. You use them to avoid duplicating code per type or resorting to any with assertions. The guidance is to use them when you'd otherwise copy-paste or lose type safety, not everywhere.

func Map[T, U any](s []T, f func(T) U) []U { ... }

An unbuffered channel has no capacity: a send blocks until a receiver is ready, so it's a synchronization point (a handoff). A buffered channel holds up to N values; sends only block when the buffer is full and receives when it's empty. You use unbuffered for strict handoff/synchronization and buffered to decouple producer and consumer speeds up to a bound.

select waits on multiple channel operations and proceeds with whichever is ready, picking randomly among several ready cases. With a default case it becomes non-blocking; combined with a context's Done channel or a timeout, it implements cancellation and timeouts. It's the core tool for coordinating multiple channels.

select {
case v := <-ch: use(v)
case <-ctx.Done(): return ctx.Err()
}

Channels are great for passing ownership of data and coordinating goroutines, but for simply protecting shared state a sync.Mutex is clearer and faster. sync.WaitGroup waits for a group of goroutines to finish; sync.Once runs initialization exactly once; atomic ops handle simple counters. The rule of thumb: channels for communication/ownership transfer, mutexes for guarding shared memory.

fmt.Errorf with %w wraps an underlying error while adding context, building a chain. errors.Is checks whether any error in the chain matches a target (e.g. sql.ErrNoRows), and errors.As extracts a specific error type from the chain. This lets you add context at each layer without losing the ability to inspect the original cause.

return fmt.Errorf("load user: %w", err)
if errors.Is(err, sql.ErrNoRows) { ... }

A sentinel error is a predefined error value (var ErrNotFound = errors.New(...)) you compare against with errors.Is — simple but limited to identity. A custom error type implements the error interface and can carry fields (codes, context), extracted with errors.As. You use sentinels for simple known conditions and custom types when callers need structured detail.

Return an error for anything a caller might reasonably handle — missing files, bad input, network failures. Reserve panic for programmer errors and truly unrecoverable states (impossible conditions, failed required initialization at startup), or inside a package where you recover at the boundary. Libraries should almost always return errors, not panic, so callers stay in control.

context carries cancellation signals, deadlines/timeouts, and request-scoped values across API boundaries and goroutines. You pass it as the first parameter, and downstream code selects on ctx.Done() to stop work when the request is cancelled or times out. It's how Go propagates 'stop' through a call tree — essential for servers to avoid leaking work on abandoned requests.

Deferred calls evaluate their arguments immediately but run at function return, so capturing a loop variable or a value that changes can surprise you. Deferring inside a loop accumulates calls until the function returns (a resource leak for long loops) — better to wrap the body in a function. And deferred functions can modify named return values, which is occasionally useful but easy to misuse.

Struct tags are string annotations on fields that libraries read via reflection. encoding/json uses json:"name,omitempty" tags to control the JSON key, omit empty values, or skip a field with json:"-". They're how you map Go field names (exported, CamelCase) to external formats (snake_case JSON) without changing your code.

type User struct { Name string `json:"name,omitempty"` }