Free · No account needed
Written lessons, published in full
30 lessons from the 488-day pathway, open to read with no account. Each is complete on its own — not a summary, not a preview, and not the first paragraph of something you have to pay for.
Most take 15–25 minutes to read properly
Python20 lessons
How the language actually works, its concurrency model, and the backend built on it.
Python internals
What the Python GIL actually locks
The GIL explained properly: what it locks, why CPython has it, and the thing it does not prevent — which is where most race-condition bugs come from.
Day 65
Python decorators, from the pattern up
Decorators built from first principles: the closure underneath, why functools.wraps matters, and how decorators that take arguments work.
Day 44
Python generators and lazy evaluation
Generators, yield and yield from: how lazy evaluation keeps memory constant over a file you could never fit in RAM.
Day 47
Python closures and the late-binding trap
What a closure actually keeps alive, the cell mechanism behind it, and why a closure created in a loop captures the wrong value.
Day 43
Python scope and the LEGB rule
Local, enclosing, global, built-in — how Python resolves a name, when global and nonlocal are needed, and the loop-variable trap.
Day 30
How Python's garbage collector works
Reference counting plus the cyclic collector: generations, thresholds, and when a collection actually runs in a running program.
Day 27
Python memory, __slots__ and interning
Where the bytes go: per-object overhead, what __slots__ saves, string interning, and the small-integer cache that surprises people.
Day 28
Concurrency
The asyncio event loop, and why it is not threads
Coroutines, await and the event loop explained from the ground up — including the distinction from threading that most tutorials skip.
Day 70
The blocking call inside an async def
The most damaging bug in Python backends: one synchronous call in a coroutine stalls every other request on the loop. How to find and fix it.
Day 72
FastAPI: def vs async def in production
When FastAPI runs your endpoint on a threadpool, when it does not, and why a plain def is sometimes the correct answer.
Day 134
Backend
What REST actually means
What Fielding's dissertation really says about resources, verbs and statelessness — and how it differs from RPC and GraphQL.
Day 16
CORS and the same-origin policy
Why the browser blocks your request, what a preflight is, and how to fix a CORS error properly instead of setting the wildcard and moving on.
Day 20
JWT from scratch — signing, verifying, and the alg=none attack
Build and verify a JSON Web Token by hand, see the alg=none attack work, and understand why you cannot really log a JWT user out.
Day 116
Password hashing, timing attacks and account enumeration
How to store a password, why a fast hash is the wrong hash, and the login response that quietly tells an attacker which emails are registered.
Day 114
Databases
The N+1 query problem
The performance bug that hides behind clean-looking ORM code: how one loop becomes a thousand queries, how to spot it, and how to fix it.
Day 136
Database indexes: the B-tree from first principles
Build the B-tree up from why it exists, then the eight concrete reasons the database ignores the index you added.
Day 189
Composite, partial and covering indexes
How to derive composite column order rather than guess it, when partial and covering indexes pay off, and the index types that are not B-trees.
Day 190
Tooling
The Git object model — build a commit by hand
Blobs, trees and commits made by hand with plumbing commands. After this, every Git command you already use stops being magic.
Day 84
Git conflicts, reflog, reset vs revert, and bisect
Resolve conflicts without guessing, recover work you thought you destroyed with reflog, and find the commit that broke it with bisect.
Day 87
Java10 lessons
The JVM, the collections people are asked about, and the concurrency that trips them up.
Concurrency
What volatile does not do
synchronized, intrinsic locks and volatile — and the guarantee volatile gives you, which is narrower than almost everyone assumes.
Day 66
Java virtual threads: what Loom changes and what it doesn't
What virtual threads actually solve, what stays exactly the same, and the pinning cases that quietly undo the benefit.
Day 72
JVM
JVM architecture explained
The class loader, the runtime data areas, the execution engine and the JIT — what actually happens between javac and your code running.
Day 23
Java garbage collection: generations, G1 and ZGC
The generational hypothesis, what separates a minor from a major GC, and how G1 and ZGC differ in what they trade away.
Day 26
Java strings, immutability and the string pool
Why String is immutable, where the string pool actually lives, and why building a string with += inside a loop is a real performance bug.
Day 29
Collections
Java HashMap internals
Buckets, hash spreading, treeification at eight entries, and resize — the Java interview question people most often half-remember.
Day 48
The equals() and hashCode() contract
What the contract requires, and exactly what breaks when you override one without the other — demonstrated, not asserted.
Day 40
ConcurrentHashMap internals and CopyOnWriteArrayList
How ConcurrentHashMap gets thread safety without locking the whole map, and when CopyOnWriteArrayList is the right trade.
Day 53
Java generics: type parameters, bounds and erasure
Type parameters, bounded types and generic methods — plus what erasure means for the code you can and cannot write.
Day 54
Java streams: sources, laziness and terminal operations
Why nothing happens until the terminal operation, what separates intermediate from terminal ops, and where streams stop being the clearer choice.
Day 59