Golang

Allocation and initialization differences between new and make.

Runtime type/value inspection, settable values, interfaces, tags, and reflection trade-offs.

Explicit error returns, wrapping, classification, inspection, and preserving operational context.

Implicit interface satisfaction, dynamic type/value pairs, nil subtleties, and API design.

First-class functions, multiple returns, closures, methods, variadics, and value semantics.

Immutable byte sequences, UTF-8 conventions, runes, indexing, conversion, and allocation.

Hash maps, zero-value reads, mutation, iteration, concurrency rules, and implementation-sensitive internals.

Low-level pointer/layout operations, guarantees, portability risks, and containment strategies.

Panic unwinding, deferred cleanup, recovery boundaries, and when not to use panic.

Defined and alias types, interfaces, method sets, assignability, conversion, generics, and zero values.

Fixed-length value types, copying semantics, indexing, iteration, and their relationship to slices.

Slice descriptors, backing arrays, append/capacity, sharing, copying, and retention pitfalls.

Deferred calls, LIFO execution, argument evaluation, return interaction, and practical cleanup patterns.

Go context trees for cancellation, deadlines, timeouts, and request-scoped values, with lifecycle rules for passing and canceling contexts.

Waiting for a group of goroutines to finish with Add, Done, and Wait, including the counter lifecycle and common Add/Wait misuse.

A map of Go's shared-memory synchronization primitives: Mutex, RWMutex, Once, Cond, Map, Pool, WaitGroup, and atomic operations.

Go's specialized concurrent map, its intended workloads, read-optimized internal design, atomic map operations, and when a normal map plus mutex is clearer.

Temporary object reuse, GC interaction, per-P optimization, and when pooling helps.

How Go `select` waits on multiple channel operations, chooses among ready cases, uses `default`, handles nil channels, timeouts, and cancellation.

Exactly-once process-local initialization and its concurrency semantics.

Exclusive access to shared state with Go's Mutex, including zero-value usage, memory-ordering guarantees, critical-section design, and common mistakes.

Go's reader/writer mutex: concurrent readers, exclusive writers, writer preference, non-upgradable locking, and when RWMutex is actually useful.

Condition variables for waiting on state predicates under a lock.

Go atomic operations, compare-and-swap, typed atomic values, atomic.Value, memory ordering, and when atomics are appropriate instead of locks.

Go channels as typed communication and synchronization primitives: buffered vs. unbuffered behavior, closing, ownership, blocking semantics, and runtime implementation.

A map of Go concurrency: goroutines, channels, synchronization primitives, the memory model, happens-before relationships, and common concurrency patterns.

What goroutines are, how `go f(...)` starts concurrent execution, how their stacks differ from OS-thread stacks, and how the runtime schedules them.

Bounded concurrency, worker pools, queues, backpressure, and when a goroutine pool is unnecessary.

The Go scheduler's G, M, and P abstractions, local run queues, work stealing, blocking syscalls, GOMAXPROCS, and asynchronous preemption.

How the Go compiler decides whether values can live in stack frames or must escape to longer-lived storage, how to inspect decisions, and why `new` does not imply heap allocation.

From parsing and type checking through SSA/optimization, code generation, linking, modules, and build cache.

Stacks, heap, allocation, escape analysis, garbage collection, and observable memory metrics.

Reading Go assembler syntax, ABI-sensitive registers, stack frames, and generated machine code.

Alignment, padding, struct layout, cache effects, and portable reasoning about field order.

Go's concurrent tracing garbage collector, mark/sweep phases, write barriers, GC pacing, GOGC, memory limits, observability, and tuning priorities.

Small growable goroutine stacks, stack growth, copying, and escape-driven heap allocation.

Go runtime heap allocation, size classes, spans, per-P caches, sweeping, and GC interaction.

Testing package conventions, table-driven tests, subtests, race checks, fuzzing, and maintainable boundaries.

Profiling Go programs with CPU, heap, allocation, goroutine, mutex, and block profiles, plus a measurement-first workflow for finding performance bottlenecks.

Writing repeatable Go benchmarks and interpreting time, allocations, variance, and compiler effects.

How Go programs retain memory through reachable objects, goroutine leaks, timers/channels, and non-Go memory, with a pprof-based diagnostic workflow.

Tracing goroutine scheduling, blocking, GC, network/syscall events, and runtime execution over time.