Golang / Golang Internals and Memory Management Interview Questions

// Array — fixed, value type
arr := [5]int{1, 2, 3, 4, 5}
arrCopy := arr // full copy of all 5 ints

// Slice — descriptor pointing to arr's backing storage
s := arr[1:4]       // s.ptr = &arr[1], s.len = 3, s.cap = 4
fmt.Println(len(s), cap(s)) // 3  4

// Modifying through the slice modifies the backing array
s[0] = 99
fmt.Println(arr) // [1 99 3 4 5] — arr is mutated!

// Make allocates a fresh backing array
fresh := make([]int, 3, 6) // len=3, cap=6, new backing array

// Nil slice — zero value; all three fields are zero
var nilSlice []int
fmt.Println(nilSlice == nil, len(nilSlice)) // true 0

s := make([]int, 3, 5) // len=3 cap=5 — room for 2 more
s2 := append(s, 10)    // fits in cap — no reallocation
// s and s2 SHARE the backing array until cap is exceeded

s3 := append(s2, 20, 30) // cap exceeded — new backing array allocated
// s, s2 still point to OLD array; s3 points to NEW array

// ALWAYS use the returned value of append
s = append(s, 99) // wrong to ignore the return — s might be outdated

// Growth strategy (Go 1.18+)
// cap < 256:  double (newcap = oldcap * 2)
// cap >= 256: grow ~25% + smooth correction to avoid thrashing

// Pre-allocate when the final size is known
names := make([]string, 0, 1000) // avoids N reallocations in a loop
for _, n := range rawNames {
    names = append(names, n)
}

// Does NOT escape — lives on stack (no reference escapes the function)
func sum(a, b int) int {
    result := a + b // stays on stack
    return result
}

// DOES escape — caller holds a pointer; Go must allocate on heap
func newCounter() *int {
    n := 0        // n escapes to heap — pointer outlives function frame
    return &n
}

// Escape via interface — any value stored in an interface box escapes
func logValue(v interface{}) { fmt.Println(v) }
x := 42
logValue(x) // x's copy escapes to heap because interface requires a pointer

// Slice backing arrays that are too large — compiler heuristic
big := make([]byte, 64*1024) // large allocation always goes to heap

// Inspect escape analysis
// go build -gcflags="-m" ./...
// go build -gcflags="-m -m" ./... (verbose, shows reason)
// Output lines like: './main.go:8:2: n escapes to heap'

// Goroutines start with 2 KB stack — very cheap to spawn
for i := 0; i < 1_000_000; i++ {
    go func(id int) {
        // Each goroutine starts with a 2 KB stack
        doWork(id)
    }(i)
}

// Deeply recursive function — stack grows automatically
func fib(n int) int {
    if n <= 1 { return n }
    return fib(n-1) + fib(n-2) // stack grows as needed, up to GOMAXSTACKS
}

// Maximum goroutine stack size (configurable via GOTRACEBACK env)
// Default maximum is 1 GB

// Stack size at goroutine creation is visible in stack traces:
// goroutine 1 [running]:
// main.main()
//     /path/main.go:10 +0x... [stack: 2048]

// runtime.Stack() for diagnostics
buf := make([]byte, 1<<20)
n := runtime.Stack(buf, true) // all goroutines
fmt.Printf("%s", buf[:n])

// Trigger GC manually (rarely needed in production)
import "runtime"
runtime.GC() // triggers a full GC cycle

// Read GC stats
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
fmt.Printf("NumGC: %d\n", stats.NumGC)
fmt.Printf("PauseTotal: %v\n", time.Duration(stats.PauseTotalNs))
fmt.Printf("HeapAlloc: %d MB\n", stats.HeapAlloc/1024/1024)

// GOGC env — controls GC frequency
// GOGC=100 (default): GC triggers when heap grows 100% above last GC live set
// GOGC=200: GC triggers at 200% — less frequent GC, more memory used
// GOGC=off: disables GC (only for benchmarks)

// GOMEMLIMIT (Go 1.19+) — hard memory limit
// GOMEMLIMIT=500MiB triggers GC more aggressively if heap approaches 500 MB

