Compilers and Interpreters

You need to sign in or sign up before continuing.

reading · we frame, you read MIT or the canonical taught · we author, no canonical fits ↺ spirals back to earlier lessons

Course locked

Complete Software Engineering Practices first.

This course unlocks once you've finished its prerequisite. Open prerequisite →

Prerequisites

Introduction to Algorithms and Complexity not yet

Theory of Computation not yet

Complete prerequisites first to enroll.

reading · 30 min + ~330 min canonical

How Code Runs: Compilation, Interpretation, and Execution Models

You have typed ruby script.rb thousands of times. What actually happens between pressing enter and seeing output? Most engineers have a vague answer — "Ruby runs it" — and that va…

primary Crafting Interpreters by Bob Nystrom

preview →

reading · 35 min + ~330 min canonical L1

The Front End: Lexing, Parsing, and the AST

The scariest-sounding part of building a language — turning a flat string of characters like if (x > 0) return x 2; into a structured tree a computer can execute — turns out to b…

primary Crafting Interpreters by Bob Nystrom

after L1 locked

reading · 35 min + ~330 min canonical L1

Making Meaning: Semantic Analysis and Intermediate Representations

Parsing gave you a tree that's grammatically correct — but grammatical correctness isn't meaning. x + 1 parses fine even if x was never declared; "hello" - 3 parses fine even thou…

primary Crafting Interpreters by Bob Nystrom

after L2 locked

reading · 35 min + ~330 min canonical L1

The Back End: Code Generation, Garbage Collection, and JIT

The front end understood your program; the middle end optimized it; now the back end has to make it actually run on real hardware — and this is where the abstract meets the physic…

primary Crafting Interpreters by Bob Nystrom

after L3 locked

reading · 35 min + ~330 min canonical L1

Ruby Under the Hood: parse.y, YARV, YJIT — and Building Your Own

Everything in this course has been building to a single, quietly transformative capability: you can now open CRuby's actual source code — parse.y, compile.c, vm.c — and follow wha…

primary Crafting Interpreters by Bob Nystrom

after L4 locked

exercise reading · 15 min L1

Exercises: Easy (Warm-up)

- [ ] CI Ch4: Scanning — Build a lexer/scanner that tokenizes Lox source code (numbers, strings, identifiers, operators) - [ ] CI Ch5: Representing Code — Define AST node classes …

after L5 locked

exercise reading · 30 min L1

Exercises: Medium (Core)

- [ ] CI Ch7: Evaluating Expressions — Tree-walk interpreter evaluating arithmetic, comparisons, string concatenation - [ ] CI Ch8: Statements and State — Add print statements, va…

after L6 locked

exercise reading · 45 min L1

Exercises: Hard (Stretch)

- [ ] CI Ch12-13: Classes and Inheritance — Add classes, this, constructors, methods, single inheritance - [ ] CI Ch14-18: Bytecode VM — Build a bytecode chunk format, VM with sta…

after L7 locked

exercise reading · 60 min L1

Mini-Project

- [ ] Build a complete Lox interpreter in Ruby (tree-walk) — All features from Crafting Interpreters Part II: expressions, statements, control flow, functions, closures, classes, …

after L8 locked

L10

project reading · 480 min L1

Project: Lox Scanner and Parser in Ruby

Following Crafting Interpreters chapters 4-6, build the lexer (scanner) and parser for the Lox language in Ruby (not Java). Output: token stream and AST for Lox programs. Test wit…

after L9 locked

L11

project reading · 240 min L1

Project: CRuby Bytecode Explorer

Write a Ruby tool that takes Ruby source code, compiles it with RubyVM::InstructionSequence, and displays the YARV bytecode with annotations explaining each instruction. Compare b…

after L10 locked

L12

assessment reading · 63 min L1

Self-Assessment: Compilers and Interpreters

- [ ] What are the stages of a compiler? (lexing, parsing, semantic analysis, optimization, code generation) - [ ] What is a recursive descent parser? What class of grammars can i…

after L11 locked

12 lessons. Read in order; spiral back when you need to. By the end you'll have used the core ideas twice — once on the abstract, once on something you'll meet at work next week.