Developer common knowledge, explained — CS fundamentals, the "why" behind everyday tools, and terms worth knowing.
32 articles
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.