// GOGC examples (set as environment variable or via runtime/debug)
// GOGC=100  (default) — GC when heap is 2x last-collection live set
// GOGC=200            — GC when heap is 3x — fewer GCs, more memory
// GOGC=50             — GC when heap is 1.5x — more frequent, lower peak
// GOGC=off            — disable GC (benchmarks/short programs only)

import "runtime/debug"

// Set programmatically (returns old value)
oldGOGC := debug.SetGCPercent(200) // increase to reduce GC frequency
defer debug.SetGCPercent(oldGOGC)

// GOMEMLIMIT — prevents OOM by forcing GC before memory is exhausted
// GOMEMLIMIT=500MiB
debug.SetMemoryLimit(500 * 1024 * 1024) // 500 MB hard limit

// Best practice for containerized Go services:
// Set GOMEMLIMIT to ~90% of container memory limit
// This prevents OOM kills while allowing GC to breathe
// Example: container limit 1 GiB → GOMEMLIMIT=900MiB

// Runtime metrics (Go 1.16+)
import "runtime/metrics"
samples := []metrics.Sample{
    {Name: "/gc/cycles/total:gc-cycles"},
    {Name: "/memory/classes/heap/objects:bytes"},
}
metrics.Read(samples)
fmt.Println(samples[0].Value.Uint64()) // total GC cycles

// Map creation
m := make(map[string]int)          // empty, grows as needed
m2 := make(map[string]int, 100)    // hint: pre-allocate for ~100 entries

// The hint avoids rehashing during initial population
// Map automatically grows (rehash) when load factor ~6.5 entries/bucket

// Comma-ok idiom — distinguish missing key from zero value
m["alice"] = 0
val, ok := m["alice"]  // val=0,  ok=true   — key exists
val, ok  = m["bob"]   // val=0,  ok=false  — key absent
if !ok { fmt.Println("key not found") }

// Deleting a key
delete(m, "alice") // no-op if key absent, no panic

// Iteration order is intentionally randomised
for k, v := range m {
    fmt.Println(k, v) // order differs across runs
}

// Maps are NOT thread-safe — concurrent reads+writes cause a fatal error
// Detected by the race detector: go run -race ./...

// Safe alternatives:
// 1. sync.Mutex protecting the map
// 2. sync.RWMutex for read-heavy workloads
// 3. sync.Map (optimised for high-concurrency, low-write scenarios)

// sync.Map — optimised for: once written, many reads
var sm sync.Map

// Store
sm.Store("key", 42)

// Load
val, ok := sm.Load("key")
if ok {
    fmt.Println(val.(int)) // type assertion required
}

// LoadOrStore — atomic get-or-set
actual, loaded := sm.LoadOrStore("key", 99)
fmt.Println(actual, loaded) // 42 true (existing value returned)

// Range — iterate (snapshot semantics during iteration not guaranteed)
sm.Range(func(k, v any) bool {
    fmt.Println(k, v)
    return true // return false to stop iteration
})

// mutex-protected map — preferred for write-heavy or type-safe needs
type SafeMap[K comparable, V any] struct {
    mu sync.RWMutex
    m  map[K]V
}
func (s *SafeMap[K, V]) Get(k K) (V, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.m[k]
    return v, ok
}

// Pass by VALUE — mutation inside the function is invisible to caller
func doubleValue(n int) { n *= 2 } // n is a copy
x := 5
doubleValue(x)
fmt.Println(x) // still 5

// Pass by POINTER — mutation is visible
func doublePtr(n *int) { *n *= 2 }
doublePtr(&x)
fmt.Println(x) // 10

// Large structs — avoid copying by passing pointer
type BigStruct struct { data [1024]byte }
func processValue(b BigStruct) {} // copies 1 KB every call
func processPtr(b *BigStruct) {}  // copies only 8 bytes (pointer)

// Value receiver vs pointer receiver on methods
type Counter struct{ count int }
func (c Counter)  Get()  int { return c.count }     // value receiver — copy
func (c *Counter) Inc()      { c.count++ }           // pointer receiver — mutates

c := Counter{}
c.Inc()              // Go automatically takes &c
fmt.Println(c.Get()) // 1

