Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives

1. nil

The identifier nil is not a keyword; it is a pre‑declared zero value for pointers, channels, functions, interfaces, maps, and slices. Because nil has no static type, the compiler must infer the expected type from context. Two nil values cannot be compared directly because they are typeless. Declaring a nil map allows reads but forbids writes, and closing a nil channel triggers a panic. Accessing a nil slice by index also panics.

var m map[string]int // m == nil, read OK, write panics
var ch chan int      // ch == nil, close(ch) panics
var s []int          // s == nil, s[0] panics

2. context

The context package propagates cancellation, deadlines, and request‑scoped values across goroutine boundaries. Two base contexts are created with context.Background() and context.TODO(). Derived contexts are built with WithCancel, WithDeadline, WithTimeout, and WithValue. Each derived context embeds the parent and adds fields such as a mutex ( mu), a done channel, a list of child cancelers, and an error value.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// ctx carries deadline and can be passed to downstream calls

Advantages: reliable goroutine cancellation and value propagation. Drawbacks: potential misuse of WithValue for non‑essential data and O(n) overhead when many derived contexts are created.

3. string and rune

A string is an immutable byte slice; each modification allocates a new backing array, leaving the old one for garbage collection. Conversions can be performed safely with a copy (allocating a new []byte) or unsafely by reinterpreting the memory layout because string and []byte share the same underlying structure.

// Safe copy
b := []byte(s)
// Unsafe conversion (no allocation)
bs := *(*[]byte)(unsafe.Pointer(&s))

A rune is an alias for int32 representing a Unicode code point. The length of a UTF‑8 string can be obtained with len(s), while the number of runes is computed via utf8.RuneCountInString(s) or by converting to a []rune.

4. unsafe and pointers

The unsafe package provides unsafe.Pointer, which can point to any type. Conversions between unsafe.Pointer, concrete pointers, and uintptr enable low‑level memory manipulation, but arithmetic on unsafe.Pointer is prohibited; it must first be cast to uintptr.

var p *int
up := unsafe.Pointer(p)          // any‑type pointer
addr := uintptr(up) + 8          // pointer arithmetic on uintptr
p2 := (*int)(unsafe.Pointer(addr))

Three helper functions are provided: Sizeof, Offset, and Alignof, which return the size, field offset, and alignment of arbitrary types.

5. Memory alignment

Go follows the same alignment rules as C: each struct field is placed at the smallest offset that satisfies its alignment requirement, and the overall struct size is padded to a multiple of the largest field alignment (or the compiler’s default). Zero‑size structs ( struct{}) occupy no space, but when placed as the last field they still require alignment to avoid pointer‑leak bugs.

6. WaitGroup

sync.WaitGroup

tracks a counter of unfinished goroutines. Add(n) increments the counter, Done() decrements it, and Wait() blocks until the counter reaches zero. Internally it contains a counter, a waiter count, and a semaphore implemented by the runtime.

var wg sync.WaitGroup
wg.Add(2)
go func(){ defer wg.Done(); /* work */ }()
go func(){ defer wg.Done(); /* work */ }()
wg.Wait() // blocks until both goroutines call Done()

7. Semaphore

Semaphores expose Acquire (P) and Release (V) operations. When the internal count is zero, Acquire blocks the caller; Release increments the count and wakes a waiting goroutine. Go’s runtime implements semaphores with a lock‑free queue of waiting goroutines.

8. nocopy

The noCopy struct implements dummy Lock / Unlock methods so that go vet -copylocks can detect accidental copies of types that must remain un‑copied (e.g., sync.Mutex).

9. channel

Channels are lock‑protected ring buffers. An unbuffered channel synchronizes a sender and a receiver directly; a buffered channel stores values in an internal slice. Closing a channel prevents further sends (panic) but allows receives until the buffer is drained, after which receives yield the zero value.

ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)
for v := range ch { fmt.Println(v) }

10. slice

A slice header contains a pointer to the underlying array, a length, and a capacity. Empty slices created with make([]int, 0) have length and capacity zero but a non‑nil data pointer (zeroBase). When capacity exceeds 1024, growth follows a 1.25× factor; otherwise it doubles.

11. Memory escape

Escape analysis decides whether a variable can stay on the stack or must be allocated on the heap. Typical escape scenarios include returning a pointer to a local variable, storing a stack pointer in a heap‑allocated structure, or capturing a variable in a closure.

12. panic and recover

Common panic sources: out‑of‑bounds slice indexing, nil pointer dereference, sending on a closed channel, and concurrent map writes. recover only works inside a deferred function; the defer chain of the panicking goroutine runs before the panic propagates.

13. defer

Each defer statement is compiled into a call to deferproc, which creates a _defer struct holding the function and its arguments. The runtime stores these structs in a LIFO list. When the surrounding function returns, deferreturn executes the deferred calls in reverse order.

for i := 0; i < 3; i++ {
    defer fmt.Println(i) // i is captured by value, prints 2 1 0
}

14. goexit

runtime.Goexit()

terminates the current goroutine after running its deferred calls. It differs from os.Exit(), which terminates the entire process.

15. interface

An interface value consists of a type pointer and a data pointer. The empty interface ( interface{}) can hold any value because every concrete type implements it. Equality requires both the type and data pointers to be nil.

16. Endianness

Go runs on little‑endian hardware, but network protocols (TCP, HTTP) use big‑endian byte order. The encoding/binary package provides BigEndian and LittleEndian helpers for conversion.

17. GMP model

Go’s scheduler uses three entities: M (OS thread), P (processor, holds a run queue), and G (goroutine). Each P has a local run queue (max 256 entries) and can steal work from other P s when empty. Goroutine states include runnable, running, and waiting (e.g., syscalls).

18. Optimistic vs. pessimistic lock

Optimistic locking assumes no conflict and validates at commit time, typically using CAS; it is suited for read‑heavy workloads. Pessimistic locking acquires a mutex before the operation, protecting against concurrent writes, and is better for write‑heavy scenarios.

19. Mutex

sync.Mutex

first attempts a fast CAS lock; if it fails and the lock appears to be held briefly, it spins up to four times before parking the goroutine. Go 1.9 introduced a “starvation” mode that gives waiting goroutines priority after a 1 ms wait.

20. map

Go maps are hash tables with buckets of eight cells. The low bits of the hash select a bucket; the high bits differentiate keys within the bucket. When load factor exceeds ~6.5 or overflow buckets grow, the map expands (doubling capacity) and migrates buckets incrementally during subsequent reads/writes.

21. sync.Map

sync.Map

implements a concurrent map using a read‑only atomic map and a dirty map protected by a mutex. Reads first check the read‑only map; on miss, they consult the dirty map and increment a miss counter. When misses equal the dirty map’s length, the dirty map is promoted to read‑only.

22. Garbage collection

Go’s GC uses a tri‑color mark‑and‑sweep algorithm. The collector starts from roots (globals, stack variables), marks reachable objects (gray → black), and finally sweeps unmarked (white) objects. GC can be triggered by large allocations (>32 KB), elapsed time (default 2 min), or manually via runtime.GC().

23. Reflection

The reflect package provides Type and Value objects to inspect and manipulate values at runtime. It is used for generic libraries, serialization, and building frameworks that need type‑agnostic behavior.