Track
Foundations
How computers and code really work, one small step at a time. Every step asks you to try something: flip bits, program a CPU, type shell commands, send packets, step through code, build objects and wire up patterns.
The modules build on each other, so go in order. You can jump to any module you like.
Start here: bits, the computer and your first programs
Under the hood: assembly, C, the OS and the network
Building well: data structures, OOP and patterns
How production systems work
Part 1
Start here: bits, the computer and your first programs
Begin with a single bit, meet the computer that runs everything, then write your first programs in Python.
Module 1
How computers store information
Bits, binary, bytes and hex, how text and colour become numbers, and the gates that compute with them.
- 1
Everything is on or off
5 min40 XPA bit is a switch. A few switches can count surprisingly high.
- 2
Counting in binary and back
7 min50 XPAdd one and carry, convert both ways, and see why programmers count from zero.
- 3
Bytes and sizes
6 min50 XPEight bits make a byte; bytes climb to KB, MB and GB. Learn to estimate any file.
- 4
Hexadecimal
6 min50 XPFour bits make one hex digit, so a byte is just two characters, from 00 to FF.
- 5
Text is numbers
7 min60 XPASCII, Unicode and UTF-8: how letters and emoji become bytes.
- 6
Colours and images are numbers
6 min50 XPThree bytes make a colour, a grid of colours makes a picture.
- 7
Logic gates
7 min60 XPAND, OR, NOT and XOR, and how two gates add two bits: the start of a CPU.
Module 2
Inside the computer
CPU, memory and addresses, the fetch-decode-execute cycle, buses, storage and how the parts talk.
- 1
The parts of a computer
6 min50 XPA processor, memory, storage, and devices for input and output. What each one is for.
- 2
Memory is a row of numbered boxes
7 min50 XPAddresses and values, reading and writing bytes, and why memory forgets when the power goes.
- 3
Fetch, decode, execute
8 min60 XPThe loop every CPU runs forever, a program counter, and a tiny program you step through.
- 4
The clock
7 min50 XPTicks, gigahertz, and why clock speed alone doesn't tell you how fast a computer is.
- 5
Buses: how the parts talk
7 min60 XPAddress, data and control lines; reads and writes over a shared bus; devices that live at addresses.
- 6
The memory hierarchy
7 min60 XPRegisters, caches, RAM, SSDs and the network: a ladder from tiny and instant to huge and slow.
- 7
Input, output and interrupts
7 min60 XPPolling vs interrupts, and the journey of a key press from your finger to your program.
- 8
From power-on to your program
7 min60 XPFirmware, the bootloader, the kernel, and how your app finally gets the CPU.
Module 3
How programs run
Values, variables, decisions, loops, functions, memory and the call stack.
- 1
Meet the editor
4 min20 XPWhere you type, what Run & check does, how to read the tests list, the output and a red error, and what to do when a loop never ends.
- 2
Programs are instructions
5 min40 XPA program is a list of steps the computer follows, one line at a time.
- 3
Values and types
6 min40 XPNumbers, text and True/False, and why "2" + "2" isn't 4.
- 4
Variables are labelled boxes
6 min40 XPStore values under names, change them, and swap two without losing one.
- 5
Expressions and operators
7 min50 XPPrecedence, the three kinds of division, comparisons and and/or/not.
- 6
Decisions
7 min50 XPif, elif and else: trace exactly which branch runs.
- 7
Loops
7 min50 XPwhile and for, running totals, off-by-one errors and loops that never end.
- 8
Functions
7 min50 XPParameters and arguments, return versus print, and local variables.
- 9
Lists and dictionaries
7 min50 XPKeep many values in one place: index a list, look up a dictionary.
- 10
References and the call stack
8 min60 XPTwo names for one list, copies, and how function calls stack up.
Part 2
Under the hood: assembly, C, the OS and the network
Go below Python: the machine's own language, a small and speedy language called C, the operating system, and how computers talk to each other.
Module 4
Assembly: talking to the CPU
Registers, instructions, jumps and loops on a toy CPU you program and step through.
- 1
Instructions are numbers
6 min50 XPWhat a CPU really reads, how assembly spells it for people, and what an assembler does.
- 2
Registers: the CPU's hands
6 min50 XPPut numbers into registers, copy them around, show them and stop.
- 3
Doing arithmetic
6 min50 XPADD and SUB, where results go, and how a whole expression becomes small steps.
- 4
Memory: LOAD and STORE
8 min60 XPAddresses versus values, moving data between memory and registers, and what a variable really is.
- 5
Jumps and loops
8 min60 XPLabels, jumping back, the zero flag, and loops that know when to stop.
- 6
Comparisons and branches
8 min60 XPCMP and the flags, conditional jumps, and how if/else and while look to the CPU.
- 7
The stack and function calls
8 min60 XPPUSH and POP, return addresses, CALL and RET, and what a stack overflow really is.
- 8
From Python to assembly
8 min60 XPA Python loop and its machine-level twin, where variables go, and compilers versus interpreters.
Module 5
C and memory
Addresses, pointers, arrays and strings as raw bytes, the stack and the heap, and how code is compiled.
- 1
Meet C
6 min50 XPA language close to the machine, with types whose sizes you can count in bytes.
- 2
Variables live at addresses
7 min55 XPEvery variable is bytes at a numbered address. The & operator reads that address.
- 3
Pointers
8 min60 XPA pointer is a variable that holds an address. Dereference it to reach what it points at.
- 4
Arrays are contiguous memory
8 min60 XPa[i] is just *(a + i). Pointer arithmetic scales by the element size, and nothing stops you going out of bounds.
- 5
Strings are char arrays
8 min60 XPA C string is characters ending in a '\0'. Lose the terminator and length checks run off the end.
- 6
The stack and the heap
9 min70 XPLocals live on the stack and vanish on return; malloc gives you heap memory you must free yourself.
- 7
When it goes wrong
9 min70 XPSegfaults, buffer overflows and undefined behaviour: why C's speed comes with sharp edges.
- 8
From source to program
8 min65 XPPreprocess, compile, assemble, link: how one .c file becomes a runnable executable.
Module 6
Operating systems and the Unix shell
What an OS does, processes, files and permissions, and a terminal to practise the shell in.
- 1
What an operating system does
6 min40 XPOne machine, many programs: the kernel shares it out, and programs ask it with system calls.
- 2
Processes: programs in motion
7 min50 XPA program is a file; a process is a running copy. The scheduler gives each one turns on the CPU.
- 3
The file system: a tree of folders
7 min50 XPDirectories form a tree from the root. Absolute and relative paths, . and .., and home (~).
- 4
Your first shell commands
8 min60 XPMeet the shell and the prompt, then look around and build: pwd, ls, cd, mkdir, touch.
- 5
Working with files
8 min60 XPRead, write, copy, move and delete: cat, echo, > and >>, cp, mv, rm.
- 6
Pipes and filters
8 min60 XPSmall tools that each do one job, joined with |: head, grep, wc, sort, uniq.
- 7
Permissions: who may do what
8 min60 XPOwners, groups and others; read, write and execute; chmod with letters and numbers.
- 8
Processes from the shell
8 min60 XPps, background jobs with &, kill and signals, environment variables and PATH.
Module 7
Networking
IP addresses, ports and packets, DNS, TCP and UDP, HTTP, and the layers that carry a request.
- 1
What a network is
6 min40 XPDevices, links, clients and servers, and the difference between your LAN and the internet.
- 2
Packets
7 min40 XPWhy big messages are chopped into numbered packets, and how the receiver puts them back together.
- 3
IP addresses
8 min50 XPFour bytes that say where a packet should go: public and private addresses, and which ones share a network.
- 4
Routing
8 min50 XPRouters forward packets hop by hop using their tables, and find another way when a link breaks.
- 5
Ports
6 min40 XPOne address, many programs: port numbers pick which program gets each packet.
- 6
TCP and UDP
9 min60 XPReliable and in order, or quick and careless: the handshake, ACKs, resends, and when to pick which.
- 7
DNS
8 min50 XPHow names like www.example.com become IP addresses: the resolver's walk, and the caches that make it fast.
- 8
HTTP
9 min60 XPThe language of the web: requests and responses, methods, status codes, headers, and cookies.
- 9
Layers
8 min50 XPEach protocol wraps the one above it: encapsulation, the TCP/IP model, and how OSI's seven layers map onto it.
- 10
What happens when you type a URL
8 min60 XPEverything at once: URL, DNS, TCP, TLS, HTTP, routing and the response, in order.
Part 3
Building well: data structures, OOP and patterns
Learn how to organise data, shape code into objects, and reuse ideas that good programmers have trusted for years.
Module 8
Data structures and algorithms
Big-O, arrays and linked lists, stacks and queues, hash maps, trees, searching and sorting.
- 1
What an algorithm is
6 min40 XPPrecise steps that always work, and why we count steps instead of seconds.
- 2
Big-O: how work grows
8 min50 XPGrowth rates, dropping constants, best and worst cases, and spotting nested loops.
- 3
Arrays and linked lists
7 min50 XPSide by side or linked by arrows: why reading and inserting cost different things.
- 4
Stacks and queues
7 min50 XPLast in, first out and first in, first out: undo, the call stack and print queues.
- 5
Hash maps
8 min60 XPHashing keys into buckets: why dict and set lookups take about one step.
- 6
Linear and binary search
7 min60 XPCheck every item, or halve the problem each time, as long as the data is sorted.
- 7
Sorting
9 min60 XPSelection, bubble and insertion sort, then merge sort's divide and conquer.
- 8
Trees and binary search trees
8 min60 XPRoots, children and leaves; searching and inserting by going left or right.
- 9
Graphs and breadth-first search
9 min70 XPNodes and edges, and finding shortest routes layer by layer.
- 10
Choosing a data structure
7 min60 XPMatch the job to the structure whose fast operations fit it.
Module 9
Object-oriented programming
Classes and objects, then the four pillars: encapsulation, abstraction, inheritance and polymorphism.
- 1
Why objects?
5 min40 XPLoose variables pile up fast. Objects keep data and behaviour together.
- 2
Classes and objects
7 min50 XPA class is the blueprint, objects are the things built from it. Meet __init__ and self.
- 3
Encapsulation: guard the data
7 min60 XPPillar 1. Keep data inside the object and let only its methods change it.
- 4
Abstraction: hide the how
7 min60 XPPillar 2. A simple interface on top, the complicated machinery hidden below.
- 5
Inheritance: is-a
7 min60 XPPillar 3. Build a class on top of another: base classes, overriding and super().
- 6
Polymorphism: one call, many behaviours
7 min60 XPPillar 4. The same message, sent to different objects, each answering its own way.
- 7
Composition over inheritance
7 min60 XPHas-a beats is-a more often than you'd think. Build objects from swappable parts.
- 8
The four pillars, side by side
8 min70 XPInterview practice: one-sentence definitions, spot-the-pillar and the classic wrong answers.
- 9
SOLID in plain words
6 min50 XPFive rules of thumb for good classes, and the bridge to design patterns.
Module 10
Design patterns
Proven shapes for code: Strategy, Observer, Factory, Decorator, Adapter, Command, State and more.
- 1
What a design pattern is
6 min40 XPNamed shapes of solution for problems that keep coming back.
- 2
Strategy: swap the algorithm
7 min50 XPPut each way of doing a job in its own object, and plug in the one you need.
- 3
Observer: tell everyone who cares
7 min50 XPLet objects subscribe to changes instead of hard-wiring who gets told.
- 4
Factory: ask for it by name
7 min50 XPPut object creation in one place so callers never pick classes themselves.
- 5
Singleton, and why to be careful
7 min50 XPOne shared instance: handy, but often a global in disguise.
- 6
Decorator: wrap to add
8 min60 XPAdd behaviour by wrapping an object in layers that share its interface.
- 7
Adapter: make it fit
7 min50 XPPut a translator between code that expects one interface and code that offers another.
- 8
Command: actions as objects
7 min50 XPTurn each action into an object you can store, queue, log and undo.
- 9
State: behaviour that changes with the stage
8 min60 XPGive each stage its own object instead of if/elif on a mode string.
- 10
Choosing a pattern
8 min60 XPStart from the problem, ask what varies, and know when to use none.
Part 4
How production systems work
Timeouts, retries, rate limits, caches, databases, deploys, observability, security and AI systems: what it takes for software to survive real traffic.
Module 11
Failure is normal
Timeouts, deadlines, retries, backoff, idempotency, circuit breakers, bulkheads and fallbacks: building clients that survive broken dependencies.
- 1
Failure is normal
7 min50 XPWhy a call across a network can fail in ways a function call never does, and why slow and dead look the same.
- 2
Timeouts
8 min60 XPWhy waiting forever is a bug, how a hung call can freeze unrelated pages, and how to choose a number.
- 3
Deadlines that travel
7 min55 XPWhy per-call timeouts add up the wrong way down a chain of services, and how one deadline fixes it.
- 4
Retries: what's worth repeating
7 min55 XPA retry is a bet that the failure was temporary. Learn which errors to retry, which never to, and which operations are safe to repeat.
- 5
Backoff and jitter
8 min60 XPHow long to wait between retries: growing delays, caps, and a pinch of randomness so clients don't move in lockstep.
- 6
Retry storms and budgets
8 min65 XPHow retries can finish off a service that was only wobbling, and how a retry budget caps the damage.
- 7
Idempotency
9 min70 XPMaking a repeat harmless: idempotency keys, stored results, and what “exactly once” really means.
- 8
Circuit breakers
9 min70 XPStop calling something that is clearly down, fail fast instead, and test the water now and then.
- 9
Bulkheads and fallbacks
9 min70 XPKeep one failing part from sinking the rest, and decide what each feature does when its dependency is gone.
- 10
A resilient client
10 min80 XPPut the layers in the right order, test them against flaky, slow, dead and hung dependencies, and write the core as code.
Module 12
Too much at once
Capacity and Little's law, rate limiters, queues, backpressure, load shedding, dead letters and idempotent consumers: coping with more work than you can do.
- 1
Load, capacity and Little's law
9 min65 XPHow much work is in flight is just arrival rate times time, and why a server at 95% busy is already in trouble.
- 2
Rate limiting and the fixed window
8 min60 XPWhy services cap how fast each caller may go, what a limit looks like on the wire, and the simplest algorithm with its sneaky flaw.
- 3
Sliding windows
9 min70 XPCounting the last N seconds from right now: the exact sliding log, and the cheap sliding counter that approximates it.
- 4
Token bucket and leaky bucket
9 min70 XPTwo ways of thinking about rate: saving up credit for bursts, or smoothing everything to a steady drip.
- 5
Limiting across many servers
9 min70 XPOne limiter is easy. Three servers behind a load balancer are not: where the count lives, races, and what to do when the counter store fails.
- 6
Queues and buffering
8 min65 XPWhat a queue really does (turn a burst into a delay), what it can't do, and the arithmetic of waiting.
- 7
Backpressure
9 min70 XPBounded queues, and the three honest answers when one is full: make the producer wait, tell it no, or drop something.
- 8
Load shedding and priority
9 min70 XPWhen demand outruns capacity for real, choose what to refuse so the work that matters still succeeds.
- 9
Dead-letter queues and poison messages
9 min70 XPHow one message that always fails can block a whole queue, and the safety net that sets it aside instead.
- 10
At-least-once delivery and idempotent consumers
10 min80 XPWhy messages arrive twice (or not at all), and how a consumer that remembers what it has done makes repeats harmless.
Module 13
Remember the answer
Latency, cache-aside and write-through, TTLs and eviction, invalidation races, stampedes, HTTP caching and CDNs, and when a cache is the wrong tool.
- 1
Why remember an answer
8 min50 XPLatency numbers, hits and misses, and the arithmetic that makes a cache worth having.
- 2
Four ways to wire a cache
10 min60 XPCache-aside, read-through, write-through and write-behind, and the consistency each one buys.
- 3
Time to live
8 min50 XPExpiry as a promise about staleness: choosing a TTL, absolute vs sliding, and lazy vs active removal.
- 4
Making room
9 min55 XPWhat to throw out when the cache is full: LRU, LFU and FIFO, and the scan that ruins them.
- 5
Why invalidation is hard
10 min60 XPTwo copies of one fact, and the race between a refill and an update that leaves the cache wrong.
- 6
The stampede
10 min60 XPWhen a hot entry expires, everyone rebuilds it at once. Locks, jitter and refreshing early.
- 7
What hit rate tells you
9 min55 XPWhat drives hit rate (size, key cardinality, popularity skew, cold starts) and what it hides.
- 8
Caching in the browser
11 min65 XPCache-Control, ETag and 304, Last-Modified, and stale-while-revalidate: caching by headers.
- 9
Shared caches and CDNs
10 min60 XPPrivate vs shared caches, how a CDN edge serves from nearby, and how pages leak when headers are wrong.
- 10
When not to cache
9 min55 XPA cache adds moving parts. What to try first, what to leave uncached, and the mistakes that leak data.
Module 14
Databases under load
Indexes, query plans, transactions, connection pools, safe migrations, replicas, regions, the outbox pattern and when to stay boring.
- 1
Databases in ten minutes
10 min50 XPTables, rows, columns and keys, plus the five SQL commands that read and change them, and what an index is for.
- 2
How an index finds a row
12 min70 XPPages, full scans, and the B-tree that finds one row in three page reads.
- 3
Choosing the right index
14 min80 XPColumn order, partial, expression and covering indexes; inverted and block-range ideas as an optional extra.
- 4
Reading a query plan
13 min80 XPScan versus seek, how joins run, and what it means when estimated and actual rows disagree.
- 5
Transactions and isolation
15 min90 XPAll-or-nothing writes, and the bugs that appear when two transactions overlap.
- 6
Connection pooling
12 min70 XPWhy connections are expensive, how to size a pool, and how serverless apps overwhelm a database.
- 7
Changing the schema without downtime
13 min80 XPExpand, backfill, switch, contract: how to rename a column while the site keeps serving traffic.
- 8
Replicas, lag and read-your-writes
12 min70 XPCopying data to followers, why they fall behind, and how to stop users seeing a stale past.
- 9
Many regions, one truth
13 min80 XPActive-passive versus active-active, what a network cut does, and how conflicts get merged.
- 10
Writing data and events together
12 min75 XPThe dual-write problem, the outbox table, and at-least-once delivery with idempotent consumers.
- 11
Queues, workflows and boring technology
14 min85 XPRunning multi-step jobs that survive crashes, and when a new data store is actually justified.
Module 15
Getting code to production
Build artifacts, CI/CD, containers, graceful shutdown, Kubernetes basics, health probes, zero-downtime deploys, feature flags, serverless and rollbacks.
- 1
From commit to artifact
7 min40 XPWhat a build produces, why you build once, and how the same bytes travel from staging to production.
- 2
Continuous integration and delivery
9 min50 XPTests on every change, fast feedback, flaky tests, and the difference between delivery and deployment.
- 3
Containers and images
9 min50 XPImages versus containers, layers and the build cache, small images, and configuration through the environment.
- 4
Signals and graceful shutdown
9 min50 XPSIGTERM versus SIGKILL, and how to stop a server without dropping the requests it is serving.
- 5
Orchestration: pods, deployments, services
9 min50 XPDeclare how many copies you want, and let a control loop keep it true. Kubernetes' core ideas, no cluster needed.
- 6
Health probes
9 min50 XPLiveness, readiness and startup probes, and the outages each misconfiguration causes.
- 7
Zero-downtime deploys
10 min55 XPRolling, blue-green and canary releases, error-rate gates, and why database changes must work with two versions at once.
- 8
Feature flags
9 min50 XPSeparating deploy from release: gradual rollouts with stable bucketing, kill switches, and keeping flag debt in check.
- 9
Serverless and cold starts
8 min45 XPFunctions that run on demand, what a cold start is made of, and when serverless is the right shape.
- 10
Rollbacks and release safety
8 min45 XPMitigate first, diagnose later: how to get back to safety fast, and the habits that make releases boring.
Module 16
Knowing what's happening
Logs, metrics and traces, structured logging, percentiles, RED and USE, SLOs and error budgets, alerting, dashboards, incident response and load testing.
- 1
Logs, metrics and traces
8 min45 XPThree kinds of evidence a running system can give you, what each is good at, and how they fit together.
- 2
Structured logging
9 min50 XPWhy log lines should be data, not prose: stable fields, levels, request ids, and what must never be logged.
- 3
Metrics: counters, gauges and histograms
8 min45 XPNumbers over time: the three instruments, why a counter must be read as a rate, and the cardinality trap.
- 4
Percentiles, not averages
8 min45 XPWhy the average hides the people who suffer, how p50, p95 and p99 work, and why the tail reaches almost everyone.
- 5
RED and USE
8 min45 XPTwo short checklists that tell you which handful of numbers to look at first: one for services, one for resources.
- 6
Distributed tracing
9 min50 XPFollowing one request across services: spans, the waterfall, self time, context propagation and sampling.
- 7
SLIs, SLOs and error budgets
10 min55 XPDeciding how reliable is reliable enough, measuring it, and turning the gap into a budget a team can spend.
- 8
Alerting and dashboards
10 min55 XPPage on symptoms, not causes; avoid alert fatigue; build dashboards that answer questions someone will really ask.
- 9
Incident response
9 min50 XPDetect, mitigate, communicate, learn: how to run an outage calmly and what a blameless review looks like.
- 10
Capacity and performance testing
9 min50 XPLoad, stress, soak and spike tests; the hockey-stick latency curve; Little's law; and how many servers you really need.
Module 17
Trust nothing by default
Threat models, sessions and tokens, OAuth and OpenID Connect, access control, least privilege, secrets, injection and XSS, tenant isolation and audit logs.
- 1
Thinking like an attacker
9 min60 XPThreat modelling on one page: what is worth taking, who wants it, which doors exist, and where trust has to be earned.
- 2
Who are you, and may you?
10 min70 XPAuthentication and authorization are different questions. Get the order, the status codes and the places to check right.
- 3
Sessions and tokens
11 min80 XPTwo ways to remember a logged-in user: a ticket the server looks up, or a signed note the server just checks.
- 4
Hardening the session
11 min80 XPCookie flags, expiry, rotation and revocation: the settings that decide whether a stolen session is a nuisance or a disaster.
- 5
OAuth and OpenID Connect
12 min90 XPHow one app gets limited, revocable access to another service without ever seeing your password. The code flow, PKCE and tokens.
- 6
Broken access control
10 min80 XPThe most common serious flaw: a logged-in user changes an id and reads someone else's record. See it, fix it, and test for it.
- 7
Least privilege
10 min80 XPGive every service, job and person only what they need, and an identity of their own, so one leak stays small.
- 8
Secrets and dependencies
12 min90 XPWhat you must never write down in the open, how to rotate it, and how to trust the code you did not write.
- 9
A map of web vulnerabilities
12 min90 XPInjection, XSS, CSRF and SSRF: one recurring mistake (data treated as instructions) in four costumes.
- 10
Tenants and audit trails
13 min100 XPMany customers in one system without leaking between them, and a record of who did what that cannot quietly be rewritten.
Module 18
Shipping AI features
Embeddings and vector search, RAG, evaluation, inference and cost, agents, and tool servers.
- 1
What is a language model?
7 min50 XPPrompt, model, token, context window, temperature and why the same question can get different answers. The words every later lesson uses.
- 2
Meaning as coordinates
9 min60 XPEmbeddings turn text into lists of numbers where nearby means similar. Cosine similarity and top-k, from scratch.
- 3
Searching vectors
10 min70 XPExact search is honest but slow. Approximate search trades a little recall for a lot of speed: layered graphs and clusters.
- 4
Choosing and sizing an index
10 min70 XPRecall, latency, memory and build time pull against each other. Do the sums, and know when a plain column is enough.
- 5
LLM inference and cost
10 min70 XPTokens, context windows, batching, streaming and cold starts: why an answer takes the time and money it does.
- 6
Filters and tenants
9 min70 XPReal searches come with conditions. Filtering before or after the vector search changes the results, and sometimes the security.
- 7
RAG from question to answer
10 min70 XPGive a language model the right passages to read. Embed, retrieve, assemble, answer, and how chunking decides what can be found.
- 8
Hybrid search and reranking
10 min70 XPKeywords catch exact strings, vectors catch paraphrases. Combine them with rank fusion, then let a reranker read the top few.
- 9
Evaluating RAG
9 min70 XPRetrieval recall, faithfulness and freshness are different failures. Build a regression set so a change cannot quietly break an answer.
- 10
Agents and tool calling
10 min80 XPThe loop that lets a model act: propose, check, run, read the result. Guardrails, approval gates and why tool output is untrusted.
- 11
Tool servers and MCP
11 min80 XPA standard way to plug internal systems into AI assistants: clients, servers, tools and resources, and how to expose them safely.