// Pointer vs nil — always check before dereferencing
var p *int
fmt.Println(p)   // 
// fmt.Println(*p) // PANIC: nil pointer dereference

// GOMAXPROCS controls the number of P's (and thus OS threads active)
import "runtime"
runtime.GOMAXPROCS(4) // use 4 OS threads for parallel execution
fmt.Println(runtime.GOMAXPROCS(0)) // 0 = query without changing

// Scheduler events that cause a context switch:
// 1. Goroutine blocks on channel send/receive
// 2. Goroutine blocks on system call (M parks, P finds another M)
// 3. go statement (new G added to local run queue of current P)
// 4. runtime.Gosched() — voluntary yield
// 5. Function call (Go 1.14+: asynchronous preemption via signals)

// Work stealing: when P's local queue is empty,
// it steals half the goroutines from another P's queue

// Global run queue: accessed when local queue has > 256 Gs,
// or periodically to ensure fairness

// View scheduler decisions
// GOTRACE=scheduler ./myapp  — not a real flag, but:
// go tool trace trace.out    — after: f, _ := os.Create("trace.out")
//                              trace.Start(f); ...; trace.Stop()

// Unbuffered channel — synchronous rendezvous
ch := make(chan int) // cap=0, buf=nil
// Send blocks until a goroutine receives; receive blocks until send

// Buffered channel — asynchronous up to capacity
ch2 := make(chan int, 5) // cap=5, ring buffer of 5 ints
ch2 <- 1 // does not block (buffer not full)
ch2 <- 2
v := <-ch2 // 1 (FIFO)

// Select — multiplexed channel operations
select {
case msg := <-ch:
    fmt.Println("received", msg)
case ch2 <- 42:
    fmt.Println("sent 42")
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
default:
    fmt.Println("non-blocking — no case ready")
}

// Closing a channel — signals receivers: no more data
close(ch2)
val, ok := <-ch2 // ok=false means channel closed and empty

// Range over channel — reads until closed
for v := range ch2 {
    fmt.Println(v)
}

// Common rules:
// - Sending to a closed channel panics
// - Receiving from a closed, empty channel returns zero value, ok=false
// - Closing a nil channel panics
// - Only the SENDER should close (receiver cannot know when sender is done)

// Empty interface (any / interface{})
// eface { type *_type, data unsafe.Pointer }
var v any = 42
// _type = pointer to int's type descriptor
// data = pointer to a heap-allocated int holding 42

// Interface with methods
// iface { itab *itab, data unsafe.Pointer }
// itab = {inter *interfacetype, type *_type, hash uint32, fun [...]uintptr}
// fun[] = the method dispatch table (virtual call table)

type Stringer interface { String() string }
type MyInt int
func (m MyInt) String() string { return fmt.Sprintf("%d", m) }

var s Stringer = MyInt(5) // iface{itab=*MyInt-Stringer-itab, data=ptr-to-5}
fmt.Println(s.String())    // dispatches via itab.fun[0]

// Type assertion — recovers the concrete type
if mi, ok := s.(MyInt); ok {
    fmt.Println(mi + 1)
}

// Type switch
switch t := v.(type) {
case int:    fmt.Println("int:", t)
case string: fmt.Println("string:", t)
default:     fmt.Println("unknown")
}

// Performance implication: values stored in interface often escape to heap
// Small values (pointer-sized or smaller) can be inlined into the data word
// Avoid interface{} in hot paths — use generics (Go 1.18+) instead

// Allocation path for a small object (<=32 KB):
// 1. Round up to nearest size class (e.g., 24 bytes → 32-byte class)
// 2. Check P's mcache for that size class — if span available, use it (no lock)
// 3. If mcache empty, fetch a span from mcentral (mutex on that size class)
// 4. If mcentral empty, request memory from mheap (global lock)
// 5. If mheap exhausted, request OS memory via mmap/VirtualAlloc

// Large object allocation (>32 KB):
// Directly from mheap — allocated as a multi-page span

// Tiny allocation (<=16 bytes, no pointers, not zero-sized):
// Multiple tiny objects packed into a single 16-byte slot
// e.g., allocating many bool or small int values is very cheap

// Size classes — Go has ~68 size classes:
// 8, 16, 24, 32, 48, 64, 80, 96, 112, 128, ... 32768 bytes

