12 posts · 60 min total · Intermediate

Readers who want both the theory behind language processing and the bridge to real compiler construction.

Read Before This

All Posts

  1. 1

    Automata and Compilers 01 - Finite Automata

    What finite automata are and why understanding compilers starts here

  2. 2

    Automata and Compilers 02 - Regular Expressions and Regular Languages

    How regular expressions are equivalent to finite automata, and where the boundary of regular languages lies

  3. 3

    Automata and Compilers 03 - Context-Free Grammars

    Moving beyond regular languages with the structure and role of context-free grammars

  4. 4

    Automata and Compilers 04 - Pushdown Automata

    What computational power a stack adds to finite automata

  5. 5

    Automata and Compilers 05 - Compiler Overview โ€” Phases and Architecture

    Why compilers are divided into multiple phases and what each phase does

  6. 6

    Automata and Compilers 06 - Lexical Analysis

    How a lexer breaks source code into tokens and where automata theory meets real implementation

  7. 7

    Automata and Compilers 07 - Top-Down Parsing

    The principles behind recursive descent parsers, LL(1) grammars, and the strengths and limitations of top-down parsing

  8. 8

    Automata and Compilers 08 - Bottom-Up Parsing

    Shift-reduce parsing, LR parser mechanics, and how parser generators work under the hood

  9. 9

    Automata and Compilers 09 - Abstract Syntax Trees

    Parse trees vs ASTs, designing AST nodes, and how ASTs bridge the compiler frontend and backend

  10. 10

    Automata and Compilers 10 - Semantic Analysis and Type Checking

    How semantic analysis catches the errors that parsers cannot, and how type checking guarantees program safety

  11. 11

    Automata and Compilers 11 - Intermediate Representations and Optimization

    Why compilers use intermediate representations and how optimization makes programs faster

  12. 12

    Automata and Compilers 12 - Code Generation

    How optimized intermediate representations become machine code, and a final look back from automata theory to compiler construction

Where To Go Next