Structure to Interpretation

How to Design Programming Languages

47 modules

190 lessons

—

Part 1

Appendices

Appendix A: Diagram Templates by StepSign in
Appendix B: Mapping to Existing TechnologiesSign in
Appendix C: Readiness AssessmentsSign in
Appendix D: GlossarySign in

Part 2

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Structure to Interpretation"Sign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 to Step 7)Sign in
The Course LensesSign in
Diagram Legend and Notation TypesSign in

Part 3

What Is a Programming Language?

What Is a Programming Language?Sign in
Languages as InterfacesSign in
Models of ComputationSign in
Design vs ImplementationSign in

Part 4

Syntax, Semantics, and Pragmatics

Syntax, Semantics, and PragmaticsSign in
Syntax vs Semantics vs PragmaticsSign in
Static vs Dynamic SemanticsSign in
Informal vs Formal SpecsSign in

Part 5

Homoiconicity and Code as Data

Homoiconicity and Code as DataSign in
Representations of CodeSign in
HomoiconicitySign in
Implications for Macros and ReflectionSign in

Part 6

Compiled vs Interpreted and Everything In Between

Compiled vs Interpreted and Everything In BetweenSign in
Execution Model SpectrumSign in
Trade-offs and Where Complexity MigratesSign in
Compilation as a PipelineSign in

Part 7

Diagramming Languages and Implementations

Diagramming Languages and ImplementationsSign in
Grammar DiagramsSign in
AST and Evaluation FlowSign in
Pipelines and Runtime DiagramsSign in

Part 8

Lexing: Turning Text into Tokens

Lexing: Turning Text into TokensSign in
Characters to TokensSign in
Regular Expressions and Automata IntuitionSign in
Hand-Written vs Generated LexersSign in

Part 9

Grammars and Parsing

Grammars and ParsingSign in
Context-Free GrammarsSign in
Parsing StrategiesSign in
Errors and RecoverySign in

Part 10

Designing a Tiny Expression Language

Designing a Tiny Expression LanguageSign in
Minimal Language SurfaceSign in
Grammar and Precedence DesignSign in
Parser Construction and ValidationSign in

Part 11

Abstract Syntax Trees and IRs

Abstract Syntax Trees and IRsSign in
Parse Tree vs ASTSign in
AST Node Design and InvariantsSign in
IR as "Compiler Currency"Sign in

Part 12

Tree-Walk Interpreters

Tree-Walk InterpretersSign in
Environments: Name-to-Value Mappings and the Boundary Between Syntax and ExecutionSign in
Evaluation by Recursion: Interpreting Expressions Through AST Traversal and Rule ApplicationSign in
Diagnostics and Stack Traces: Making Runtime Errors Explainable in a Tree-Walk WorldSign in

Part 13

Extending the Tiny Language with Statements

Extending the Tiny Language with StatementsSign in
Statements and Sequencing: Blocks, Sequences, and the Shift from "Expression Only" to "Program"Sign in
Scope and Shadowing: Lifetime Rules as Semantics, Not SyntaxSign in
Expression vs Statement Languages: Designing the Semantic Boundary and Its ConsequencesSign in

Part 14

Variables, State, and the Store

Variables, State, and the StoreSign in
Environment vs Store: References vs Values and Why Mutation Needs a Second StructureSign in
Assignment Semantics: Modeling State Changes Precisely and Avoiding Hidden Aliasing SurprisesSign in
State in Interpreters and IRs: Representing Mutation So Later Compilation Stays CorrectSign in

Part 15

Control Flow Constructs

Control Flow ConstructsSign in
Conditionals and Loops: Structured Control and How Evaluation Order Becomes ObservableSign in
Desugaring: Translating "Nice Syntax" into Core Constructs You Can Reason AboutSign in
Non-Local Control: Exceptions, Early Returns, and the Semantics of UnwindingSign in

Part 16

Functions, Closures, and Scope

Functions, Closures, and ScopeSign in
First-Class Functions: Lambdas as Values and What It Means for a Language to Treat Behavior as DataSign in
Lexical vs Dynamic Scope: Closure Capture and How Name Resolution Becomes a Design ChoiceSign in
Calling Conventions at a High Level: Call Stacks, Environments, and the Observable Consequences for DebuggingSign in