// Inspecting allocation stats
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc      = %d KB\n", m.Alloc/1024)
fmt.Printf("TotalAlloc = %d KB\n", m.TotalAlloc/1024)
fmt.Printf("Sys        = %d KB\n", m.Sys/1024)
fmt.Printf("Mallocs    = %d\n", m.Mallocs)
fmt.Printf("Frees      = %d\n", m.Frees)

// String header: {ptr unsafe.Pointer, len int}
s := "hello"
fmt.Println(len(s))    // 5 (bytes, not runes)
fmt.Println(s[0])      // 104 — byte value of 'h'
// s[0] = 'H'          // compile error: cannot assign to s[0]

// UTF-8: len counts bytes, range counts runes
emoji := "Go 🚀"
fmt.Println(len(emoji))              // 7 (G=1, o=1, space=1, rocket=4 bytes)
for i, r := range emoji {
    fmt.Printf("%d: %c\n", i, r)  // i is byte offset, r is rune value
}

// String concatenation creates a NEW backing array each time
// Avoid in loops — use strings.Builder instead
var b strings.Builder
for _, s := range words {
    b.WriteString(s)
    b.WriteByte(' ')
}
result := b.String() // single allocation

// string <-> []byte conversion
// Each conversion copies the bytes (different backing arrays)
bytes := []byte(s)   // copy into a new mutable byte slice
s2    := string(bytes) // copy back — new immutable string

// Zero-copy cast with unsafe (avoid unless in hot path + well-understood)
// Not recommended for general use

// Arguments evaluated immediately at defer statement
x := 10
defer fmt.Println(x) // prints 10 even if x is later changed
x = 20
// Output: 10

// Named return values + defer — modify return before it reaches caller
func divide(a, b float64) (result float64, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()
    result = a / b
    return // named return
}

// LIFO order — multiple defers run last-in first-out
func cleanup() {
    defer fmt.Println("first defer")
    defer fmt.Println("second defer")
    defer fmt.Println("third defer")
    // Output: third, second, first
}

// Performance: defer has overhead (allocates defer record pre-Go 1.14)
// Go 1.14+ inlines simple defers — near-zero overhead for non-looping, non-panic paths

// Avoid defer in tight loops — call cleanup explicitly
func processFiles(files []string) {
    for _, f := range files {
        func() { // wrap in closure so defer fires per file
            fh, _ := os.Open(f)
            defer fh.Close() // OK inside the per-file closure
            // process...
        }()
    }
}

// Basic panic — causes runtime abort with stack trace
func mustPositive(n int) int {
    if n <= 0 {
        panic(fmt.Sprintf("expected positive, got %d", n))
    }
    return n
}

// recover — MUST be called inside a deferred function
func safeDiv(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    result = a / b // panics if b == 0
    return
}

r, err := safeDiv(10, 0)
fmt.Println(r, err) // 0  recovered from panic: runtime error: integer divide by zero

// recover() returns nil if not panicking
// It cannot recover a panic from a DIFFERENT goroutine
go func() {
    panic("goroutine panic") // crashes the whole program
}()

// When to use panic vs error:
// panic — unrecoverable programming errors (index out of bounds, nil deref)
//         or internal invariant violations that should never happen
// error — expected failure conditions (file not found, network timeout, bad input)

// Libraries should NEVER let panics propagate to callers
// Use recover at the public API boundary to convert to errors

// ── HTTP endpoint (register once, profile on demand) ──
import _ "net/http/pprof" // blank import registers handlers
import "net/http"

go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

// Profile endpoints:
// http://localhost:6060/debug/pprof/goroutine?debug=1  — goroutines
// http://localhost:6060/debug/pprof/heap               — heap snapshot
// http://localhost:6060/debug/pprof/profile?seconds=30 — CPU profile

// ── CLI usage ──
// Download and view CPU profile:
// go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
// (pprof) top10    — top 10 functions by CPU
// (pprof) web      — opens flame graph in browser
// (pprof) list myFunc — annotated source for myFunc

