Go FAQ & Answers

Go (Golang) is a statically typed, compiled language designed for simplicity and performance. Key features: built-in concurrency (goroutines, channels), fast compilation, garbage collection, static linking, cross-platform compilation, comprehensive standard library, implicit interface implementation, first-class functions, multiple return values, built-in testing and fuzzing (Go 1.18+). Go 1.22+ adds range-over-function iterators, Go 1.23 introduces iter package for custom iterators. Emphasizes readable, maintainable code with excellent tooling (gofmt, go vet, staticcheck). Ideal for: web services, CLI tools, cloud-native applications, distributed systems, DevOps automation, microservices.

Goroutines are lightweight concurrent execution units managed by Go runtime. Create with 'go' keyword: go function(). Runtime multiplexes thousands of goroutines onto OS threads using M:N scheduling. Start with ~2KB stack (grows/shrinks dynamically). Schedule cooperatively - blocking operations don't halt other goroutines. Communicate via channels (CSP model). Exit when function returns or panics. Use sync.WaitGroup or errgroup for synchronization. Modern Go (1.19+) has improved preemption, preventing goroutine monopolization. Extremely efficient - production systems run millions concurrently. Essential Go concurrency primitive, far lighter than OS threads.

Channels enable safe goroutine communication following CSP (Communicating Sequential Processes). Create: ch := make(chan T) for unbuffered, make(chan T, size) for buffered. Unbuffered channels synchronize sender/receiver (rendezvous). Buffered channels block only when full (send) or empty (receive). Operations: ch <- value (send), value := <-ch (receive), close(ch) (signal completion). Go 1.23: timer channels now unbuffered (capacity 0), preventing stale values. Use select for multiple channels. Receive from closed channel returns zero value. Philosophy: 'Share memory by communicating, not communicate by sharing memory.' Essential for safe concurrent patterns.

defer schedules function execution immediately before enclosing function returns. Executes in LIFO order (last deferred runs first). Arguments evaluated at defer statement, not when deferred function runs. Use for: resource cleanup (defer file.Close()), mutex unlocking (defer mu.Unlock()), panic recovery (defer func() { recover() }()), transaction rollbacks. Runs even during panic. Common pattern: defer cleanup() immediately after resource acquisition. Multiple defers in single function allowed. Go 1.14+ optimized defer with zero overhead for common cases. Best practice: use defer for symmetry - open/close, lock/unlock, begin/commit operations. Makes resource management reliable and code cleaner.

Go uses explicit error checking with multiple return values. Convention: error as final return. Error interface: type error interface { Error() string }. Check: if err != nil { return fmt.Errorf("context: %w", err) }. Go 1.13+ error wrapping: fmt.Errorf with %w preserves error chain. Unwrap with errors.Is(err, target) for sentinel errors, errors.As(err, &targetType) for type assertions. Custom errors implement Error() method. Create with errors.New(), fmt.Errorf(). Best practices: wrap errors with context at each layer, check every error, use errors.Is/As for inspection, return early on errors. Philosophy: explicit over hidden control flow. No exceptions - predictable error handling.

Interfaces define behavior through method sets with implicit implementation. Syntax: type I interface { Method() T }. Type implements interface automatically by having matching methods - no explicit declaration. Empty interface interface{} (alias any in Go 1.18+) accepts any type. Interface embedding composes multiple interfaces. Common interfaces: io.Reader, io.Writer, error, fmt.Stringer. Implementation is structural (duck typing) - if type has required methods, it implements interface. Use for: abstraction, polymorphism, dependency injection, testing mocks. Go 1.18+ generics use interfaces as type constraints. Best practice: accept interfaces, return concrete types. Small interfaces (1-3 methods) more composable.

panic halts normal execution, unwinds goroutine stack executing deferred functions, then crashes program unless recovered. Call recover only in deferred functions: defer func() { if r := recover(); r != nil { /* handle */ } }(). recover returns panic's argument, stops unwinding. Use panic for: impossible states, programming errors, initialization failures. Use errors for expected failures. panic is per-goroutine - doesn't stop other goroutines. Best practices: avoid panic in libraries (return errors instead), use for truly unrecoverable situations, recover at boundaries (HTTP handlers, goroutine tops). Modern Go: prefer explicit error handling. panic/recover not for control flow - exceptional circumstances only.

