One idea.
One short video.
Narrated explainers on the things engineers keep confusing — precision vs recall, what mmap really does, why more cores can make a program slower. Every one has a written companion page, so you can read it instead. Free, no sign-up.
Zero-Copy: How Servers Send Files Without Touching the Data
Sending a file the naive way copies the same bytes four times and crosses the kernel boundary four times, even though the application never reads them. sendfile() and scatter-gather DMA cut that down to zero CPU copies — the reason nginx, Kafka, and Netty can push huge files without breaking a sweat.
Watch or read →
The OSI Model: How a Message Crosses the Internet, Layer by Layer
A message crosses WiFi, copper, fiber, and routers and arrives intact because the network is a stack of layers, each doing one job and talking only to its direct neighbor. Going down the stack, each layer wraps the data in its own header — boxes inside boxes — and the far side unwraps them one by one going back up.
Watch or read →
NUMA: Why More CPU Cores Can Make Your Program Slower
Move a fast multithreaded program to a bigger server with more cores and it can run slower — same code, same data. On a big machine, memory isn't one uniform pool: each CPU socket has its own bank of RAM, and reaching another socket's memory is roughly twice as slow as reaching your own.
Watch or read →
mmap: How to Read a 50GB File Without 50GB of RAM
How memory-mapped files let a process address a file directly instead of copying it into a buffer — mapping loads nothing up front, and the OS pulls in only the 4KB page you actually touch, via a page fault and the shared page cache.
Watch or read →
malloc: Where Does Memory Come From (and Why free() Doesn't Give It Back)?
Your program calls malloc and free millions of times a second with no system call each time, because the allocator sits between you and the OS: it buys memory wholesale in big slabs and hands you small pieces retail, tracking what's free on its own shelf.
Watch or read →
io_uring: How One System Call Does the Work of Thousands
A server handling 100,000 connections is often slow not because the network is slow, but because of system calls — every read or write crosses the wall between user space and the kernel. io_uring shares two ring buffers with the kernel so a whole batch of requests can be submitted and completed with barely any crossings at all.
Watch or read →
epoll: How One Server Holds a Million Connections
Why servers used to fall over around ten thousand connections (the C10K problem), and how Linux's epoll flips the cost model from checking every connection to checking only the active ones — the mechanism under nginx, Redis, and Node's event loop.
Watch or read →
Classification vs Regression: Which Bucket, or How Much?
Classification sorts input into a fixed set of discrete buckets — cat or dog, spam or not — and is scored by accuracy. Regression predicts a continuous number on a line, like temperature or price, and is scored by how far off the prediction lands.
Watch or read →
Greedy vs Dynamic Programming: Grab the Best Now, or Plan the Whole?
Making change for 6 with coins {1, 3, 4}: greedy grabs the biggest coin that fits each time and never looks back, landing on 4+1+1. Dynamic programming solves every overlapping subproblem once and remembers the best answer, finding the true optimum of 3+3.
Watch or read →
Cookies vs Sessions vs Tokens: Who Remembers You're Logged In?
HTTP is stateless, so the server forgets you between requests. A cookie is just the envelope carrying the real answer — the actual axis is where the login state lives: on the server (a session) or inside the token itself (a JWT).
Watch or read →
Supervised vs Unsupervised vs Reinforcement: The 3 Ways a Machine Learns
Three classic ways to teach a machine, like teaching a child three different ways: labeled flashcards, an unsorted toy box, or a game with a score. What your problem gives you decides which one applies.
Watch or read →
Recursion vs Iteration: Two Shapes for the Same Job (and Why One Crashes)
Recursion solves a problem by having a function call a smaller version of itself down to a base case, then combines the answers back up — a natural fit for self-similar problems. Iteration solves the same problem with a loop and a running total, and never grows the call stack.
Watch or read →
Pass by Value vs Pass by Reference: The Gotcha That Breaks Brains
Change a variable inside a function — does the caller see it? Most popular languages pass the reference itself by value: a copy of the address, so you can mutate the shared object but can't reassign the caller's variable. The real split isn't value-vs-reference, it's mutate vs reassign.
Watch or read →
Latency vs Throughput: The Two 'Faster's People Confuse
Latency is how long one request takes end to end — what a single user feels. Throughput is how many requests the system handles per second — the fleet's capacity. Below capacity they barely interact; push toward the limit and queues form, and latency spikes even though nothing about a single request changed.
Watch or read →
Hashing vs Encryption vs Encoding: 3 Things Every Dev Confuses
Encoding, encryption, and hashing get used like synonyms but do three different jobs. The tell is whether you need the original back, and for whom: encoding is reversible by anyone (no key), encryption is reversible only with a key, and hashing is not reversible at all.
Watch or read →
Compiled vs Interpreted: It's Just a Question of When Your Code Gets Translated
Your code is text a CPU can't run — something has to translate it, and compiled-vs-interpreted is just a question of when. A compiler translates the whole program up front into a fast executable; an interpreter translates it line by line at runtime.
Watch or read →
Bias vs Variance: The Two Ways a Model Misses (and Why You Can't Kill Both)
Bias is how far off-target a model sits on average — a too-simple model that underfits. Variance is how inconsistent it is across different training sets — a too-complex model that overfits. You cannot minimize both at once, so the goal is the minimum of their sum.
Watch or read →
Authentication vs Authorization: Who You Are vs What You Can Do
Authentication proves who you are, like passport control. Authorization decides what you may do once you're in, like a boarding pass and a lounge door. Even the HTTP status codes are misnamed: 401 Unauthorized really means unauthenticated, and 403 Forbidden is the real not-authorized.
Watch or read →
Static vs Dynamic Typing: Proofread Now, or Find the Typos Live?
When are a program's types checked — before it runs, or while it runs? Static typing catches mismatches at compile time; dynamic typing only discovers them when that exact line executes. The difference is when you pay for the mistake, not whether you pay.
Watch or read →
Stateless vs Stateful: Remember the User, or Hand Them a Ticket?
Two ways to handle client state between requests: a stateful server keeps your session in its own memory so every request must return to the same machine, while a stateless server keeps nothing — each request carries what it needs, so any instance can handle any request.
Watch or read →
Precision vs Recall: Which Mistake Can You Live With?
A classifier is wrong two different ways: flag something real as bad, or miss the bad thing entirely. Precision and recall score those two mistakes separately, and you can't maximize both at once — the threshold trades one off against the other.
Watch or read →
Normalization vs Denormalization: One Master Copy, or Photocopies Everywhere?
Two opposite schema philosophies trading correctness for speed: normalization stores each fact exactly once and joins to read it back; denormalization copies the data into every row that needs it so reads skip the join, at the cost of keeping every copy in sync.
Watch or read →
Discriminative vs Generative Models: A Critic, or an Artist?
Two opposite ways a model learns from data: a discriminative model only learns the boundary between classes, while a generative model learns the full distribution of each class well enough to create new samples — which is exactly what makes modern generative AI generative.
Watch or read →
Cross-Validation: One Exam, or Five?
A single hold-out test set gives a fragile score that swings with which rows you happened to hold out, and wastes data the model never trains on. K-fold cross-validation rotates the test set across k folds and averages the scores for a far more stable estimate — while using every row for both training and testing.
Watch or read →
Bagging vs Boosting: A Jury, or a Relay?
Two opposite ways to combine many weak models into one strong ensemble: bagging trains models independently and averages their votes to cancel out variance, while boosting trains models sequentially, each one fixing the last one's mistakes, to reduce bias.
Watch or read →