@pointerwalk
CS you can watch run.
Algorithms, data structures, system design and AI, explained step by step with animations you can pause, replay and poke.
- 13
- subjects
- 115
- topics
Binary search
find 41
Start in the middle.
1check
How it works
Every page teaches the same way
- 01
Watch it run
Every idea starts as an animation. You see the algorithm or the system move before you read a word about it.
- 02
Read it step by step
Short sentences, one step at a time, with a worked example for each. No step assumes the next one.
- 03
Try it yourself
Pause, step forward one move at a time, change the input, and compare approaches on the same data.
Subjects
Pick where to start
The same subjects the videos cover. Each one is a set of short pages you can read in any order.
System Design
How real systems stay fast and stay up: spreading load, caching, limiting traffic, and surviving failure.
0%12 topics · 12 ready
Data Structures
The shapes data is stored in, shown changing as items go in and out, and what each shape makes cheap.
0%13 topics · 13 ready
Algorithms
Step-by-step recipes for searching, sorting and finding routes, run on real inputs so you can count the work.
0%11 topics · 11 ready
Databases
What a database does with your query: indexes, joins, transactions, locks, and the log that keeps data safe.
0%12 topics · 12 ready
AI and Machine Learning
What a language model does with your prompt, from tokens to the next word, and how models learn at all.
0%10 topics · 10 ready
Languages and Runtimes
The surprises inside everyday code: numbers, strings, scope, hidden costs, and what the runtime does behind your back.
0%14 topics · 14 ready
Distributed Systems
Many machines that must agree with each other while the network between them drops, delays and splits.
0%7 topics · 7 ready
Networking
What travels between your browser and a server, one hop and one handshake at a time.
0%7 topics · 7 ready
Security
How secrets stay secret: encrypted connections, stored passwords, and hashes that prove nothing changed.
0%7 topics · 7 ready
Operating Systems
How one machine shares its CPU, memory and disk between everything that wants them.
0%6 topics · 6 ready
Concurrency
Several things happening at once on shared data, and the tools that keep them from stepping on each other.
0%5 topics · 5 ready
Maths for Programmers
The small pieces of maths that keep turning up in code: probability, primes and sequences.
0%6 topics · 6 ready
Developer Tools
The tools you use every day, opened up: what Git writes to disk and how to read any regular expression.
0%5 topics · 5 ready
Ready to read
Start with one of these
Load Balancing
How one address spreads requests over many servers, and the eight algorithms that decide who gets the next one.
Not started.Beginner14 minCache Eviction Policies
The cache is full. LRU, LFU, FIFO and Random each throw out a different item, and no policy wins on every workload.
Not started.Beginner10 minCaching Strategies
Cache-aside, read-through, write-through, write-behind and refresh-ahead: who writes, who reads, and when each serves stale data.
Not started.Intermediate12 minCache Stampede
One popular key expires and every request rebuilds it at once. Why it happens and three ways to stop it.
Not started.Intermediate8 minRate Limiting
Fixed window, sliding window, token bucket and leaky bucket face the same burst, and one of them lets twice the limit through.
Not started.Intermediate11 minConsistent Hashing
Add a server and most keys stay where they are. The hash ring, compared with plain modulo hashing.
Not started.Intermediate10 minRetries, Backoff and Jitter
A brief stall turns into an outage when every client retries at once. Exponential backoff and jitter spread them out.
Not started.Intermediate9 minSharding and Hot Keys
One shard drowns while the rest sit idle. Why adding servers does not help while one key owns the load.
Not started.Intermediate9 minQueues and Backpressure
Producers that are 1% faster than consumers build a queue that never ends. Backpressure is how the slow side says stop.
Not started.Intermediate9 minCascading Failures and Load Shedding
One server dies, the rest go over 100% and fall in turn. Refusing some requests keeps the others alive.
Not started.Intermediate9 minREST, gRPC or GraphQL
Three ways for programs to talk. Who calls it, how many round trips, and how strict the contract needs to be.
Not started.Beginner9 minMonolith or Microservices
Team size, deploy frequency and whether the parts scale differently: the questions that decide it.
Not started.Beginner8 minHash Tables
One key, one bucket, no searching. Then two keys collide: chaining, probing, and when O(1) stops being true.
Not started.Beginner13 minBloom Filters
Three bits decide whether a word is in the set. It can say maybe, and it never gives a wrong no.
Not started.Intermediate8 minUnion-Find
Are these two connected? Ask the root. Path compression flattens the trees so later questions take one hop.
Not started.Intermediate9 minLinked Lists
Blocks joined by arrows. Reversing a list moves no data at all: three markers walk along and turn each arrow around.
Not started.Beginner8 minHeaps
The smallest item always floats to the top. Insert swaps its way up, and removing the top lets the last item sink.
Not started.Beginner9 minRing Buffers
A queue that never moves its data: a circle of slots with a head and a tail chasing each other.
Not started.Beginner7 minDynamic Arrays
A million appends need only twenty resizes. Why doubling keeps the copying under two copies per item.
Not started.Beginner7 minRandom ID Collisions
Four billion possible IDs, and the odds of a clash pass 50% at about 77,000 users.
Not started.Intermediate7 minChoosing a Data Structure
Looked up by key? Kept in order? Added at one end or both? A few questions that pick the structure for you.
Not started.Beginner9 minStacks and Queues
Put the same three items into both. A stack gives back the last one first. A queue gives back the first one first.
Not started.Beginner7 minBinary Search Trees
Smaller to the left, larger to the right. Searching skips half the tree at every step, until the tree is built in sorted order and becomes a list.
Not started.Beginner10 minTries
A tree where each step down is one letter. Words that start the same share a path, which makes finding everything with a prefix nearly free.
Not started.Intermediate8 minGraphs
Things and the connections between them. Two ways to store the same graph, and what each one makes fast.
Not started.Beginner9 minPathfinding: BFS, Dijkstra, Bellman-Ford and A*
Four ways to find a route on the same map. One of them finds the fewest steps and the most expensive route.
Not started.Intermediate14 minString Search
Naive, KMP, Boyer-Moore and Rabin-Karp look for one word in the same sentence. One of them reads the pattern backwards and skips most of the text.
Not started.Intermediate12 minBinary Search
A million items in twenty checks, and the overflow bug that hid in the textbook version for years.
Not started.Beginner8 minReading Big-O from Code
Two nested loops are not always O(n²). Count the steps the inner loop really takes.
Not started.Beginner9 minRecursion and Memoization
Naive fib(30) makes 2,692,537 calls, most of them repeats. One cache turns the call tree into a line.
Not started.Beginner10 minQuicksort
Pick a pivot, split around it, repeat on each side. Watch each split put one item in its final place.
Not started.Intermediate10 minDepth-First Tree Traversal
Walking a tree to the bottom before going sideways. The same pattern repeats at every level, smaller each time.
Not started.Beginner8 minSorting Algorithms
Bubble, selection, insertion and merge sort put the same bars in order. Count the comparisons each one needs, and see why one of them pulls ahead as the list grows.
Not started.Beginner12 minDynamic Programming
Fewest coins to make an amount. The greedy answer is wrong, the brute-force answer is slow, and a small table gets it right.
Not started.Intermediate11 minGraph Traversal: BFS and DFS
Two ways to visit everything in a graph. One spreads out in rings using a queue. The other dives deep using a stack.
Not started.Beginner9 minTwo Pointers and Sliding Window
Two markers moving through an array turn a search over every pair into a single pass.
Not started.Intermediate9 minIndexes and B-Trees
A million rows found in three hops. How a B-tree index turns a full scan into a short walk from root to leaf.
Not started.Intermediate11 minThe N+1 Query Problem
A loop that loads one author per post runs 101 queries. Fetching the authors together runs 2.
Not started.Beginner7 minSQL Joins
Two small tables and six joins. Which rows survive inner, left, right, full, cross and self joins.
Not started.Beginner10 minTransaction Isolation Levels
Four levels, and the anomaly each one still allows: dirty reads, non-repeatable reads, phantoms.
Not started.Advanced12 minDeadlocks
Two transfers lock the same two accounts in opposite order and wait forever. Locking in one order fixes it.
Not started.Intermediate8 minConnection Pools
One slow query holds every connection and requests pile up outside, while the database itself sits idle.
Not started.Intermediate8 minNULL and Three-Valued Logic
NULL = NULL is neither true nor false in SQL. Why the answer is unknown, and what IS NULL is for.
Not started.Beginner6 minPagination: OFFSET or Keyset
OFFSET 1,000,000 reads a million rows before returning ten. Paging after the last id reads only the ten.
Not started.Intermediate7 minThe Write Path and the Write-Ahead Log
Five stops before a write is done: parse, lock, append to the log, flush to disk, acknowledge.
Not started.Advanced10 minSQL or NoSQL
A short set of questions about your data that leads to an answer. Most paths end at the boring choice.
Not started.Beginner8 minTransactions and ACID
Money leaves one account and the power fails before it reaches the other. A transaction makes the two steps happen together or not at all.
Not started.Beginner9 minNormalization
Store each fact once. A table that repeats a customer's address on every order will sooner or later hold two different addresses.
Not started.Beginner9 minTokenization
Models do not read words. A sentence is split into characters, then the most common pairs are merged into tokens.
Not started.Beginner8 minEmbeddings and Semantic Search
Search by meaning: text becomes an arrow, and the nearest arrow wins even when no words match.
Not started.Beginner9 minAttention
How a model knows what "it" means: every token looks at every other one, which is also why doubling the prompt quadruples the work.
Not started.Intermediate11 minHow an LLM Generates Text
One prompt in: tokens, vectors, layers, scores, one token out. Then the whole thing runs again for the next token.
Not started.Beginner10 minTemperature and Sampling
The same prompt gives a different answer. Temperature reshapes the odds before the next token is drawn.
Not started.Beginner8 minContext Windows and Memory
Models do not remember your chat. Each message is sent with the whole conversation so far, and the app is what remembers.
Not started.Beginner7 minRAG or Fine-Tuning
Does the model lack facts, or lack a skill? Facts change, so they are looked up. Behaviour is trained.
Not started.Intermediate9 minInside One Neuron
Multiply, add, squash. Change one weight and the same inputs give the opposite answer.
Not started.Beginner7 minGradient Descent
A model learns by rolling downhill. Three learning rates: one crawls, one bounces out of the valley, one settles.
Not started.Intermediate9 minEight AI Words, Explained
Token, context window, embedding, temperature, top-p, fine-tuning, RAG and hallucination, each shown happening.
Not started.Beginner8 minFloating Point
0.1 + 0.2 is not 0.3. 0.1 has no exact binary form, so the sum lands a hair past 0.3.
Not started.Beginner8 minInteger Overflow
Math.abs() returned a negative number. What happens when a value does not fit in 32 bits.
Not started.Beginner7 minUnicode and String Length
One emoji on screen, length five. Code points, joiners, and why length is not what you see.
Not started.Beginner8 minSorting Text That Looks Like Numbers
Sort "10", "9", "2" and "10" comes first. Strings are compared character by character.
Not started.Beginner5 minPython's Mutable Default Arguments
A list used as a default argument is built once and shared by every call.
Not started.Beginner6 minThe Real Cost of Python Operations
Eight everyday list, dict and set operations with what they cost. Swapping [ ] for { } turns 5,000 checks into 1.
Not started.Beginner9 minJavaScript Closures in Loops
Three timers in a loop all print 3. Every callback shares one variable, and the loop has finished before any of them runs.
Not started.Beginner7 minJavaScript Type Coercion
[] == ![] is true. Each conversion the comparison makes, one step at a time.
Not started.Beginner7 minString Concatenation in a Loop
Every += copies everything written so far. The hidden O(n²), and the builder that removes it.
Not started.Beginner6 minAsync/Await: In a Row or Together
Three awaits in a row wait three times. Start them together and the waiting overlaps.
Not started.Beginner7 minThe Call Stack
Recursion is a tall stack: each call adds a frame, then the tower pays back from the top. Remove the base case and it overflows.
Not started.Beginner8 minPseudo-Random Numbers
A generator with a seed produces a sequence. Run the same seed again and the same numbers come out, in the same order.
Not started.Beginner6 minGarbage Collection: Mark and Sweep
Who deletes your objects? The collector marks everything reachable from the roots and sweeps away the rest.
Not started.Intermediate9 minCPU Caches and Loop Order
The same two loops, swapped, run several times slower. Memory is read in lines, and one order uses them well.
Not started.Intermediate8 minLeader Election with Raft
Five servers and no boss. Timers run out, a candidate asks for votes, and a majority decides who leads.
Not started.Advanced12 minSplit Brain and Quorum
The network splits and both halves elect a leader. Requiring a majority is what prevents two histories.
Not started.Advanced10 minGossip Protocols
One server knows something. Each round, everyone who knows tells one other at random, and a million servers hear it within a few dozen rounds.
Not started.Intermediate8 minReplication and Replication Lag
Copies of the data on several servers. Writes go to one and are copied to the rest, and for a moment the copies disagree.
Not started.Intermediate10 minThe CAP Theorem
When the network splits, a system must either refuse some requests or risk giving different answers. It cannot avoid both.
Not started.Intermediate8 minTwo-Phase Commit
Two databases must both save a change, or neither. First everyone promises, then everyone commits, and there is one moment where it can get stuck.
Not started.Advanced9 minIdempotency and Safe Retries
The reply was lost, so the client sends the payment again. An idempotency key is what stops the customer being charged twice.
Not started.Intermediate8 minWhat Happens When You Press Enter
One request passes six stops: DNS, TCP, TLS, HTTP, the server, the first byte back. Most of the time goes before the request is sent.
Not started.Beginner11 minTCP Slow Start and Congestion Control
Why a download starts slow: the window doubles each round trip, hits a loss, halves, and climbs again.
Not started.Intermediate9 minHTTP Status Codes
The nine codes you will debug, sorted by whose fault it is: yours, theirs, or the network in between.
Not started.Beginner8 minDNS: Turning Names into Addresses
You type a name and the internet needs a number. Four servers are asked in turn, and the answer is remembered so the next lookup is instant.
Not started.Beginner9 minTCP or UDP
The network loses packets and delivers them out of order. TCP repairs that and makes you wait. UDP hands over whatever arrives.
Not started.Beginner9 minHTTP/1.1, HTTP/2 and HTTP/3
One page, many files. Three versions of HTTP fetch them in very different ways, and one lost packet shows why HTTP/3 exists.
Not started.Intermediate10 minIP Addresses, Subnets and NAT
Every device needs an address, and there are not enough to go round. How a home router shares one public address between everything behind it.
Not started.Beginner10 minHTTPS and the TLS Handshake
Hello, certificate, key exchange, and then everything after is unreadable to the network.
Not started.Intermediate10 minHow Passwords Should Be Stored
Add a salt, run a slow hash, store the result. The site never needs to know your password to check it.
Not started.Beginner8 minPassword Length and Brute Force
Add one character and cracking takes 62 times longer. From under a second to longer than a lifetime.
Not started.Beginner6 minMerkle Trees
Change one byte and the root changes. Proving one leaf belongs takes a handful of hashes, not the whole tree.
Not started.Intermediate9 minPublic-Key Cryptography
A lock anyone can close and only one person can open. How two keys solve the problem of sharing a secret with a stranger.
Not started.Intermediate10 minSQL Injection
A name typed into a login box becomes part of the database command. One quote mark turns data into code, and one habit prevents it.
Not started.Beginner8 minSessions, Cookies and Tokens
HTTP forgets you after every request. Two ways for a site to remember who you are: look you up each time, or hand you a signed pass.
Not started.Intermediate9 minCPU Scheduling
Five jobs and four schedulers. Shortest-job-first wins on average while one long job is still waiting at the end.
Not started.Intermediate10 minMemory Allocation
First-fit, best-fit, worst-fit and next-fit place the same blocks into one strip of memory. One leaves the most unusable slivers.
Not started.Intermediate9 minWhat Deleting a File Really Does
A file is a name pointing at blocks on disk. Delete removes the name, and the blocks can stay until something overwrites them.
Not started.Beginner6 minProcesses and Threads
A process has its own private memory. Threads inside it share that memory. That one difference decides what is safe, what is fast and what a crash takes down.
Not started.Beginner9 minVirtual Memory and Paging
Every program believes it has memory to itself. A page table maps that illusion onto real memory, and a page fault fills in what is missing.
Not started.Intermediate10 minSystem Calls: Asking the Kernel
Your program cannot touch the disk, the network or the screen. It asks the kernel to do it, through a narrow, guarded doorway.
Not started.Intermediate8 minRace Conditions
Two clicks, and one like goes missing. Every line is correct; the gap between reading and writing is the bug.
Not started.Beginner8 minMutex, Semaphore, Channel
Six primitives, sorted by how many threads may pass at once, and which one to reach for.
Not started.Intermediate10 minDo More Threads Make It Faster?
The same job on 1, 2, 4, 8 and 16 threads with a shared lock in the middle. Past the number of cores the gains stop, then reverse.
Not started.Intermediate8 minThe Event Loop
One thread, thousands of things in progress. How JavaScript decides what runs next, and why a promise beats a zero-delay timer.
Not started.Intermediate9 minThread Pools
A thread per task works until there are ten thousand tasks. A fixed team of workers and a queue does the same job with a fraction of the cost.
Not started.Intermediate8 minThe Birthday Paradox
23 people, and a 50% chance two share a birthday. It is not 23 chances. It is 253 pairs.
Not started.Beginner7 minThe Sieve of Eratosthenes
Each prime crosses out its multiples at its own tempo. The gaps where nothing lands are the primes.
Not started.Beginner7 minThe Collatz Conjecture
Halve if even, triple and add one if odd. 27 takes 111 steps to reach 1 and climbs past 9,000 on the way.
Not started.Beginner6 minBinary and Hexadecimal
Computers count with two digits. Flip the bits yourself, see what each one is worth, and find out why programmers write numbers in base 16.
Not started.Beginner8 minLogarithms
How many times can you halve a million before you reach one? Twenty. That question is all a logarithm is, and it is why log n algorithms are fast.
Not started.Beginner7 minModular Arithmetic
Arithmetic that wraps around, like a clock. It is behind hash tables, ring buffers, weekdays and most of cryptography.
Not started.Beginner7 minWhat git commit Writes
A file change becomes a blob, a tree, a commit and a moved branch name. A branch is a tiny text file holding one commit id.
Not started.Intermediate9 minUndo Anything in Git
Unstage, amend, revert, reset, restore, reflog: which command undoes which mistake.
Not started.Beginner8 minRegular Expressions
Eight building blocks, each matching live against a sample string. Together they read any pattern.
Not started.Beginner9 minGit Branches: Merge or Rebase
Two lines of work have to become one. Fast-forward, merge commit and rebase give the same files and three different histories.
Not started.Intermediate10 minContainers and Images
It works on my machine, so ship the machine. An image is a stack of layers, and a container is that image running in isolation.
Not started.Intermediate9 min
One CS idea a day, in under a minute
The shorts show the idea running. These pages are where you slow it down and work through it.