Go · Expert
Optimizing Struct Memory Alignment
Go aligns struct fields based on their size. Large fields should come first to minimize padding bytes added by the compiler to ensure memory address alignment.
Open snippet →Code library
Expert Go exercises
Read these Expert Go snippets line by line — each one comes with a written breakdown of what the code does and why.
Go · Expert
Reducing GC Pressure with sync.Pool
sync.Pool allows for object reuse, significantly reducing the frequency of garbage collection cycles in high-throughput applications by recycling allocated memory.
Open snippet →Go · Expert
Zero-Allocation String to Byte Slice Conversion
Standard conversions copy memory. Using the unsafe package allows reinterpreting the underlying memory header to avoid allocations, though it requires careful management of string immutability.
Open snippet →Go · Expert
Generic Type Set Constraints
Type sets in interfaces allow generics to restrict types to a specific union. The tilde (~) operator includes types that share the same underlying primitive type.
Open snippet →Go · Expert
Request Collapsing with singleflight
The singleflight package provides a duplicate function call suppression mechanism. It ensures that for a given key, only one execution of a function is in flight at a time. If multiple goroutines c…
Open snippet →Go · Expert
High-Concurrency Map with Lock Striping
Lock striping is a pattern to reduce contention on a shared resource by splitting it into multiple independent 'shards', each with its own lock. In a highly concurrent environment, a single global…
Open snippet →Go · Expert
Profiling Specific Logic with pprof Labels
Standard CPU profiling in Go shows where time is spent across functions, but often doesn't distinguish between different contexts (e.g., which specific user or task caused the load). pprof.Do allow…
Open snippet →Go · Expert
Resource Throttling with Weighted Semaphores
Weighted semaphores allow you to control access to a shared resource pool where different tasks may consume different amounts of that resource. Unlike a simple channel-based semaphore which only co…
Open snippet →Go · Expert
Error Chain Inspection with errors.As and Unwrap
Expert Go error handling layers context around a root cause via fmt.Errorf with %w plus custom types that implement Unwrap(). errors.As walks the chain and copies the first matching typed error int…
Open snippet →Go · Expert
Labeled Break to Exit Nested Loops Cleanly
Go has no multi-level break by default — a plain break only exits the innermost loop or switch. A statement label placed before the outer for converts it into a target: break Outer transfers contro…
Open snippet →Go · Expert
Capacity-Bounded Slicing via the Three-Index Expression
A two-index slice s[low:high] keeps the original backing array's capacity all the way to its end, so a later append into the returned slice can silently overwrite memory the caller still relies on.…
Open snippet →Go · Expert
Timing-Safe Token Verification with crypto/subtle
A naive comparison like bytes.Equal or == on two strings returns as soon as it finds a difference. Network attackers can measure that early exit and brute-force a MAC one byte at a time — extending…
Open snippet →Go · Expert
Generating Cryptographically Secure Session IDs
math/rand is a deterministic PRNG seeded from a global source; given a handful of outputs an attacker can recover the seed and predict every future token. crypto/rand draws from the operating syste…
Open snippet →Go · Expert
Lock-Free Stack Implementation via Atomic Pointers
High-throughput concurrent data structures often eliminate mutex contention by leveraging Compare-And-Swap (CAS) instructions. Go 1.19 introduced generic `atomic.Pointer[T]`, allowing lock-free dat…
Open snippet →Go · Expert
Stack Trace Frame Extraction with runtime.Callers
Deep error tracing and custom observability tools often require programmatic inspection of execution call stacks without third-party libraries. Using `runtime.Callers` combined with `runtime.Caller…
Open snippet →Go · Expert
Resource Lifecycle Guards Using runtime.KeepAlive
When combining object finalizers (`runtime.SetFinalizer`) with raw handles (such as file descriptors or C pointers), the Go GC can reclaim a container struct mid-method if fields inside it are copi…
Open snippet →Go · Expert
Lock-Free Read-Copy-Update (RCU) Strategy with atomic.Value
The Read-Copy-Update (RCU) pattern enables lock-free read operations for heavily read data structures by swapping an immutable instance pointer via `atomic.Value`. Writes clone the structure under…
Open snippet →Go · Expert
Zero-Copy String and Byte Conversions via modern unsafe Package API
Go 1.17 and 1.20 introduced unsafe.Slice, unsafe.SliceData, unsafe.String, and unsafe.StringData to replace reflection-based struct hacking on StringHeader and SliceHeader. This provides explicit,…
Open snippet →Go · Expert
GC-Optimized Object Reuse with Typed Buffer Pooling via sync.Pool
sync.Pool manages reusable temporary objects to dramatically decrease Garbage Collector (GC) pressure in allocation-heavy environments. High-performance design patterns combine sync.Pool with capac…
Open snippet →Go · Expert
Biased Priority Channel Selection Pattern for High-Throughput Pipelines
Standard Go select blocks evaluate ready cases pseudo-randomly to avoid starvation. To build deterministic priority scheduling, a non-blocking select with a default clause must first probe high-pri…
Open snippet →Go · Expert
Fine-Grained Latency Profiling with runtime/trace Regions and Tasks
The standard library runtime/trace package allows developers to instrument user-level tasks, regions, and trace logs. These annotations integrate directly into execution traces generated by 'go too…
Open snippet →Go · Expert
Lock-Free Concurrent Bitset State Tracking using Atomic Bitwise Operations
Lock-free state management can be efficiently implemented over unsigned integer bitmasks using atomic Compare-And-Swap (CAS) loops. This pattern enables concurrent flag toggling without lock conten…
Open snippet →Go · Expert
Lock-Free Concurrent Stack using Generic Atomic Pointers
This snippet demonstrates how to construct a lock-free thread-safe stack using Go 1.19+ atomic.Pointer[T] generics. By employing a Compare-And-Swap (CAS) retry loop, lock contention overhead is min…
Open snippet →Go · Expert
Dynamic Multi-Channel Multiplexing via Dynamic Runtime Reflection Select Cases
When the number of channels to receive from is dynamically determined at runtime, static select blocks are insufficient. This code uses reflect.Select to construct dynamic select cases programmatic…
Open snippet →Go · Expert
Multi-Error Aggregation and Hierarchical Type Matching with Slice Unwrapping
Go 1.20 introduced support for Unwrap() []error in composite custom errors. Implementing this method enables stdlib errors.Is and errors.As to recursively traverse tree-like error graphs, allowing…
Open snippet →Go · Expert
Hermetic Subtest Isolation with Parallel Execution Control and Cleanup Hooks
Parallel testing with subtests requires careful management of closure variable capture, resource cleanup order via t.Cleanup, and helper stack trace preservation with t.Helper(). Utilizing t.Cleanu…
Open snippet →Go · Expert
Constant-Time Cryptographic Comparison and Sensitive Memory Sanitization
Timing side-channel attacks exploit execution duration differences during byte comparisons. crypto/subtle.ConstantTimeCompare executes in constant time regardless of where byte mismatches occur. Ex…
Open snippet →Go · Expert
Asynchronous Task Orchestration via Context AfterFunc Registration
Go 1.21 introduced context.AfterFunc, which schedules a closure to run in its own goroutine after a context is cancelled. Calling the returned stopFunc unregisters the handler. If stopFunc returns…
Open snippet →Go · Expert
Zero-Copy String to Slice Inspection via Unsafe Pointer Memory Primitives
Modern Go (1.20+) provides unsafe.StringData and unsafe.Slice to construct byte slice headers directly over immutable string backing arrays without heap allocations. While zero-copy conversions enh…
Open snippet →Go · Expert
Structured Call Stack Unwinding and Frame Extraction During Deferred Recover
Combining deferred recover() with runtime.Callers and runtime.CallersFrames enables production panic wrappers to extract programmatic stack frame details (file paths, line numbers, function names)…
Open snippet →