// Heap profile:
// go tool pprof http://localhost:6060/debug/pprof/heap
// (pprof) top10 -cum   — cumulative allocation
// (pprof) alloc_space  — total bytes allocated (not just live)
// (pprof) inuse_space  — currently live bytes

// ── Benchmark profiling ──
// go test -bench=. -cpuprofile=cpu.out -memprofile=mem.out
// go tool pprof cpu.out

// ── Programmatic (for batch programs) ──
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
// ... run workload ...
// go tool pprof cpu.prof

// Run with race detection
// go run -race main.go
// go test -race ./...
// go build -race -o myapp

// Example of a data race
var counter int

var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        counter++ // DATA RACE: concurrent unsynchronised write
    }()
}
wg.Wait()

// Race detector output:
// ==================
// WARNING: DATA RACE
// Write at 0x00c000016090 by goroutine 7:
//   main.main.func1()
//       /tmp/main.go:14 +0x38
// Previous write at 0x00c000016090 by goroutine 6:
//   main.main.func1()
//       /tmp/main.go:14 +0x38
// ==================

// Fix: use atomic or mutex
var atomicCounter int64
atomic.AddInt64(&atomicCounter, 1) // race-free

// Race detector overhead:
// CPU: 5–20x slower
// Memory: 5–10x more
// Not suitable for production (unless you accept the overhead)
// Ideal in CI and -race enabled test suites

// sync.Mutex — use when all accesses are writes or complex read+write ops
type SafeCounter struct {
    mu sync.Mutex
    count int
}
func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// sync.RWMutex — use when reads dominate
type Config struct {
    mu   sync.RWMutex
    data map[string]string
}
func (c *Config) Get(key string) string {
    c.mu.RLock()          // many readers can hold RLock concurrently
    defer c.mu.RUnlock()
    return c.data[key]
}
func (c *Config) Set(key, val string) {
    c.mu.Lock()           // exclusive — no readers or writers
    defer c.mu.Unlock()
    c.data[key] = val
}

// Important: RWMutex is NOT always faster than Mutex
// RWMutex has higher per-operation overhead than Mutex
// It wins when: read:write ratio >> 10:1 and lock is held for a notable duration
// For very short critical sections, Mutex can be faster

// TryLock (Go 1.18+)
if c.mu.TryLock() {
    defer c.mu.Unlock()
    // got the lock
} else {
    // lock is held — do something else
}

// ── Channel: ownership transfer ──
func producer(out chan<- int) {
    for i := 0; i < 10; i++ {
        out <- i // transfer ownership of i to consumer
    }
    close(out)
}
func consumer(in <-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

// ── Mutex: protecting shared state ──
type Inventory struct {
    mu    sync.Mutex
    items map[string]int
}
func (inv *Inventory) Add(name string, qty int) {
    inv.mu.Lock()
    defer inv.mu.Unlock()
    inv.items[name] += qty
}

// ── Avoiding channel misuse ──
// Bad: using a channel as a simple mutex replacement
sem := make(chan struct{}, 1) // semaphore
sem <- struct{}{} // acquire
// critical section
<-sem             // release
// Better: just use sync.Mutex for this pattern

// Context for cancellation (not raw channels)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
select {
case result := <-doWork(ctx):
    fmt.Println(result)
case <-ctx.Done():
    fmt.Println("timeout:", ctx.Err())
}

// Generic function with type constraint
func Min[T constraints.Ordered](a, b T) T {
    if a < b { return a }
    return b
}

fmt.Println(Min(3, 5))         // int
fmt.Println(Min(3.14, 2.71))   // float64
fmt.Println(Min("foo", "bar")) // string

// Generic type
type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(item T) { s.items = append(s.items, item) }
func (s *Stack[T]) Pop() (T, bool) {
    var zero T
    if len(s.items) == 0 { return zero, false }
    n := len(s.items) - 1
    item := s.items[n]
    s.items = s.items[:n]
    return item, true
}

// Custom interface constraint
type Number interface {
    ~int | ~int32 | ~int64 | ~float32 | ~float64
}
func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums { total += n }
    return total
}

// ~ means: any type whose underlying type is int
type MyInt int // ~int matches MyInt
fmt.Println(Sum([]MyInt{1, 2, 3})) // 6