Part 17

Typing Discipline and Design Choices

Typing Discipline and Design ChoicesSign in
Static vs Dynamic Typing: Where Errors Surface and What You Can GuaranteeSign in
Strong vs Weak and Mixed Regimes: What Coercion Buys and What It BreaksSign in
Designing a Type Philosophy: Aligning Types with Language Goals, Ergonomics, and ToolingSign in

Part 18

Type Systems and Type Checking

Type Systems and Type CheckingSign in
Core Type Building Blocks: Primitives, Records, Pairs, and Algebraic Data TypesSign in
Typing Judgments and Environments: Rules as the Executable Spec of Static SemanticsSign in
Algorithmic Type Checking: Implementable Checking and What Makes Error Messages UsableSign in

Part 19

Type Inference and Polymorphism

Type Inference and PolymorphismSign in
Unification Intuition: Constraints, Solving, and Why Inference Reshapes API DesignSign in
Parametric Polymorphism: Generics and Type Parameters as Abstraction MechanismsSign in
Ad-hoc Polymorphism: Overloading and Type-Class-Like Ideas and Where Complexity AccumulatesSign in

Part 20

Operational and Denotational Semantics

Operational and Denotational SemanticsSign in
Big-Step vs Small-Step: What Each Style Explains About Evaluation and ControlSign in
Denotational Semantics: Mapping Programs to Mathematical Objects to Reason About EquivalenceSign in
Semantics for Transformation: Using Meaning to Justify Optimizations and RefactoringsSign in

Part 21

Static Analysis Beyond Types

Static Analysis Beyond TypesSign in
Dataflow Analysis: Liveness, Reachability, and the Shape of "Safe Approximations"Sign in
CFGs and SSA: Why Control-Flow Graphs and SSA Form Dominate Compiler ReasoningSign in
Soundness vs Completeness: How Analyses Become Warnings, Errors, and Developer GuidanceSign in

Part 22

From AST to IR: Lowering and Desugaring

From AST to IR: Lowering and DesugaringSign in
Surface vs Core Language: Designing a Minimal Core You Can Compile ReliablySign in
Desugaring as Semantics Preservation: What Transformations Must Preserve to Stay CorrectSign in
High-Level IR Design: Representing Control and Data for Compilation and OptimizationSign in

Part 23

Designing a Bytecode and VM

Designing a Bytecode and VMSign in
Bytecode Instruction Sets: Stack-Based vs Register-Based Design Trade-offsSign in
VM Architecture: Dispatch, Frames, Stack/Heap Boundaries, and What Makes Debugging PossibleSign in
Debug Metadata: Line Tables and Source Mapping as First-Class VM RequirementsSign in

Part 24

Code Generation to Bytecode

Code Generation to BytecodeSign in
Translating AST/IR to Bytecode: Preserving Evaluation Order and Side EffectsSign in
Control Flow in Bytecode: Labels, Jumps, and Structuring Constructs Without Losing ClaritySign in
Functions and Closures: Representing Calls, Environments, and Upvalues in a VM ModelSign in

Part 25

Interpreting and Optimizing Bytecode

Interpreting and Optimizing BytecodeSign in
Interpreter Techniques: Switch Dispatch vs Threaded Code and Why It Matters for PerformanceSign in
Simple Compile-Time Optimizations: Peephole and Constant Folding as "Cheap Wins"Sign in
Instrumentation and Profiling: Gathering Evidence to Guide Later Optimizations and JIT ChoicesSign in

Part 26

Exceptions, Error Handling, and Debugging Support

Exceptions, Error Handling, and Debugging SupportSign in
Exception Models: Unwinding vs Resumption and What They Imply for Language SemanticsSign in
Debugging Interfaces: Breakpoints, Stepping, Inspection, and VM Support RequirementsSign in
Tracing and Tool APIs: Designing Stable Hooks for Debuggers and Observability ToolsSign in

Part 27

Lowering to Low-Level IR