Go modules (introduced Go 1.11, default since 1.16) manage dependencies with semantic versioning. go.mod defines module path, Go version, and dependency requirements. go.sum contains cryptographic checksums verifying dependency integrity, preventing tampering. Initialize: go mod init module/path. Add dependency: go get package@version. Commands: go mod tidy (clean unused), go mod vendor (copy to vendor/), go mod download (fetch). Uses Minimum Version Selection (MVS) - most stable dependency resolution. replace directive for local development/forks. retract directive marks withdrawn versions. Both files committed to version control. Go 1.21+ improved workspace mode. Essential for reproducible builds across environments.

Structs are typed field collections. Define: type S struct { Field T }. Initialize: s := S{Field: val}, s := &S{}, s := S{} (zero values). Methods: func (r Receiver) Method() {}. Pointer receivers (func (r *Receiver)) can modify fields, prevent copying. Value receivers (func (r Receiver)) operate on copy. Go auto-converts: ptr.ValueMethod() and val.PointerMethod() (if addressable). Best practice: use pointer receivers consistently if any method modifies state or struct is large. Struct embedding promotes methods: embedded type's methods available on outer type. No inheritance - composition via embedding. Zero value useful - sync.Mutex, bytes.Buffer usable without initialization.

Exported identifiers start with uppercase (public), unexported with lowercase (package-private). Package names: lowercase, concise, single-word, no underscores (avoid util, common, base). Avoid redundancy: ring.New not ring.NewRing. Interface names: -er suffix (Reader, Writer, Stringer) or agent nouns. Variables: short in small scopes (i, j, r), descriptive in larger scopes. Constants: MixedCaps or mixedCaps, not SCREAMING_CASE (exception: generated code). Use gofmt for formatting, golangci-lint for style. Go 1.19+ vet checks for common mistakes. Modern convention: avoid stuttering (http.HTTPServer → http.Server). Follow standard library patterns for consistency and idiomacy.

Initialization order: (1) imported packages recursively (depth-first), (2) package-level constants, (3) package-level variables (dependency order), (4) init() functions (source file order). Multiple init() per package/file allowed - execute sequentially. init() signature: func init() {} (no args, no return). Use for: complex initialization, side effects, validation, registration (database drivers, image formats). Cannot be called explicitly. Runs once per package. Deterministic order ensures reliable setup. Best practices: avoid complex init() (hard to test), prefer explicit initialization functions, use init() for registration patterns only. Go 1.21+ improved init performance.

Value receiver (func (t T)) receives copy - cannot modify original, safe for concurrent use, efficient for small types (<64 bytes). Pointer receiver (func (t *T)) receives pointer - can modify original, avoids copying large structs, required for modifying methods. Best practice: use pointer receivers consistently if any method needs modification or struct is large. Go auto-converts: ptr.ValueMethod() calls (*ptr).ValueMethod(), val.PointerMethod() calls (&val).PointerMethod() for addressable values. Cannot take address of map values or interface values. Choose pointer for: modification, large structs (>64 bytes), consistency across methods, implementing interfaces with pointer receivers. Value receivers for: small immutable data, concurrent safety.

Worker pool pattern: fixed workers process tasks from job channel. Implementation: jobs := make(chan Job, 100); results := make(chan Result, 100); var wg sync.WaitGroup; for w := 0; w < workers; w++ { wg.Add(1); go worker(&wg, jobs, results) }. Send jobs, close(jobs) when done, wg.Wait() for completion. Modern Go: use errgroup (golang.org/x/sync/errgroup) for error handling: g.Go(func() error { /* work */ }); if err := g.Wait(); err != nil {}. Patterns: fan-out (distribute), fan-in (collect), pipeline (stages), context for cancellation. Use buffered channels for queuing. Go 1.22+ improved scheduler efficiency. Essential for parallel processing, batch operations, rate limiting.

