49 units · 12 modules · free
Everything You Need to Know About Computer Science
From the bytes under your code to a system design you can defend out loud — in degree order, and every unit ends with the interview questions it unlocks.
Most working developers never took these courses, and most job interviews assume they did. The order below is the one a degree uses — the machine first, the abstractions after — because the later units only make sense once the earlier ones do. Each unit ships as a video walkthrough with the smallest runnable code that proves the point, plus a written post here. You can also ask the blog about anything already published.
M01How your code actually runs
Below the language you write in there is a machine that only moves bytes. Four units to stop treating it as magic.
01Binary, bytes and why integers overflow
Everything is a number, and every number has an edge.
02Memory: stack vs heap, and what an allocation costs
Two places to put a value, and only one of them is free.
03The CPU: instructions, cache lines, and why locality beats cleverness
A clever algorithm that misses cache loses to a dumb one that does not.
04Compiled vs interpreted — what Python really does
Python is compiled. Just not to what you think.
M02Operating systems
The layer that decides which of your code runs, when, and what it is allowed to touch.
05Processes vs threads
Same program, two very different kinds of "at the same time".
06Scheduling and context switches
Concurrency you did not ask for, costing time you did not budget.
07Virtual memory and paging
Every process believes it owns the whole machine. It is a lie the kernel maintains.
08Files, descriptors, and blocking vs non-blocking I/O
Why one slow disk read can freeze a whole server.
M03Complexity and data structures
The part of a CS degree interviews test most directly — and the part that is most often learned as trivia instead of as tools.
09Big-O without the maths
Not "how fast" — how the cost grows when the input does.
10Arrays vs linked lists (and why arrays usually win)
The textbook says O(1) insert. The machine disagrees.
11Hash tables — the one to truly understand
Average O(1), until it is not. Collisions, load factor, and what a dict really is.
12Trees, and why they need balancing
A binary search tree that grows the wrong way is just a slow list.
13Graphs, BFS and DFS
Most "hard" interview problems are a graph you did not recognise.
M04Algorithms that actually show up
Not the whole textbook — the handful of patterns that appear again and again in real interviews and real code.
14Sorting: what to know vs what not to memorise
Nobody will ask you to implement quicksort. They will ask why it is the default.
15Recursion → dynamic programming
DP is recursion that stopped repeating itself.
16The interview patterns: two pointers, sliding window, binary search
Three shapes that cover a surprising share of the question bank.
M05Networking
What happens between your browser and someone else’s server, in order.
17What happens when you type a URL — DNS → TCP → TLS → HTTP
The most-asked interview question there is, answered end to end.
18HTTP/1.1 vs 2 vs 3, status codes, and how to design REST paths
One protocol family, three answers to "why is it slow", a status line that says whose fault it is, and one naming convention worth arguing about.
19Sockets, latency, timeouts and retries
Every network call fails eventually. Design for the failure, not the happy path.
M06Databases
The subject that separates people who use a database from people who can reason about one.
20Tables, indexes, and how a query is planned
The planner decides whether your query is instant or a full scan.
21B-tree vs LSM — the bet every database makes
Update in place, or append and clean up later. There is no third option.
22Transactions and isolation levels
ACID is four promises, and isolation is a dial — most defaults are not serializable.
23The write-ahead log and crash recovery
Durability means it was written down before it was done.
24Normalisation, denormalisation, and the N+1 trap
A clean schema and a fast page are not automatically the same thing.
M07Concurrency
Two things at once, and all the ways that goes wrong.
25Race conditions and locks
The bug that only appears under load, and never in your tests.
26Async and the event loop
One thread, thousands of connections — as long as nothing blocks it.
27Idempotency
The property that makes retries safe — and without it, retries are a bug.
M08Distributed systems
What changes once one machine is no longer enough — which is where system-design interviews live.
28Replication
One copy is a single point of failure; more copies means lag.
29Sharding and partitioning
Splitting is easy. Hot keys and rebalancing are the job.
30Caching
A correctness problem wearing a performance costume.
31Consensus and CAP
Agreeing on one value across machines — the hardest thing in the field.
32Queues, backpressure and dead letters
A queue does not remove load. It moves it in time — until it does not.
M09Delivery and operations
Building it is half the job. This is the half that decides whether it stays up — and the half most self-taught paths skip entirely.
33Load balancing and autoscaling
More traffic than one box can take, and the new box always arrives late.
34Monitoring, observability and tracing
Every dashboard is green during the outage. That is the problem.
35Containers, deploys and rollbacks
Shipping is a system too — and the rollback is the part you test least.
M10Software design
Everything above runs your code. This is the course about the code itself — how objects earn their keep, where a rule lives, what a boundary is for, and why one change ends up touching four files.
36Objects: encapsulation, inheritance, and why composition usually wins
Four pillars in every tutorial, and one of them quietly causes most of the damage.
37Coupling and cohesion
The two words underneath every argument about "clean" code.
38SOLID, without the acronym worship
Five letters, two that carry the weight, and three you can usually derive.
39Design patterns: the handful that actually show up
Twenty-three in the book. You will meet about six, and two of them are already in your framework.
40Layers: route handler, service, repository
The rule for publishing an article ends up in four places, and one never gets the fix.
41Boundaries, seams and testability
If you need a database running to test a business rule, the rule is in the wrong place.
M11Putting it together
The two units that turn everything above into an answer you can give out loud.
42Back-of-the-envelope estimation
If you cannot size it, you cannot design it.
43A full system design, end to end
One question, answered the way an interviewer wants to hear it.
M12Security
The subject every backend eventually gets wrong in public. Who you are, what you may do, what the wire can see — and the handful of attacks that account for most breaches.
44Authentication vs authorization
Proving who you are and deciding what you may do are two different systems, and 401 is not 403.
45Sessions, cookies and tokens — how an app remembers you
Every "logged in" is one of two bets: the server remembers, or the token proves it.
46Storing passwords — hashing that is slow on purpose
Both bcrypt and SHA-256 are one-way. Only one of them survives the leak.
47TLS and certificates — what the padlock actually proves
It proves the server is who it claims. It says nothing about the client, and nothing about the code.
48The attacks worth knowing: injection, XSS, CSRF and CORS
Four names people mix up constantly, each with a different attacker and a different fix.
49Defence in depth: firewalls, WAFs, allowlists and zero trust
A wall only works once. What you do after someone is inside is the actual design.