Blog
Some of these posts are deeply technical, on Go internals, performance, and the systems I build. Others step back from code, with essays on technology, quality, and culture.
-
Zero-Deficit Engineering: Treat Trade-offs as Design Questions
A practical discipline that tests claimed trade-offs, verifies hard constraints, and removes avoidable gaps between engineering objectives and design results.
-
The Great Regression: How Quality Died While We Were Told Things Were Getting Better
A critical examination of how quality has systematically declined across software, healthcare, manufacturing, construction, education, and beyond, while being marketed as progress.
-
Why Transaction Logs Matter: The Idea That Became Remac
Why batch jobs, polling, and application relays can leave gaps, what database transaction logs make possible, and how an early PostgreSQL-to-file prototype became Remac.
-
Building Torus: Architecture Decisions and Trade-offs
Learn the engineering decisions behind building a production DHT in Go. Explore trade-offs between gRPC vs REST, consistency vs availability, and scalability patterns.
-
Finger Tables and O(log N) Routing: Chord's Magic
Understand how Chord achieves logarithmic routing with finger tables. Learn the algorithm that powers efficient key lookups in distributed hash tables.
-
The Ring and Consistent Hashing: Chord's Foundation
Master the core concepts behind the Chord DHT protocol. Understand why consistent hashing uses a ring topology and how it minimizes data movement in distributed systems.
-
Why Distributed Hash Tables Matter: The Problem Space
Discover why distributed hash tables power systems like BitTorrent and IPFS. Learn how DHTs solve the coordination problem in distributed systems without central servers.
-
The Invisible Man: How Go's Standard Library Tricks the Compiler
Discover how Go's standard library uses NoEscape and Escape functions to manipulate escape analysis. Deep dive into compiler optimization tricks.
-
Breaking the Glass: A Deep Dive into Go's Unsafe Package (Part 3)
Explore zero-copy performance wins with unsafe in Go and learn about architectural pitfalls that cause silent data corruption. Final part of the unsafe series.
-
Part 5: The Garbage Collector Tax (Pointers vs. Values)
Understand how pointers impact Go's garbage collector performance. Learn when to use values vs pointers to minimize GC latency in high-performance applications.
-
Breaking the Glass: A Deep Dive into Go's Unsafe Package (Part 2)
Master pointer arithmetic in Go using unsafe. Learn the pointer arithmetic dance and understand the risks of uintptr conversions.
-
Part 4: The Hidden Headers (Strings, Slices, Interfaces, and Maps)
Explore Go's internal memory layout for strings, slices, interfaces, and maps. Understand how these complex types work under the hood.
-
Part 3: CPU Caches and False Sharing
Discover how CPU cache lines affect Go performance and learn to prevent false sharing in concurrent programs. Essential knowledge for high-performance Go applications.
-
Breaking the Glass: A Deep Dive into Go's Unsafe Package (Part 1)
Learn when and how to use Go's unsafe package. Understand the difference between *T, unsafe.Pointer, and uintptr, plus GC visibility rules.
-
Part 2: Structs, Padding, and Wasted Bytes
Master struct padding in Go and learn how to optimize memory layout. Save RAM by reordering fields and understanding alignment requirements.
-
Part 1: The Fundamentals of Memory
Understand memory alignment, CPU word sizes, and why your variables cost more than you think. First part of the Go memory optimization series.
-
Cryptographic Security: Constant-Time Byte Comparison
Learn how timing attacks work and why constant-time byte comparison is critical for cryptographic security in Go. Deep dive into Go's crypto package implementation.