Practical Go Foundations
A practical reading path through the core language ideas and trade-offs that shape everyday Go code.
Why Go? A Practical Look at Where Go Stands Among Programming Languages
A practical look at where Go stands among programming languages, from compile time and runtime trade-offs to garbage collection, deployment, and operational simplicity.
Read article →Go Variables and Types: Simple on the Surface, Opinionated Underneath
A practical look at how Go handles variables and types, from zero values and short declarations to byte, rune, constants, conversions, shadowing, and scope.
Read article →Go if Statements: Simple, but Opinionated
A practical look at how if works in Go, from basic branching and short statements to scope, shadowing, and why Go keeps conditionals deliberately plain.
Read article →Go Functions: Simple Signatures, Real Trade-offs
A practical look at how Go functions work in real code, from signatures and return values to early returns, higher-order functions, closures, variadics, any, and defer.
Read article →Go Structs: Simple Data, Real Design Decisions
A practical look at how structs work in Go, from zero values and nested data to embedding, tags, methods, and value semantics.
Read article →Go Interfaces: Small Contracts, Real Trade-offs
A practical look at how interfaces work in Go, from small behavioral contracts and implicit implementation to type assertions, nil behavior, method sets, and real design trade-offs.
Read article →Go Errors: Explicit by Design, Better or Worse
A practical look at how errors work in Go, from plain errors and early returns to wrapping, sentinels, custom error types, errors.Is, errors.As, errors.Join, and cleanup semantics.
Read article →Go Loops: Practical Patterns
A practical look at how loops work in Go, from retry and pagination loops to range, batching, break, continue, and worker patterns.
Read article →Go Arrays, Slices, Properly: From Basics to Production Pitfalls
A practical mental model for Go arrays and slices, from fixed-size arrays and shared backing storage to append, copy, nil vs empty slices, and production memory pitfalls.
Read article →Go Maps, Properly: From Simple Lookups to Production Trade-offs
A practical look at how maps work in Go, from simple lookups and grouping to nil maps, shared mutation, iteration order, composite keys, concurrency, and real production trade-offs.
Read article →Go Pointers, Properly: From Basic Syntax to Real-World Semantics
A practical look at how pointers work in Go, from basic syntax and shared mutation to receiver semantics, repository flows, nil design, and real-world trade-offs.
Read article →Practical Go Foundations: Concurrency in Go, from Basics to Production Reality
A practical guide to Go concurrency, from sequential defaults and goroutines to channels, select, context, worker pools, backpressure, mutexes, and errgroup.
Read article →Mutex in Go: What It Solves, What It Hides, and Where It Breaks
A practical guide to what mutexes solve in Go, how lock scope and contention shape performance, and where mutex-heavy designs start to break down.
Read article →