Every topic, in one place.
Most are still being written.

Start with the vocabulary: what code says, what it does, and how to follow a small example.

Follow declarations and assignments closely before treating a variable as a box in memory.

Look beneath familiar values without assuming every language stores them in the same way.

Use the values you understand to choose a path, repeat work, and reason about termination.

Follow a call from argument evaluation to return, then explore the state a function can carry.

Build larger values and learn what indexing, resizing, copying, and iteration really involve.

Name the thing a value refers to, then follow how each language lets you reach and change it.

Describe the values an operation accepts and see how each language expresses a reusable contract.

Use Haskell to question familiar assumptions about mutation, function arguments, and the timing of work.

Organize definitions and make the boundary between public and private names explicit.

Follow what happens when a normal result is unavailable, and keep failure behavior explicit.

Now ask who can use a value, how long it remains valid, and who is responsible for releasing resources.

Meet the hardware your program eventually runs on, without needing to build it.

Follow dependencies, build inputs, and initialization before examining the generated program.

Follow what a running program asks the operating system for: memory, files, input, output, and an exit.

Connect language behavior to storage while keeping conceptual diagrams distinct from measured layouts.

Distinguish when work happens, why data stays reachable, and how storage becomes eligible for reclamation.

Reason about more than one activity after calls, mutation, lifetime, and failure are familiar.

Bring the pieces together: how language rules become executable work, and what the runtime supplies.

Choose useful quantities, keep units straight, and understand how values are represented.

Use growth, probability, and statistics to interpret behavior and measurements.

Apply simple models to queues, reliability, retries, caches, capacity, and subnet plans.

Understand the math inside embeddings, training, and model output.

Follow data across local links, network boundaries, and service endpoints.

Understand how networks forward, filter, secure, and deliver application traffic.

Gather network evidence, narrow likely causes, and verify that a repair worked.

Build a practical vocabulary for reasoning about software risk and controls.

Start with assets and boundaries; use threats to decide which controls matter.

Identify the trust boundaries where web requests and data enter the system.

Keep untrusted data from becoming executable code or query structure.

Make every sensitive action depend on an explicit, verified permission.

Protect account access, credentials, and the sessions that represent a user.

Choose sound ways to protect sensitive data, secrets, and cryptographic keys.

Protect APIs and business workflows from unauthorized use and resource abuse.

Secure AI features by treating model inputs, outputs, retrieved content, and tool proposals as untrusted.

Turn security properties into reviewable, repeatable tests.

Handle uploaded files and complex content as hostile input.

Know what enters builds and reduce risk in dependencies and delivery pipelines.

Understand browser protections and preserve user privacy in client experiences.

Reduce the privileges and exposure of the systems that run the application.

Create useful signals, respond to security incidents, and learn from them.

Connect engineering practices to versioned verification standards and exam objectives.

Set up the small habits that make every later investigation faster.

Move from a symptom to a small explanation you can check.

Use examples and generated cases to challenge a claim about behavior.

Choose useful boundaries and improve the code while keeping its promises.

Measure a representative workload before deciding where the cost comes from.

Give a small program a clear interface and predictable configuration.

Turn bytes outside the program into usable values, then write results with explicit failure behavior.

Follow a request through parsing, application behavior, and a response.

Make the boundary between an in-memory result and stored state explicit.

Combine task lifetime, errors, resource ownership, and testing in one small application.