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 Gotchas

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 Gotchas

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 Gotchas

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

Go