LEARNING PATH

Build your CS foundations

Understand what happens after you write the code.

Follow a program from execution to memory, complexity, and the CPU. Use computer science foundations to answer questions that come up while building software.

For programmers who want to connect their experience to computer science foundations

Why can two implementations of the same task run at different speeds?

Scope and finish line

Every main reading in this course is published and available now.

Steps
22
Main readings
22
Check questions
60

What you will learn to explain

  • Explain how array access, data structures and algorithm choices affect running time.
  • Explain execution and the role of the OS, then reason about programs using types, compilers and computation theory.

Final main reading: Computability, Reductions, P, and NP

Complete each step’s main reading and its check, where one is provided. Extra reading and experiments are optional.

See the final step ↓

0 of 22 steps complete

Start learning →

Apply the course in code

After an experiment, apply its rule in a short function and test the result.

Your learning steps

  1. STEP 01Not started

    From Source Code to a Running Program

    Goal: Explain how source code passes through a compiler, interpreter, and runtime before execution.

    Main reading: From Source Code to a Running Program →

  2. STEP 02Not started

    Values, Types, Control Flow, Functions, and Modules

    Goal: Trace values, types, expressions, branches, and loops to explain changes in program state.

    Main reading: Values, Types, Control Flow, Functions, and Modules →

    Explore the mechanisms
  3. STEP 03Not started

    Propositional Logic, Predicate Logic, and Proof

    Goal: Formalize natural-language claims using propositions, logical connectives, and quantifiers, and explain why inference rules are valid.

    Main reading: Propositional Logic, Predicate Logic, and Proof →

  4. STEP 04Not started

    Memory, Pointers, References, and Lifetimes

    Goal: Diagram runtime memory using stacks, heaps, addresses, pointers, and references.

    Main reading: Memory, Pointers, References, and Lifetimes →

    Explore the mechanisms
  5. STEP 05Not started

    Complexity and Measured Performance

    Goal: Derive time and space complexity using O, Omega, and Theta notation and explain how costs grow with input size.

    Main reading: Complexity and Measured Performance →

    Explore the mechanisms
  6. STEP 06Not started

    Binary Representation, Logic Circuits, and Instruction Sets

    Goal: Represent integers, characters, and instructions as bit sequences and explain how basic logic operations support computation.

    Main reading: Binary Representation, Logic Circuits, and Instruction Sets →

    Explore the mechanisms
  7. STEP 07Not started

    CPUs, Instruction Cycles, and Pipelines

    Goal: Trace instruction fetch, decode, execution, memory access, and write-back.

    Main reading: CPUs, Instruction Cycles, and Pipelines →

    Explore the mechanisms
  8. STEP 08Not started

    Caches and the Memory Hierarchy

    Goal: Explain the memory hierarchy of registers, caches, main memory, and storage, and why locality matters.

    Main reading: Caches and the Memory Hierarchy →

    Explore the mechanisms
  9. STEP 09Not started

    Arrays, Lists, Stacks, Queues, Hash Tables, and Trees

    Goal: Explain the representations and operation costs of major data structures and select one for a required workload.

    Main reading: Choose a data structure from the operations you need →

    Explore the mechanisms
  10. STEP 10Not started

    Divide and Conquer, Greedy Algorithms, Dynamic Programming, and Backtracking

    Goal: Identify when divide and conquer, greedy algorithms, dynamic programming, and backtracking apply to a problem's substructure.

    Main reading: Choose among greedy methods, divide-and-conquer, and dynamic programming →

    Explore the mechanisms
  11. STEP 11Not started

    Graph Representations, BFS, DFS, and Shortest Paths

    Goal: Model real problems as vertices, edges, and weights, and explain the differences between adjacency lists and matrices.

    Main reading: Understand BFS and DFS through traversal order and shortest paths →

    Explore the mechanisms
  12. STEP 12Not started

    Debugging, Testing, and Reproducibility

    Goal: Reproduce a defect and narrow down its cause using logs, stack traces, and a debugger.

    Main reading: Debugging and testing: turn a hypothesis into a small check →

    Explore the mechanisms
  13. STEP 13Not started

    Sets, Relations, Functions, and Counting

    Goal: Represent discrete objects and their associations using sets, relations, and functions, and explain their properties.

    Main reading: Sets, relations, and counting: handle overlap and correspondence →

    Explore the mechanisms
  14. STEP 14Not started

    Induction, Recursion, and Invariants

    Goal: Construct base and inductive steps to prove properties of natural numbers and recursively defined structures.

    Main reading: Induction and loop invariants: explain why repetition is correct →

    Explore the mechanisms
  15. STEP 15Not started

    The Kernel, Privilege Modes, and System Calls

    Goal: Explain the protection boundary between user and kernel modes and how a system call crosses it.

    Main reading: The Kernel, Privilege Modes, and System Calls →

    Explore the mechanisms
  16. STEP 16Not started

    Virtual Memory, Page Tables, and the TLB

    Goal: Split a virtual address into a page number and offset, and trace translation through page tables and the translation lookaside buffer.

    Main reading: Virtual Memory, Page Tables, and the TLB →

    Explore the mechanisms
  17. STEP 17Not started

    Interleaving, Race Conditions, and Atomicity

    Goal: Enumerate thread interleavings to detect race conditions and lost updates to shared state.

    Main reading: Interleaving, Race Conditions, and Atomicity →

    Explore the mechanisms
  18. STEP 18Not started

    Mutexes, Semaphores, Condition Variables, and Deadlock

    Goal: Trace state changes in mutexes, semaphores, condition variables, and monitors, and explain their different uses.

    Main reading: Locks and condition variables: protect state and wait for change →

    Explore the mechanisms
  19. STEP 19Not started

    Syntax, Semantics, and Type Systems

    Goal: Distinguish syntax, static semantics, and dynamic semantics, and explain the rules used to interpret a program.

    Main reading: Syntax, semantics, and types: separate three kinds of correctness →

    Explore the mechanisms
  20. STEP 20Not started

    Compilers, Interpreters, Runtimes, and Garbage Collection

    Goal: Trace lexical analysis, parsing, abstract syntax trees, intermediate representations, optimization, and code generation.

    Main reading: Compilers, Interpreters, Runtimes, and Garbage Collection →

    Explore the mechanisms
  21. STEP 21Not started

    Formal Languages, Regular Expressions, and Finite Automata

    Goal: Formalize alphabets, strings, and languages, and explain the connection between regular expressions and finite automata.

    Main reading: Formal Languages, Regular Expressions, and Finite Automata →

  22. STEP 22Not started

    Computability, Reductions, P, and NP

    Goal: Use Turing machines and decision problems to distinguish computability, decidability, and undecidability.

    Main reading: Computability, Reductions, P, and NP →

Progress is kept in this browser for the current language. You can read the steps in any order.