Leaflet
Pro
SYSTEMATIC INTERACTION
0 total views
0 this month

Compiler Theory and Engineering

For learners with a strong computer science foundation, this course studies the full path from source code to executable behavior: lexing, parsing, semantics, types, IR, optimization, code generation, runtime systems, linking, virtual machines, JIT, computability, and compiler engineering practice.

Start Learning

Table of Contents

Chapter 1: Compiler Pipeline and Build Systems

•
1.1 What a Compiler Does
•
1.2 Source Code to Executable
•
1.3 Interpreters, Compilers, AOT, JIT, and VMs
•
1.4 Course Project: A Small Language and Compiler

Chapter 2: Formal Languages and Finite Automata

•
2.1 Alphabet, Strings, Kleene Closure, and Languages
•
2.2 Regular Languages and Regular Expressions
•
2.3 DFA and DFA Minimization
•
2.4 NFA and Epsilon-NFA
•
2.5 Regex to NFA to DFA in Lexical Analysis

Chapter 3: Lexical Analysis

•
3.1 Tokens, Lexemes, Patterns, and Token Streams
•
3.2 Maximal Munch, Keywords, Identifiers, Literals, Comments
•
3.3 Handwritten Lexers and Table-Driven Lexers
•
3.4 Lexer Errors, Source Positions, and Diagnostics

Chapter 4: Context-Free Languages and Grammars

•
4.1 CFG, Terminals, Nonterminals, Productions, Start Symbols
•
4.2 Derivation, Parse Trees, and Ambiguity
•
4.3 Grammar Transformations, Left Recursion, Left Factoring
•
4.4 CNF, CFG, and PDA

Chapter 5: Top-Down Parsing

•
5.1 FIRST and FOLLOW Sets
•
5.2 LL(1) Grammar and Predictive Parsing Tables
•
5.3 Recursive Descent Parsing
•
5.4 Pratt Parsing for Expressions
•
5.5 Parser Error Recovery

Chapter 6: Bottom-Up Parsing

•
6.1 Shift-Reduce Parsing
•
6.2 LR Items and LR Parsing Intuition
•
6.3 SLR, LALR, and LR(1)
•
6.4 Shift/Reduce and Reduce/Reduce Conflicts
•
6.5 Parser Generators

Chapter 7: AST, Symbol Tables, and Name Resolution

•
7.1 Concrete Syntax Tree vs Abstract Syntax Tree
•
7.2 AST Node Design and Source Ranges
•
7.3 Scopes and Symbol Tables
•
7.4 Declarations, Bindings, Shadowing, and Imports
•
7.5 Frontend Architecture

Chapter 8: Semantic Analysis and Type Checking

•
8.1 Static vs Dynamic Type Checking
•
8.2 Primitive, Composite, Function, and User-Defined Types
•
8.3 Type Equivalence, Compatibility, Coercion, and Casts
•
8.4 Overloading and Type Inference Basics
•
8.5 High-Quality Semantic Diagnostics

Chapter 9: Runtime Environment

•
9.1 Program Memory Layout
•
9.2 Activation Records and Stack Frames
•
9.3 Calling Conventions and Parameter Passing
•
9.4 Objects, Vtables, Closures, and Captured Variables
•
9.5 Garbage Collection, Reference Counting, and Ownership

Chapter 10: Intermediate Representation

•
10.1 Why Compilers Use IR
•
10.2 Three-Address Code
•
10.3 Basic Blocks and Control-Flow Graphs
•
10.4 Dominators and Loops
•
10.5 SSA Form and Phi Nodes

Chapter 11: Intermediate Code Generation

•
11.1 Lowering AST to IR
•
11.2 Expression Translation
•
11.3 Control-Flow Translation for Branches and Loops
•
11.4 Function Calls and Returns in IR
•
11.5 Short-Circuit Boolean Code Generation

Chapter 12: Code Optimization

•
12.1 Constant Folding and Constant Propagation
•
12.2 Common Subexpression Elimination
•
12.3 Dead Code Elimination
•
12.4 Data-Flow Analysis Framework
•
12.5 Liveness Analysis and Loop Optimizations
•
12.6 Optimization Correctness and Tradeoffs

Chapter 13: Machine Code Generation

•
13.1 Instruction Selection
•
13.2 Register Allocation: Graph Coloring and Linear Scan
•
13.3 Stack Frame Layout
•
13.4 ABI and Calling Convention Details
•
13.5 Emitting Assembly

Chapter 14: Linking, Loading, and Object Files

•
14.1 Object Files and Sections
•
14.2 Symbols and Relocation
•
14.3 Static Linking vs Dynamic Linking
•
14.4 Shared Libraries and Symbol Visibility
•
14.5 Debug Information and Source Maps

Chapter 15: Virtual Machines, Bytecode, and JIT

•
15.1 Stack-Based and Register-Based Bytecode
•
15.2 Bytecode Interpreters
•
15.3 JIT Compilation Pipeline
•
15.4 Inline Caches and Runtime Profiling
•
15.5 LLVM, WebAssembly, and Portable Backends

Chapter 16: Computability and Compiler Limits

•
16.1 Turing Machines
•
16.2 Decidability and Undecidability
•
16.3 The Halting Problem
•
16.4 Why Perfect Static Analysis Is Impossible
•
16.5 Practical Compromises in Real Compilers

Chapter 17: Compiler Testing, Security, and Engineering

•
17.1 Unit, Golden, Snapshot, and Integration Tests
•
17.2 Differential Testing and Fuzzing
•
17.3 Undefined Behavior and Sanitizer-Style Tooling
•
17.4 Error Messages as Compiler UX
•
17.5 Maintaining a Compiler Codebase

SUITABLE AUDIENCE

Advanced learners who already know data structures, algorithms, computer organization, operating systems, and at least one systems programming language, and who want to deeply understand how programs are built and executed.

© 2026 Leaflet Interactive Mastery.