Lowering to Low-Level IRSign in
SSA Form: What SSA Guarantees and Why Optimizers Love ItSign in
CFGs, Dominance, Phi Nodes: Encoding Merges and Control-Dependent Values PreciselySign in
Mapping High-Level Constructs: Translating Closures, Objects, and Control into Low-Level IRSign in

Part 28

Code Generation to Native Architectures

Code Generation to Native ArchitecturesSign in
Calling Conventions and ABIs: Stable Contracts Between Compiled Code and the PlatformSign in
Instruction Selection and Scheduling: Turning IR into Machine Code Without Leaving Performance on the TableSign in
Multi-ISA Backends: Designing Portability Boundaries When Targeting Multiple ArchitecturesSign in

Part 29

Optimization Passes

Optimization PassesSign in
Local vs Global Optimizations: What "Global" Requires in Terms of Analysis and InvariantsSign in
Canonical Passes: Inlining, Constant Propagation, DCE, Loop Transforms and Their Semantic ConstraintsSign in
Trade-offs: Compile Time Versus Runtime Performance and How to Justify ComplexitySign in

Part 30

Garbage Collection and Memory Management

Garbage Collection and Memory ManagementSign in
Explicit vs GC: Ownership Ideas and the Boundary Between Language Semantics and Runtime PolicySign in
Tracing, Reference Counting, Generational GC: Collectors as Different Failure and Latency ProfilesSign in
Interactions: FFI, Concurrency, and Real-Time Constraints as the Hard Edges of Memory ManagementSign in

Part 31

JIT Compilation and Hybrid Execution

JIT Compilation and Hybrid ExecutionSign in
JIT vs AOT vs Interpreter: Selecting an Execution Strategy for Your Product ConstraintsSign in
Hot Paths and PGO: Profiling-Guided Decisions and What "Hot" Really MeansSign in
Tiering and Deoptimization: Why Adaptive Systems Need a Safe Escape HatchSign in

Part 32

Code as Data in Practice

Code as Data in PracticeSign in
Internal Representation vs External Syntax: Where Metaprogramming Hooks AttachSign in
AST Manipulation and Reflection APIs: Capabilities, Invariants, and How Tools Stay CorrectSign in
Risks and Guardrails: Hygiene Pressures, Invariant Breakage, and Why Tooling Becomes HarderSign in

Part 33

Macros: From Textual to Syntactic

Macros: From Textual to SyntacticSign in
Text Macros vs AST Macros: Failure Modes and Why Syntactic Macros Dominate Serious UseSign in
Hygiene and Scope: Avoiding Accidental Capture and Keeping Expansions PredictableSign in
Expansion Phases: Compile-Time Evaluation, Staging Boundaries, and ReproducibilitySign in

Part 34

Designing Homoiconic Languages

Designing Homoiconic LanguagesSign in
Uniform Representations: S-Expressions and What They Buy You in Simplicity and Transformation PowerSign in
Quoting and Quasiquotation: Controlling Evaluation Boundaries and Building Code SafelySign in
DSLs via Embedding: Using Homoiconicity to Create Language Families and Internal DSLsSign in

Part 35

Staging, Partial Evaluation, and Generative Programming

Staging, Partial Evaluation, and Generative ProgrammingSign in
Multi-Stage Programming: Staged IRs and the Semantics of Run Now vs Run LaterSign in
Partial Evaluation: Specialization as an Optimization Technique with Semantic ObligationsSign in
Code Generation Tooling: Templates, Builders, and Maintaining DebuggabilitySign in

Part 36

Metaprogramming Tooling and Debugging

Metaprogramming Tooling and DebuggingSign in
Inspecting Expansions: Viewing Expanded Macros and Staged Code as a Primary Debugging WorkflowSign in
Source Maps and Expansion Traces: Preserving User Intent Through TransformationsSign in
Safety Boundaries for Metaprogramming: Policy, Conventions, and Limitations That Keep Ecosystems SaneSign in

Part 37

Modules, Packages, and Namespaces