Arrays: fixed size (part of type), value type, syntax [N]T. Different sizes are different types. Rare in production code. Slices: dynamic size, reference type (header + pointer to array), syntax []T. Create: make([]T, len, cap), []T{values}, array[low:high]. Slice header contains pointer, length, capacity. Operations: append(s, vals...) may reallocate when cap exceeded. len(s) returns length, cap(s) returns capacity. Slicing creates new header sharing underlying array - mutations visible across slices. Use copy(dst, src) for independent copy. Zero value: nil slice (len=0, cap=0). Slices are idiomatic Go - use in 99% of cases. append patterns optimized in modern Go.

Go uses concurrent, tri-color mark-and-sweep GC running alongside program with <1ms pause times. Triggers automatically based on heap growth (GOGC=100 default - GC when heap doubles). Optimizations: reduce allocations with sync.Pool for temporary objects (93% performance gains reported), use value types to reduce pointer scanning, preallocate slices/maps with make([]T, 0, capacity), avoid []byte conversions in hot paths, reuse buffers. Profile with pprof: go test -memprofile. Monitor: GODEBUG=gctrace=1. Tune GOGC (higher = less frequent GC, more memory). Go 1.19+ improved GC efficiency. sync.Pool ideal for high-churn objects like HTTP request buffers. Modern GC rarely needs tuning.

select multiplexes multiple channel operations, like switch for channels. Blocks until one case ready, chooses randomly if multiple ready. Syntax: select { case v := <-ch1: handle; case ch2 <- x: handle; default: non-blocking }. default makes select non-blocking. Common patterns: timeout with time.After(), cancellation with ctx.Done(), multiplexing results. Example: select { case <-ctx.Done(): return ctx.Err(); case result := <-ch: process(result); case <-time.After(5*time.Second): return ErrTimeout; }. Go 1.23: timer channels unbuffered, preventing stale timeout signals. Use for: coordinating goroutines, implementing timeouts, graceful shutdown. Essential for complex channel coordination and concurrent control flow.

Go is statically typed with type inference (x := 5). Type assertion extracts concrete value from interface: val := i.(ConcreteType) panics if wrong type. Safe form: val, ok := i.(ConcreteType) returns (zero, false) if wrong. Type switch handles multiple types: switch v := i.(type) { case int: /* v is int /; case string: / v is string */ }. Go 1.18+ generics: type parameters with constraints. Use type assertions for: accessing underlying type, handling heterogeneous data, downcasting. Best practices: prefer comma-ok idiom, use type switches for multiple types, avoid type assertions in hot paths (interface method calls faster). Cannot assert between incompatible types at compile time.

testing package provides comprehensive framework. Tests in *_test.go files. Test functions: func TestName(t *testing.T). Run: go test, go test -v (verbose). Assertions: t.Error/Errorf (continue), t.Fatal/Fatalf (stop), t.Skip (conditional). Subtests: t.Run("subtest", func(t *testing.T) {}) for table-driven tests. Benchmarks: func BenchmarkName(b testing.B) { for range b.N { / code */ } }, run with go test -bench=. Examples: func ExampleName() with // Output: comment. Go 1.18+ fuzzing: func FuzzName(f *testing.F) for automated input generation. Coverage: go test -cover, -coverprofile. Go 1.20+ improved coverage for integration tests. No external dependencies needed - production-quality testing built-in.

context.Context carries cancellation signals, deadlines, request-scoped values across API boundaries and goroutines. Create: context.Background() (root), context.WithCancel(parent), context.WithTimeout(parent, duration), context.WithDeadline(parent, time). Check cancellation: select { case <-ctx.Done(): return ctx.Err() }. Always call cancel() to prevent leaks: ctx, cancel := context.WithTimeout(parent, 5*time.Second); defer cancel(). Pass as first parameter: func DoWork(ctx context.Context, args). Use for: request timeouts, graceful shutdown, cancellation propagation. Never store in structs. Values: context.WithValue for request-scoped data (use sparingly, prefer explicit parameters). Best practices: always check ctx.Done() in loops, propagate through call chains, cancel when done.