// Context hierarchy — child inherits cancellation from parent
ctx := context.Background() // root — never cancelled, never has deadline

// WithCancel — explicit cancellation
ctx1, cancel1 := context.WithCancel(ctx)
defer cancel1() // ALWAYS defer cancel to prevent goroutine leaks

// WithTimeout — automatically cancelled after duration
ctx2, cancel2 := context.WithTimeout(ctx, 5*time.Second)
defer cancel2()

// WithDeadline — cancelled at absolute time
deadline := time.Now().Add(10 * time.Second)
ctx3, cancel3 := context.WithDeadline(ctx, deadline)
defer cancel3()

// WithValue — carry request-scoped data (use sparingly)
type ctxKey string
ctx4 := context.WithValue(ctx, ctxKey("traceID"), "abc-123")
traceID := ctx4.Value(ctxKey("traceID")).(string)

// Propagate through function calls
func fetchData(ctx context.Context, url string) ([]byte, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req) // cancels if ctx is done
    if err != nil { return nil, err }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}

// Checking cancellation in a long loop
func processItems(ctx context.Context, items []Item) error {
    for _, item := range items {
        select {
        case <-ctx.Done():
            return ctx.Err() // context.DeadlineExceeded or context.Canceled
        default:
            process(item)
        }
    }
    return nil
}

import "unsafe"

// unsafe.Sizeof — size of a type in bytes (compile-time)
type MyStruct struct {
    a int32  // 4 bytes
    b int64  // 8 bytes (8-byte aligned)
    c int8   // 1 byte
           // 7 bytes padding to next 8-byte boundary
}
fmt.Println(unsafe.Sizeof(MyStruct{}))    // 24 (not 13!) — alignment padding
fmt.Println(unsafe.Alignof(MyStruct{}.b)) // 8
fmt.Println(unsafe.Offsetof(MyStruct{}.b)) // 8 (offset of field b)

// unsafe.Pointer — the 'escape hatch' for type-unsafe pointer conversion
// uintptr + unsafe.Pointer can do pointer arithmetic
// But: converting to uintptr makes the value opaque to GC — GC can move object!

// Zero-copy string <-> []byte (HIGH RISK — avoid in application code)
// Only safe when the lifetime and mutability constraints are guaranteed
func bytesToString(b []byte) string {
    return *(*string)(unsafe.Pointer(&b))
}

// Struct field access via offset (used in reflect, cgo, sync internals)
// go:linkname — link to unexported symbols in other packages
// (used by stdlib, not for general use)

// Safe uses of unsafe:
// - Measuring struct size/alignment for documentation
// - Implementing generic data structures that need raw memory (arena allocators)
// - cgo interoperability
// - Performance-critical zero-copy conversions with proven safety

type MyError struct{ code int }
func (e *MyError) Error() string { return fmt.Sprintf("error %d", e.code) }

// Bug: returns a non-nil interface holding a nil *MyError
func riskyOp(fail bool) error {
    var err *MyError // nil *MyError pointer
    if fail {
        err = &MyError{code: 42}
    }
    return err // WRONG: even when fail=false, the returned error is NOT nil
              // The interface has {type=*MyError, data=nil}
}

e := riskyOp(false)
if e != nil {
    fmt.Println("ERROR:", e) // This PRINTS — interface is non-nil!
}

// Fix 1: return untyped nil when there is no error
func safeOp(fail bool) error {
    if fail {
        return &MyError{code: 42}
    }
    return nil // nil interface — both type and data are nil
}

// Fix 2: use a concrete return type if the caller always knows the type
func safeOp2(fail bool) *MyError {
    if fail { return &MyError{code: 42} }
    return nil // now nil really means nil
}

// Detect with reflect if debugging:
fmt.Println(e == nil)                   // false (interface non-nil)
fmt.Println(reflect.ValueOf(e).IsNil()) // true  (data pointer is nil)

// Common leak pattern 1: unbuffered channel with no receiver
func leak1() {
    ch := make(chan int)
    go func() {
        ch <- 42 // blocks forever — nobody reads
    }()
    // function returns; the goroutine is stuck sending forever
}