Modules, Packages, and NamespacesSign in
Module Systems: Visibility Rules, Encapsulation, and Compilation UnitsSign in
Package Managers: Versioning, Dependency Resolution, Registries, and Supply-Chain ImplicationsSign in
Namespaces and Imports: Avoiding Global Chaos While Keeping Code ReadableSign in

Part 38

Build Systems, Toolchains, and REPLs

Build Systems, Toolchains, and REPLsSign in
Toolchains as Products: Compiler, Linker, Runner, and What "One Command Works" RequiresSign in
REPL Design: Interactive Evaluation, State, and Aligning REPL Semantics with Compiled SemanticsSign in
Incremental Compilation and Hot Reloading: Feedback Loops, Caching, and Correctness PitfallsSign in

Part 39

Interoperability and FFI

Interoperability and FFISign in
Calling Out to Other Worlds: C/System Libraries and Runtime Integration StrategiesSign in
Marshalling and Representation: Data Layout Across Boundaries and What Can Go WrongSign in
Safety, Performance, Versioning: Maintaining a Stable Boundary Under EvolutionSign in

Part 40

Multi-Target and Multi-Backend Languages

Multi-Target and Multi-Backend LanguagesSign in
VM Targets vs Native: Portability Boundaries and Performance CeilingsSign in
Shared Core IR: Designing a Common Middle Layer That Supports Multiple BackendsSign in
Where Portability Lives: Choosing Which Features Are Portable and Which Are Platform-ShapedSign in

Part 41

Designing for Developer Experience

Designing for Developer ExperienceSign in
Diagnostics as Design: Error Messages, Hints, and How They Encode Language PhilosophySign in
Formatting, Linting, Refactoring: Making Consistency and Correctness CheapSign in
Language Servers and IDEs: APIs, Incremental Analysis, and the Ergonomics of Tooling IntegrationSign in

Part 42

Evolving a Language Over Time

Evolving a Language Over TimeSign in
Versioning and Deprecation: Migration Strategy as Part of the Language ContractSign in
Backward Compatibility vs Progress: What You Preserve and What You Break, and WhySign in
Governance Processes: RFCs, Community Norms, and Decision-Making Structures That ScaleSign in

Part 43

Language Design Patterns

Language Design PatternsSign in
Expression vs Statement Orientation: How Surface Form Shapes Semantics and ToolingSign in
Effects and Explicitness: Implicit vs Explicit Control, Side Effects, and ComposabilitySign in
Surface Syntax Patterns: Keywords vs Operators vs Punctuation and the Trade-offs in Readability and ParsingSign in

Part 44

Semantic and Type System Patterns

Semantic and Type System PatternsSign in
Safe-by-Default Design: Invariants You Enforce and What You Leave to ConventionSign in
Effect Systems and Ownership Ideas: High-Level Patterns for Taming Side Effects and ResourcesSign in
Refinement and Advanced Types: Power Versus Simplicity Versus Learnability as a Product ConstraintSign in

Part 45

Runtime and Execution Patterns

Runtime and Execution PatternsSign in
VM Patterns: Stack vs Register, Object Models, and Dispatch StrategiesSign in
Memory Layout Patterns: Tagged Values, Headers, Vtables, and Representation LeakSign in
Concurrency Models: Threads, Async/Await, Actors, Green Threads, and Runtime AssumptionsSign in

Part 46

Implementing DSLs and Embedded Languages

Implementing DSLs and Embedded LanguagesSign in
Internal vs External DSLs: Design Goals, Tooling Implications, and Maintenance CostsSign in
Embedding vs Standalone: When a Host Language Is Enough and When It Becomes a ConstraintSign in
New Language vs Library: Decision Criteria and Failure Modes of Each PathSign in

Part 47

Checklists for New Language Designs

Checklists for New Language DesignsSign in
Syntax Checklist: Grammar, Precedence, Readability, and Error Recovery as First-Order Design ConcernsSign in
Semantics and Types Checklist: Evaluation Rules, Type Philosophy, and Static Reasoning GuaranteesSign in
Runtime, Tooling, Ecosystem Checklist: Execution Strategy, Debugging Story, Packaging, and Long-Term EvolutionSign in

Course overview