Developer common knowledge, explained — CS fundamentals, the "why" behind everyday tools, and terms worth knowing.
60 articles
TCP and UDP aren't interchangeable. We walk through the exact failure modes — head-of-line blocking, silent packet loss, Nagle delays — that show up when you pick the wrong transport.
How write-ahead logging keeps your data intact when the machine dies mid-write — the log-first rule, fsync, checkpoints, and why PostgreSQL and SQLite both rely on it.
What backpressure actually is, why an unbounded queue is a memory leak in disguise, and the four strategies a producer can take when a consumer falls behind.
A bloom filter trades a small false-positive rate for big memory savings. Here is the math behind the trade, where it pays off, and the failure mode that bites people.
A practical look at idempotency keys: why a retried payment request shouldn't charge a card twice, how the pattern works, and where it quietly breaks in production.
How CI runners, stacked-diff CLIs, code review systems, and AI coding agents build on Git's object model — blobs, trees, commits, and refs — instead of reinventing version control, and how to start building on the plumbing yourself.
Why some databases append writes and reconcile later while others edit in place — and how that one choice shapes write throughput, read latency, and disk usage.
How copy-on-write defers copying until a write actually happens — the mechanism behind fast fork(), filesystem snapshots, and database MVCC, explained with page tables and page faults.
A coroutine suspends and resumes cooperatively; a thread is preempted by the OS. Here is the real difference in scheduling, memory, and parallelism — and when each one wins.
How two's complement encodes negative integers, why CPUs run signed and unsigned math on one adder, and the edge cases — INT_MIN, overflow, sign extension — that cause real bugs.
MVCC keeps multiple versions of every row so reads never block writes. Here's how Postgres implements it with xmin/xmax, why your tables bloat, and where snapshot isolation bites.
How the circuit breaker pattern stops one slow dependency from taking down your whole service — states, thresholds, and the defaults real libraries ship with.
A Merkle tree hashes data into a single fingerprint so you can verify any piece without downloading the whole set. Here's how it works and where it already runs in your stack.
A practical look at the write-ahead log: the durability trick behind Postgres, SQLite, and most databases, and what it means when a server loses power mid-write.
Why hash(key) % N falls apart when you add a server, how the hash ring fixes it, and what virtual nodes do — a practical walkthrough for developers.
A practical explainer on conflict-free replicated data types: the merge math behind them, the main CRDT families, and how libraries like Yjs and Automerge use them.
A precise walkthrough of what happens between typing a domain and getting an IP: stub resolver, recursive resolver, root, TLD, and authoritative nameservers, plus TTLs.
A queue without back-pressure does not absorb load — it hides it until you run out of memory. Learn what back-pressure means, the four ways systems apply it, and how to add it to your own services.
A practical guide to the four SQL isolation levels, the concurrency anomalies they forbid, and how PostgreSQL and MySQL actually behave at the same level name.
A Bloom filter answers set-membership with 'probably yes' or 'definitely no' in a fraction of the space a hash set needs. Here's how it works and where it's quietly running in tools you already use.
The CAP theorem isn't 'pick two of three.' It's a rule about what happens during a network partition — and most of the time, no partition is happening at all.
The jump to senior is about judgment, scope, and influence — not more syntax. Four books that actually build the skills that get you promoted, with honest notes on who each is for.
Which mechanical keyboard is actually worth it for programming in 2026? A no-hype guide to switches, layouts, and the specific Keychron boards most developers land on — with honest sourcing.
A developer-focused monitor buying guide for 2026: why text sharpness beats refresh rate, the 27-inch 4K sweet spot, when an ultrawide is worth it, and the specific Dell and LG panels coders keep recommending.
Which noise-cancelling headphones are actually worth it for deep-focus coding and clean calls in 2026? A no-hype guide to the Sony, Bose, and Sennheiser models most developers land on.
On a remote team, sounding clear matters more than looking sharp. A no-hype guide to the webcams and microphones that make your stand-ups and pairing sessions actually pleasant in 2026.
A no-hype guide to the four desk upgrades that actually change how a developer works day to day — monitor arm, screen lighting, a sit-stand desk, and a real dock — with honest sourcing.
Not a list of 50 books you'll never read. Six software engineering books that have survived every framework churn — what each one teaches, who it's for, and the order to read them in.
ACID and BASE describe two ends of a tradeoff between strict correctness and scalable availability. Learn what each guarantee means, when each fits, and why most modern databases sit somewhere in between.
Byte order explained: how big-endian and little-endian lay out multi-byte numbers in memory, why network protocols pick one, and when the difference actually bites you.
Big-O describes how an algorithm's runtime or memory grows as input grows. Learn the common classes — O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n) — with plain examples.
A clear walkthrough of CORS and the same-origin policy — what an origin is, why your fetch fails, how servers opt in, and the big misconception about who CORS actually protects.
What environment variables actually are, why they hold config and secrets, and how PATH decides which binary runs when you type a command.
Type 0.1 + 0.2 into almost any language and you get 0.30000000000000004. Here is why IEEE 754 binary floating point does that — and how to handle it correctly.
A clear explainer of git merge versus git rebase — how each one rewrites or preserves history, what tradeoffs you accept, and the one rule you must never break.
Git is a content-addressed object store. Learn the four object types — blobs, trees, commits, tags — and why Git keeps whole snapshots instead of diffs.
Why hash tables give average-case constant-time lookups — hashing keys to indices, handling collisions, load factor, rehashing, and the O(n) worst case.
HTTPS is HTTP wrapped in TLS — a handshake that authenticates the server and sets up encryption. Here is how the keys, ciphers, and certificate chain of trust actually fit together.
Why HTTP status 418 exists, where it came from (an April Fools' RFC about coffee pots), and what it teaches you about how status codes are actually organized.
What idempotent means in practice — how it shapes HTTP method semantics, why it makes retries safe over flaky networks, and how the idempotency key pattern stops duplicate charges.
A mutex enforces exclusive access to a critical section; a semaphore is a permit counter that allows up to N holders. Here is when to reach for each.
Three values that all mean 'nothing or invalid' in JavaScript — but null, undefined, and NaN each tell a different story. Here is how to read them.
Why mutating an object inside a function works in Python and Java but reassigning the parameter doesn't — and how that differs from C copies and C++ references.
What a pointer actually is, how references differ, why they power linked lists and trees, and how higher-level languages hide raw addresses behind reference semantics.
A race condition is when a program's correctness depends on the unpredictable timing of concurrent operations. Here's why they happen, the classic lost-update bug, and how to fix them by design.
Recursion and iteration both repeat work — but recursion leans on the call stack to remember where it was. Here is what that means, and when it bites.
A clear explainer of stack vs heap memory — call stacks, automatic vs dynamic allocation, why the stack is fast, and what causes a stack overflow versus heap exhaustion.
Latency is how long one operation takes; throughput is how many complete per second. They're related but distinct — here's how batching, parallelism, and pipelining trade one for the other.
How the Unix pipe connects one command's output to the next, why streams (stdin, stdout, stderr) matter, and how composition lets tiny tools replace a custom script.
Unicode is the standard that gives every character a number; UTF-8 is one way to turn those numbers into bytes. Here is how they fit together and why it matters.
A clear, step-by-step walk through the full browser request lifecycle — URL parsing, DNS, TCP, TLS, the HTTP exchange, and how the page actually renders.
Thread-safe code behaves correctly when multiple threads run it at once. Here is the real root cause — shared mutable state — and the tools that actually fix it.
How foo, bar, and baz became the default placeholder names in code examples — the FUBAR slang theory, MIT hacker roots, and the other placeholder traditions worth knowing.
The 80-column line limit comes from IBM punched cards and early terminals — but the readability and side-by-side-diff benefits are why it still survives in modern style guides.
Zero-based indexing isn't arbitrary — it falls out of how arrays are stored in memory, where an index is really an offset from the array's starting address.
The story behind the 'Hello, World' tradition — how it spread from a 1970s C tutorial, and why printing one line is still the smartest first thing you do in any new language.
A clear explanation of the loopback address — why traffic to 127.0.0.1 never leaves your machine, how localhost resolves to it, and why this matters for local development.
Port numbers stop at 65535 because TCP and UDP store them in a 16-bit field. Here is what that means, how IANA splits the range, and why low ports need root.
The 1947 Harvard Mark II moth is real and taped into a logbook — but 'bug' was already engineering slang decades before. Here's the honest story.
Passwords are hashed, not encrypted — because you never need to read them back, only check them. Here is why one-way hashing, salts, and slow algorithms like bcrypt matter.
One email every Friday with the tools worth your time. No spam, unsubscribe anytime.