Go modules use semantic versioning (v1.2.3). Major versions v2+ require /v2, /v3 suffix in module path for breaking changes. Commands: go get package@version (add/update), go mod tidy (clean), go mod vendor (copy to vendor/), go get -u (update). Minimum Version Selection chooses oldest version satisfying all requirements - most predictable. Directives: replace (local/fork development), retract (mark version withdrawn), exclude (skip broken version). Update all: go get -u ./..., update one: go get package@latest. Go 1.21+ workspace mode (go.work) for multi-module development. go.sum ensures integrity. Both files version-controlled. Pin major versions, float minor/patch for security updates.

new(T) allocates zeroed storage, returns pointer *T for any type. Rarely used - composite literals preferred (&T{} equivalent). make(T, args) initializes built-in types (slices, maps, channels), returns initialized value T (not pointer). Usage: make([]T, len, cap) for slices, make(map[K]V) or make(map[K]V, capacity) for maps, make(chan T) or make(chan T, buffer) for channels. make necessary because these types need runtime initialization beyond zeroing (slice header, map hash table, channel buffer). Best practices: use make for slice/map/chan, use composite literals &T{} instead of new(T). Zero values often sufficient - var m map[K]V is valid nil map (reads return zero, writes panic until initialized).

encoding/json package handles JSON marshaling/unmarshaling. Marshal: data, err := json.Marshal(v) returns []byte. Unmarshal: err := json.Unmarshal(data, &v) decodes into v. Struct tags control mapping: type Person struct { Name string json:"name" Age int json:"age,omitempty" Internal string json:"-" }. Tags: rename field, omitempty (skip zero values), - (ignore). Only exported fields encoded. Streaming: json.NewEncoder(w).Encode(v), json.NewDecoder(r).Decode(&v) for efficient I/O. Handle unknown fields: json.Decoder.DisallowUnknownFields(). Custom marshaling: implement json.Marshaler/Unmarshaler interfaces. Modern pattern: use json.RawMessage for delayed parsing. Essential for REST APIs, configuration, data exchange.

Empty interface interface{} (alias any in Go 1.18+) accepts any type - zero methods required. Use for: heterogeneous collections, JSON unmarshaling, reflection. Access concrete type via type assertion/switch. Go 1.18+ generics use interfaces as type constraints with union types. Example: func Min[T constraints.Ordered](a, b T) T uses Ordered constraint (supports <, >, ==). constraints package: Ordered, Signed, Integer, Float, Complex. Custom: type Number interface { int | int64 | float64 } or type Stringer interface { String() string }. comparable constraint for map keys and == operations. Best practices: prefer generics over interface{} for type safety, use any sparingly, constraints more expressive than empty interface. Generics compile to concrete types, not interface dispatch.

Pattern: (1) listen for OS signals, (2) initiate shutdown, (3) cleanup, (4) exit. Implementation: sig := make(chan os.Signal, 1); signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM); <-sig triggers shutdown. Create shutdown context: ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second); defer cancel(). Propagate to goroutines via context. HTTP: server.Shutdown(ctx) waits for active connections. Use sync.WaitGroup or errgroup to wait for goroutines. Close resources: database connections, file handles. Pattern: defer cleanup in main(). Best practices: timeout shutdown (30s typical), log shutdown progress, handle shutdown errors, drain work queues. Modern servers use graceful shutdown for zero-downtime deployments. Essential for data consistency and request completion.

Standard layout (widely adopted, not official): cmd/ (application entry points), pkg/ (library code), internal/ (private packages - blocked from external import), api/ (API specs), web/ (static assets), configs/, scripts/, test/, docs/. Flat over nested - avoid deep hierarchies. Package by domain/feature, not by type (no models/, controllers/). Avoid god packages (util, common, helpers). One package per directory. Keep main.go minimal - delegate to packages. No circular dependencies. cmd/myapp/main.go for binaries. internal/ enforces encapsulation. Go 1.21+ improved module workspaces for monorepos. Best practices: simple structure initially, add complexity as needed, follow standard library patterns, prioritize readability over clever organization.