// Fix: use a buffered channel, or ensure the receiver runs
func fixed1() {
    ch := make(chan int, 1) // buffered: sender doesn't block
    go func() { ch <- 42 }()
    // or: read from ch here before returning
}

// Common leak pattern 2: no cancellation signal
func leak2(ctx context.Context, jobs <-chan Job) {
    go func() {
        for {
            job := <-jobs // blocks if jobs is never closed or ctx cancelled
            process(job)
        }
    }()
}

// Fix: use select with ctx.Done()
func fixed2(ctx context.Context, jobs <-chan Job) {
    go func() {
        for {
            select {
            case <-ctx.Done(): return // clean exit on cancellation
            case job := <-jobs: process(job)
            }
        }
    }()
}

// Detecting leaks
// 1. runtime.NumGoroutine() — spot trend in tests or monitoring
// 2. http://localhost:6060/debug/pprof/goroutine?debug=2 — full traces
// 3. goleak library (uber-go/goleak) — assert no goroutines leak in tests
// import goleak "go.uber.org/goleak"
// func TestMyFunc(t *testing.T) {
//     defer goleak.VerifyNone(t)
//     myFunc()
// }

var wg sync.WaitGroup

// CORRECT: Add BEFORE launching the goroutine
for i := 0; i < 5; i++ {
    wg.Add(1)                 // increment BEFORE go statement
    go func(id int) {
        defer wg.Done()       // always use defer — ensures Done even on panic
        fmt.Println("worker", id)
    }(i)
}
wg.Wait() // blocks until count reaches zero

// WRONG: Add inside the goroutine — race condition
for i := 0; i < 5; i++ {
    go func(id int) {
        wg.Add(1)   // may execute AFTER Wait() returns — data race!
        defer wg.Done()
        fmt.Println(id)
    }(i)
}
wg.Wait() // might return before all goroutines call Add

// WRONG: reusing WaitGroup before Wait returns
// Do not call Add on a WaitGroup whose Wait has not yet returned

// Pattern: limit concurrency with a semaphore channel
sem := make(chan struct{}, 10) // max 10 goroutines at once
for _, item := range items {
    wg.Add(1)
    sem <- struct{}{} // acquire slot
    go func(it Item) {
        defer func() { <-sem; wg.Done() }()
        process(it)
    }(item)
}
wg.Wait()

// ── Classic goroutine loop bug ──
// Go 1.21 and earlier:
for i := 0; i < 3; i++ {
    go func() {
        fmt.Println(i) // captures &i — all goroutines print 3, 3, 3
    }()
}
time.Sleep(time.Second)

// Fix 1: pass as argument (creates a copy per iteration)
for i := 0; i < 3; i++ {
    go func(i int) {      // i is now a local copy
        fmt.Println(i)    // 0, 1, 2 (in some order)
    }(i)
}

// Fix 2: shadow the variable inside the loop (pre-Go 1.22)
for i := 0; i < 3; i++ {
    i := i // new i per iteration
    go func() { fmt.Println(i) }()
}

// Go 1.22+ fix: loop variables are per-iteration by default
// The behaviour changed — each loop iteration now has its own i
// So the bug no longer exists in Go 1.22+ for range loops

// Closures in non-goroutine contexts
adders := make([]func() int, 3)
for i := 0; i < 3; i++ {
    i := i // shadow is needed pre-Go-1.22
    adders[i] = func() int { return i + 10 }
}
fmt.Println(adders[0](), adders[1](), adders[2]()) // 10 11 12

type Logger struct{ prefix string }
func (l Logger) Log(msg string) { fmt.Println(l.prefix+":", msg) }

type Server struct {
    Logger              // embedded — methods promoted
    addr   string
}

s := Server{Logger: Logger{"SERVER"}, addr: ":8080"}
s.Log("starting")  // promoted — same as s.Logger.Log("starting")
s.prefix = "SRV"   // promoted field access

// Embedding satisfies interfaces
type Loggable interface { Log(string) }
var l Loggable = s // Server satisfies Loggable via embedded Logger

// Method overriding — outer type can shadow embedded method
func (s Server) Log(msg string) {
    fmt.Printf("[%s] %s\n", s.addr, msg) // custom implementation
    // s.Logger.Log(msg) // explicitly call embedded if needed
}

