base-cs
Base CS from zero
Start with no CS theory. Finish understanding how a computer runs your code and what every programming construct really means.
Start track → 01
What a computer is
A computer stores everything as bits and is built from two-state switches. 01 Bits and binary 18 min 02 Counting in binary 20 min 03 Encoding the world 22 min 04 Boolean logic 20 min 05 Logic gates 20 min 06 What a computer is: multiple-choice review 13 min 07 What a computer is: free-recall review 13 min 08 What a computer is: read patterns and circuits 14 min 09 What a computer is: build a bits-to-arithmetic toolkit 210 min
02
Memory
Memory is a long row of numbered cells; an address is the number, a value is what sits there. 03
The processor
The CPU repeats one loop forever: fetch an instruction, decode it, execute it. 01 The instruction 18 min 02 Fetch–Decode–Execute 20 min 03 Registers 20 min 04 Machine code 20 min 05 A toy CPU 25 min 06 The processor: multiple-choice review 13 min 07 The processor: free-recall review 13 min 08 The processor: trace and decode 14 min 09 The processor: build a CPU simulator 220 min
04
From machine code to a language
High-level code is translated — compiled or interpreted — into the instructions the CPU runs. 01 The assembler idea 18 min 02 Why high-level languages 18 min 03 Compilation vs interpretation 22 min 04 The runtime 20 min 05 From source to running program 25 min 06 From machine code to a language: multiple-choice review 13 min 07 From machine code to a language: free-recall review 13 min 08 From machine code to a language: code and mapping reading 14 min 09 From machine code to a language: trace a program down the ladder 210 min
05
Values and types
Bits mean nothing alone; a type is the rule that says how to read them. 01 What a value is 20 min 02 Types interpret bits 20 min 03 Primitive types 22 min 04 Why types exist 20 min 05 Values and types: multiple-choice review 13 min 06 Values and types: free-recall review 13 min 07 Values and types: code reading 14 min 08 Values and types: build a value inspector 210 min
06
Variables and state
A variable is a named memory cell; assignment changes what it holds. 01 A variable is a named cell 20 min 02 Assignment 22 min 03 Mutation and state 20 min 04 References vs values 25 min 05 Variables and state: multiple-choice review 13 min 06 Variables and state: free-recall review 13 min 07 Variables and state: code reading 14 min 08 Variables and state: build a state container 200 min
07
Control flow
Conditionals and loops are the CPU choosing which instruction to run next. 08
Functions and the call stack
Every call pushes a frame onto the stack; returning pops it back off. 01 What a function is 18 min 02 The call stack 22 min 03 Parameters and return values 20 min 04 Scope 18 min 05 Recursion preview 22 min 06 Functions and the call stack: multiple-choice review 13 min 07 Functions and the call stack: free-recall review 13 min 08 Functions and the call stack: code and trace reading 14 min 09 Functions and the call stack: build a stack tracer 210 min
09
Data in memory
Arrays are contiguous cells; objects are labelled cells — both are layouts in memory. 01 Arrays as contiguous cells 20 min 02 Indexing and offsets 20 min 03 Objects as key-value 20 min 04 Collections in memory 22 min 05 Data in memory: multiple-choice review 13 min 06 Data in memory: free-recall review 13 min 07 Data in memory: code and layout reading 14 min 08 Data in memory: build a memory-layout model 210 min
10
Abstraction
Bundling data with the operations on it lets you stop thinking about the machine. 01 What abstraction is 18 min 02 Bundling data and behaviour 22 min 03 Modules 20 min 04 Why abstraction exists 20 min 05 Abstraction: multiple-choice review 13 min 06 Abstraction: free-recall review 13 min 07 Abstraction: code reading 14 min 08 Abstraction: build a leak-proof-then-leaky module 200 min
11
When a program fails
An error is the machine reporting it cannot continue; the stack trace says where. 01 Errors vs exceptions 20 min 02 The stack trace 22 min 03 Undefined behaviour 22 min 04 Debugging as reasoning 22 min 05 When a program fails: multiple-choice review 13 min 06 When a program fails: free-recall review 14 min 07 When a program fails: code and trace reading 14 min 08 When a program fails: hunt two bugs by reasoning 200 min
12
Time and concurrency
Async exists because the CPU must not sit idle while a slow device answers. 01 Why async exists 18 min 02 Blocking vs non-blocking 20 min 03 The event loop 24 min 04 Concurrency vs parallelism 22 min 05 Time and concurrency: multiple-choice review 13 min 06 Time and concurrency: free-recall review 14 min 07 Time and concurrency: code reading 14 min 08 Time and concurrency: reproduce and fix a race 210 min
Build with this track
Guided projects that exercise what you learn here.
Pathfinding Route Engine
Four search algorithms, one shared problem: get from A to B across a weighted grid. You'll build BFS, DFS, Dijkstra, and A* on a single graph model, then run them side by side and watch them disagree — DFS lunges into a dead end, BFS floods evenly, Dijkstra crawls outward by cost, A* leans toward the goal. This is where the algorithms unit stops being trivia and becomes a set of tools you choose between, with reasons.
Tiny Stack VM
Build the machine that runs the machine. You define a small bytecode instruction set, write an assembler that turns readable mnemonics into bytes, and write the interpreter loop that fetches, decodes, and executes them one at a time. By the end you will have demystified the whole stack between a line of source and a running program — because you wrote every layer of it yourself.
Algorithms from zero
Know one programming language, know no algorithms. Finish able to solve hard problems with confidence.