Awesome Scalability
The blogs listed on the page are really useful for my work and understanding how complex and scalable systems are built.
The Magic of BPF
Brendan Gregg introduces eBPF, the technology that revolutionized Linux kernel observability and performance engineering.
Raft: In Search of an Understandable Consensus Algorithm
Diego Ongaro and John Ousterhout’s 2014 paper that strips away heavy math to provide a consensus algorithm engineers can actually build. The definitive guide to how clusters (like Kubernetes) manage state.
The 5 Minute Rule for Trading Memory for Disk Accesses
Jim Gray's 1987 classic economic analysis on caching physics. It remains the foundational math for modern RAM vs. SSD decisions.
The Mother of All Demos
Doug Engelbart's 1968 presentation. The literal source code for the mouse, hypertext, and modern computing interfaces.
Everything is a File
A deep dive into the core UNIX philosophy and how the `/proc` filesystem and file descriptors actually govern the OS.
Whats a Service Mesh?
William Morgan (creator of Linkerd) explains the fundamental shift from application-level retry logic to infrastructure-level sidecar proxying.
The Mythical Man-Month
Fred Brooks' timeless essay on software engineering management. Adding manpower to a late software project makes it later.
Randomness in Security (dev/random vs dev/urandom)
A deep technical explanation of how Linux generates entropy, and why true randomness is incredibly difficult for deterministic machines.
Epoll is fundamentally broken
A brutally technical teardown of Linux I/O multiplexing and the edge cases of edge-triggered vs level-triggered epoll.
Big Data: The end of the beginning
A retrospective on the Hadoop era and the architectural shift toward real-time, columnar OLAP storage (like ClickHouse).
The Log: What every software engineer should know about real-time data's unifying abstraction
Jay Kreps breaks down the fundamental data structure behind distributed systems, event sourcing, and Apache Kafka.
Notes on Distributed Systems for Young Bloods
Practical, hard-won, and cynical advice on building distributed systems that don't fail catastrophically in production.
Choose Boring Technology
Dan McKinley's masterpiece on 'innovation tokens' and why you should probably just use Postgres and PHP.
The USE Method
Brendan Gregg's foundational methodology for analyzing the performance of any system (Utilization, Saturation, Errors).
Reflections on Trusting Trust
Ken Thompson's Turing Award lecture on compiler backdoors and why you can't truly trust code you didn't write yourself.
Smashing the Stack for Fun and Profit
Aleph One's legendary 1996 Phrack article that introduced buffer overflows and memory corruption to the masses.
The Tail at Scale
Jeff Dean explains why the 99th percentile latency matters in large-scale systems and how Google handles it.
Falsehoods Programmers Believe About Time
A humbling, terrifying reminder of how complicated dates, timezones, and leap seconds actually are.
A Dao of Web Design
John Allsopp's 2000 essay that laid the philosophical groundwork for responsive web design and fluidity.
The TTY demystified
Ever wonder why your terminal behaves weirdly? This explains the archaic, fascinating history of the TTY subsystem.
Out of the Tar Pit
A 2006 deep dive by Ben Moseley and Peter Marks into why software becomes complicated. It champions clear mechanics and simplicity over messy shortcuts, fundamentally changing how you view system architecture.
Jepsen: Distributed Systems Safety Research
Kyle Kingsbury tortures databases by cutting network partitions and mathematically proving they lose your data.
Postmortem: GitLab database incident
A masterclass in transparent incident reporting after an engineer accidentally deleted the production database.
Maker's Schedule, Manager's Schedule
Paul Graham explains why a single 30-minute meeting can destroy an entire afternoon for a programmer.
Architecture of a Database System
A deep architectural breakdown of how relational databases actually process, plan, and execute queries under the hood.
How the Kernel Manages Your Memory
Gustavo Duarte's brilliant visual explanation of Linux memory management, page tables, and virtual address spaces.
The Law of Leaky Abstractions
Joel Spolsky's core thesis: all non-trivial abstractions, to some degree, are leaky and will eventually require you to learn the underlying layer.
What Screens Want
Frank Chimero on the nature of digital design, the canvas of the web, and designing for native fluidity.
You Are Not Google
A sharp critique of over-engineering your startup with microservices and Kubernetes. You don't have Google's scaling problems.
Let's Build a Simple Database
Writing a sqlite clone from scratch in C. The ultimate, hands-on way to understand B-Trees and memory paging.
The C10K Problem
The original classic on handling 10,000 concurrent connections. A must-read for anyone building high-throughput systems.
What Every Programmer Should Know About Memory
Ulrich Drepper's incredibly dense, 100-page deep dive into CPU caches, memory banks, and hardware reality.
Falsehoods Programmers Believe About Names
Patrick McKenzie lists 40 assumptions engineers make about user names that will inevitably break your validation logic.
On Being A Senior Engineer
John Allspaw (Etsy/Flickr) details the behavioral and psychological traits that separate mature engineers from junior ones.
Fallacies of Distributed Computing Explained
The classic 8 assumptions everyone makes when building networked applications, and why the network is never actually reliable.
Dynamo: Amazon's Highly Available Key-value Store
Amazon’s 2007 masterclass in making smart trade-offs. The blueprint for building a highly available key-value store that handles data conflicts and physical failures gracefully.
Dapper, a Large-Scale Distributed Systems Tracing Infrastructure
Google’s 2010 blueprint for modern observability. Explains how to track requests across massive distributed chains without slowing down the underlying services.
C-Store: A Column-oriented DBMS
Mike Stonebraker’s 2005 paper proving why columnar storage is vastly superior for analytical workloads by aligning with hardware read realities.