Computer Science
Linear algebra, graph theory, discrete math, and the deeper mathematical foundations that make computing possible.
Bloom Filters: Trading Certainty for Speed in a Probabilistic Data Structure
A bouncer with a shortcut checklist doesn't reread the whole guest list for every arrival -- Bloom filters get that same speed by giving up perfect certainty.
COMPUTER SCIENCETwo's Complement: How Computers Represent Negative Numbers
Computers have no minus sign in their circuitry, so negative numbers are represented with a wraparound trick borrowed from something as ordinary as a car odometer.
COMPUTER SCIENCEAmortized Analysis: Why a Dynamic Array's "Occasional Slow Append" Isn't a Bug
Big-O tells you the worst case of one operation; amortized analysis tells you the average cost across a whole sequence of them -- and that number is what actually matters for a dynamic array.
COMPUTER SCIENCENP-Hard vs. NP-Complete: Sorting Out the Vocabulary After "P vs. NP"
Every NP-complete problem is NP-hard, but not every NP-hard problem is NP-complete — one extra requirement is what separates the two terms.
COMPUTER SCIENCEHeaps and Priority Queues: The Structure Behind "What's Next"
A hospital triage line doesn't treat patients in the order they arrived — it treats the most urgent one next, and a heap is the data structure built for exactly that.
COMPUTER SCIENCEDivide and Conquer: The One Pattern Behind Merge Sort, Quicksort, and Binary Search
Flipping to the middle of a phone book instead of reading it page by page is the same trick that makes three "unrelated" sorting and searching algorithms actually one idea.
COMPUTER SCIENCEWhat a Derivative Actually Measures, and Why Gradient Descent Uses It
A derivative is just a slope — and gradient descent is nothing more than following that slope downhill, one small step at a time.
COMPUTER SCIENCEFinite State Machines: The Simple Idea Behind Regex Engines and Traffic Lights
A traffic light never remembers how long it's been green -- it just knows which color it is right now, and that's the entire idea behind a finite state machine.
COMPUTER SCIENCEBig-O's Cousins: Big-Omega and Big-Theta, and Why Worst-Case Isn't the Whole Story
Big-O only promises an upper bound on how bad things get — Big-Omega and Big-Theta describe the best case and the tight, honest middle.
COMPUTER SCIENCEProbability for Developers: Why Hash Collisions and Load Balancing Both Come Down to the Birthday Problem
A room of just 23 people has better-than-even odds of a shared birthday -- and that same surprising math governs when your hash table and your load balancer both start clumping.
COMPUTER SCIENCESet Theory Basics: Why Databases Think in Unions and Intersections
Every SQL JOIN and UNION you've ever written is set theory wearing a friendlier name.
COMPUTER SCIENCEModular Arithmetic: The Math Behind Clocks, Hashing, and Cryptography
Every clock on the wall is already running a program in modular arithmetic -- and so is every hash table and every encryption scheme.
COMPUTER SCIENCEWhat a Matrix Actually Is, and Why Programmers Should Care
A matrix is a spreadsheet with a rulebook for combining it with other spreadsheets — the intimidating part is the notation, not the idea.
COMPUTER SCIENCEWhat Big-O Actually Measures (and What It Doesn't)
Big-O describes how an algorithm's workload grows as the input grows — not how fast it runs on your machine today, and not how it behaves on a typical, average input.
COMPUTER SCIENCEP vs. NP, Explained for People Who Don't Need to Prove Anything
Some problems are as easy to check as they are to solve. Others are easy to check and, as far as anyone has ever proven, brutally hard to solve — and nobody knows for certain those two categories are actually different.
COMPUTER SCIENCEHow a CPU Actually Executes an Instruction
A CPU doesn't "understand" your program — it repeats the same three-step loop, billions of times a second, on one tiny instruction at a time.
COMPUTER SCIENCEHow GPS Finds the "Fastest" Route: Dijkstra's Algorithm
Your phone doesn't try every possible route. It keeps a running tally of the cheapest known way to reach each intersection, and only ever updates that tally when it finds something better.
COMPUTER SCIENCERecursion and Induction: Proving Code and Proving Math Are the Same Idea
A line of falling dominoes and a recursive function solve their problem the exact same way: handle the very first case, then trust that each step correctly sets up the next.
COMPUTER SCIENCEEigenvalues and Eigenvectors, Explained Without the Textbook Notation
An eigenvector is a direction a transformation doesn't rotate — it only stretches or shrinks it. The eigenvalue is just the amount of that stretch.
COMPUTER SCIENCEWhy a Hash Table's Performance Can Silently Degrade Over Time
A hash table is fast because it has room to spread items out. Fill it up without letting it grow, and it slowly turns into the slow, item-by-item search it was built to avoid.
COMPUTER SCIENCESorting Algorithms, Compared Honestly
There isn't one best sorting algorithm — there's a right one for a given size of data, how sorted it already is, and whether equal items need to keep their original order.
COMPUTER SCIENCEBFS vs. DFS: Two Ways to Walk a Graph
Breadth-first search spreads out like a ripple in a pond; depth-first search commits to one path like a maze-runner. Same graph, two very different visiting orders.
COMPUTER SCIENCEGreedy vs. Dynamic Programming: When the "Obvious" Answer Is Wrong
A greedy algorithm always takes the best-looking option right now. Sometimes that's provably optimal. Sometimes it walks straight past the actual best answer.
COMPUTER SCIENCEHow Rotation and Scaling Actually Work
A transformation matrix is a small, reusable recipe for "spin this" or "stretch this" — the same handful of numbers applies to every point in a shape at once.
COMPUTER SCIENCECombinatorics for Developers: When "How Many Ways" Questions Matter
Combinatorics is just careful counting — and it's the math behind password strength, test coverage, and why a four-digit PIN is weaker than it feels.
COMPUTER SCIENCETrees Are Just Graphs With Rules
A family tree, a file system, and a company org chart are all the same shape: one graph, with the rule that nothing ever connects back to where it came from.
COMPUTER SCIENCEStacks and Queues: The Structures Behind Undo Buttons and Print Queues
A stack is a pile of dishes. A queue is a checkout line. Two of the simplest ideas in computer science, and two of the most quietly everywhere.
COMPUTER SCIENCEVectors and Dot Products: The Math Under Every 3D Game
A vector is just an arrow with a direction and a length. The dot product is how code asks two arrows whether they're pointing the same way.
COMPUTER SCIENCEHashing: Why It's Fast, and What a Collision Actually Costs You
A hash function is a coat-check ticket machine — a fast way to convert something into a short number that (usually) points straight to the right slot.
COMPUTER SCIENCEWhat a Graph Actually Is (and Why It's Not a Chart)
In computer science, "graph" means dots connected by lines — a map of relationships, not a bar chart. The vocabulary collision trips up almost everyone at first.
COMPUTER SCIENCEBoolean Logic and Truth Tables: The Math Under Every "if"
Every `if` statement you've ever written is Boolean logic — a system built on nothing but true, false, and three ways of combining them.
COMPUTER SCIENCEBinary, Then Hex: Why Computers Count Differently
A computer counts in binary because a transistor only reliably knows two states, on and off. Hexadecimal exists purely as a shorthand for humans reading all those on/off values.