// Interface embedding — compose interface contracts
type ReadWriter interface {
    io.Reader // embedded interface
    io.Writer
}

// Embedding vs named field
type WithName struct {
    myLogger Logger  // named field — NOT promoted, access as s.myLogger.Log()
}
type WithEmbed struct {
    Logger           // embedded — methods promoted to outer type
}

import "errors"

// Sentinel errors — comparable with ==  or errors.Is
var ErrNotFound = errors.New("not found")
var ErrPermission = errors.New("permission denied")

// Wrap — %w creates an error chain
func openFile(path string) error {
    if err := os.Open(path); err != nil {
        return fmt.Errorf("openFile %s: %w", path, err) // wrap with context
    }
    return nil
}

// errors.Is — checks if any error in the chain equals the target
err := openFile("/nonexistent")
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("file does not exist")
}

// Custom error type
type ValidationError struct {
    Field   string
    Message string
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
}

func validate(name string) error {
    if name == "" {
        return fmt.Errorf("user creation: %w", &ValidationError{"name", "required"})
    }
    return nil
}

// errors.As — extracts a specific type from the chain
err = validate("")
var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Printf("Field: %s, Message: %s\n", ve.Field, ve.Message)
}

// errors.Unwrap — one level only
inner := errors.Unwrap(err) // returns the wrapped *ValidationError

// Multiple wrapping (Go 1.20+) — join multiple errors
err1, err2 := errors.New("e1"), errors.New("e2")
joined := errors.Join(err1, err2)
errors.Is(joined, err1) // true

// benchmark_test.go
func BenchmarkStringConcat(b *testing.B) {
    // b.N is set by the framework — run the measured code exactly b.N times
    for i := 0; i < b.N; i++ {
        s := ""
        for j := 0; j < 100; j++ {
            s += "x" // inefficient — baseline
        }
        _ = s
    }
}

func BenchmarkStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 100; j++ {
            sb.WriteString("x")
        }
        _ = sb.String()
    }
}

// Run benchmarks:
// go test -bench=. -benchmem ./...
// BenchmarkStringConcat-8    123456   9876 ns/op   5264 B/op  99 allocs/op
// BenchmarkStringBuilder-8   456789   2345 ns/op    128 B/op   2 allocs/op

// -benchmem: shows memory allocations per op
// -benchtime=5s: run each benchmark for 5 seconds
// -count=5: run each benchmark 5 times for statistical stability

// Reset timer to exclude setup time
func BenchmarkWithSetup(b *testing.B) {
    data := make([]byte, 1<<20) // setup — excluded from timing
    b.ResetTimer()              // start timing from here
    for i := 0; i < b.N; i++ {
        process(data)
    }
}

// Run with pprof to get a flame graph:
// go test -bench=BenchmarkStringConcat -cpuprofile=cpu.out
// go tool pprof cpu.out

// Poorly ordered — wastes 7 bytes of padding
type Wasteful struct {
    a bool    // 1 byte
              // 7 bytes PADDING (for b's 8-byte alignment)
    b int64   // 8 bytes
    c bool    // 1 byte
              // 7 bytes PADDING (to align next field / end of struct)
}  // Total: 24 bytes (wastes 14 bytes)

// Well ordered — no padding (fields largest to smallest)
type Compact struct {
    b int64   // 8 bytes
    a bool    // 1 byte
    c bool    // 1 byte
              // 6 bytes padding to align to 8-byte boundary at struct end
}  // Total: 16 bytes (saves 8 bytes vs Wasteful)

// Verify with unsafe
fmt.Println(unsafe.Sizeof(Wasteful{})) // 24
fmt.Println(unsafe.Sizeof(Compact{}))  // 16

// Performance impact:
// Larger structs → more cache lines → more cache misses in hot loops
// A 50% size reduction can be a 2x performance improvement in array iteration

// Tool: fieldalignment (golang.org/x/tools/go/analysis/passes/fieldalignment)
// go install golang.org/x/tools/cmd/fieldalignment@latest
// fieldalignment ./...     — reports suboptimal struct layouts
// fieldalignment -fix ./.. — rewrites structs (review before committing!)

// go vet includes a similar check with: -structtag flag