Go

## Quick Reference | Topic | File | |-------|------| | Concurrency patterns | `concurrency.md` | | Interface and type system | `interfaces.md` | | Slices, maps, strings | `collections.md` | | Error handling patterns | `errors.md` | ## Goroutine Leaks - Goroutine blocked on channel with no sender = leak forever—always ensure channel closes or use context - Unbuffered channel send blocks until receive—deadlock if receiver never comes - `for range` on channel loops forever until channel closed—sender must `close(ch)` - Context cancellation doesn't stop goroutine automatically—must check `ctx.Done()` in loop - Leaked goroutines accumulate memory and never garbage collect ## Channel Traps - Sending to nil channel blocks forever—receiving from nil also blocks forever - Sending to closed channel panics—closing already closed channel panics - Only sender should close channel—receiver closing causes sender panic - Buffered channel full = send blocks—size buffer for expected load - `select` with multiple ready cases picks randomly—not first listed ## Defer Traps - Defer arguments evaluated immediately, not when deferred function runs—`defer log(time.Now())` captures now - Defer in loop accumulates—defers stack, run at function end not iteration end - Defer runs even on panic—good for cleanup, but recover only in deferred function - Named return values modifiable in defer—`defer func() { err = wrap(err) }()` works - Defer order is LIFO—last defer runs first ## Interface Traps - Nil concrete value in interface is not nil interface—`var p *MyType; var i interface{} = p; i != nil` is true - Type assertion on wrong type panics—use comma-ok: `v, ok := i.(Type)` - Empty interface `any` accepts anything but loses type safety—avoid when possible - Interface satisfaction is implicit—no compile error if method signature drifts - Pointer receiver doesn't satisfy interface for value type—only `*T` has the method ## Error Handling - Errors are values, not exceptions—always check returned error - `err != nil` after every call—unchecked errors are silent bugs - `errors.Is` for wrapped errors—`==` doesn't work with `fmt.Errorf("%w", err)` - Sentinel errors should be `var ErrFoo = errors.New()` not recreated - Panic for programmer errors only—return error for runtime failures ## Slice Traps - Slice is reference to array—modifying slice modifies original - Append may or may not reallocate—never assume capacity - Slicing doesn't copy—`a[1:3]` shares memory with `a` - Nil slice and empty slice differ—`var s []int` vs `s := []int{}` - `copy()` copies min of lengths—doesn't extend destination ## Map Traps - Reading from nil map returns zero value—writing to nil map panics - Map iteration order is random—don't rely on order - Maps not safe for concurrent access—use `sync.Map` or mutex - Taking address of map element forbidden—`&m[key]` doesn't compile - Delete from map during iteration is safe—but add may cause issues ## String Traps - Strings are immutable byte slices—each modification creates new allocation - `range` over string iterates runes, not bytes—index jumps for multi-byte chars - `len(s)` is bytes, not characters—use `utf8.RuneCountInString()` - String comparison is byte-wise—not Unicode normalized - Substring shares memory with original—large string keeps memory alive ## Struct and Memory - Struct fields padded for alignment—field order affects memory size - Zero value is valid—`var wg sync.WaitGroup` works, no constructor needed - Copying struct with mutex copies unlocked mutex—always pass pointer - Embedding is not inheritance—promoted methods can be shadowed - Exported fields start uppercase—lowercase fields invisible outside package ## Build Traps - `go build` caches aggressively—use `-a` flag to force rebuild - Unused imports fail compilation—use `_` import for side effects only - `init()` runs before main, order by dependency—not file order - `go:embed` paths relative to source file—not working directory - Cross-compile: `GOOS=linux GOARCH=amd64 go build`—easy but test on target