The Runtime Theory
hard · 20h · 21 steps

Software Systems: From Code to Production

A guided tour across all 17 TRT domains, from algorithms and machine execution to distributed services, security, and delivery.

Curriculum (21 steps)

1

Learn to connect an algorithm's correctness argument to the comparisons, branches, and memory accesses it performs.

Start→
2

Compare arrays, hash tables, trees, heaps, and graphs by the operations they make cheap and the memory accesses they require.

Start→
3

Follow compilation, linking, loading, address spaces, and the first instructions that turn a program into a running process.

Start→
4

Understand how processes, virtual memory, scheduling, files, and system calls let programs share a machine.

Start→
5

Follow an instruction through a pipelined processor and explain why cache locality often matters more than operation count.

Start→
6

Follow an HTTPS API request from a browser through name resolution, transport, TLS, HTTP, server code, and back.

Start→
7

Trace SQL through parsing, logical rewrites, cost-based planning, physical operators, indexes, and the buffer pool.

Start→
8

Follow a small program through lexing, parsing, semantic checks, intermediate forms, code generation, and runtime execution.

Start→
9

Separate JavaScript callbacks, event-loop scheduling, operating-system I/O, and worker-pool tasks in an asynchronous program.

Start→
10

Design timeouts, retries, idempotency keys, and server-side state so a lost response does not silently duplicate an operation.

Start→
11

Use cohesion, coupling, and dependency direction to choose software boundaries that make likely changes easier to contain.

Start→
12

Turn user requirements into a data flow, capacity model, and failure-aware architecture before drawing infrastructure boxes.

Start→
13

Understand why timeouts, retries, ordering, and consistency matter when remote machines can fail independently.

Start→
14

Follow the cloud control plane that compares declared configuration with live resources and works toward the requested state.

Start→
15

Threat-model a request by tracing sensitive data, user authority, trust boundaries, and the controls that limit abuse.

Start→
16

Use workload shape, latency distributions, profiling, and controlled experiments to find the cause of slow software.

Start→
17

Follow a change from Git objects and review through tests, build artifacts, deployment, rollback, and production feedback.

Start→
18

Walk one fresh HTTP/2 request over TCP from URL parsing through DNS, TLS, server handling, and the response.

Start→
19

Follow a selective SQL lookup through planning, a B-tree index, heap visibility checks, and the result rows.

Start→
20

Follow a client command from the leader's log through replication, quorum commitment, state-machine application, and reply.

Start→
21

Visualize review, automated checks, immutable artifacts, staged rollout, observability, and rollback decisions.

Start→