The Tutorials Shelf

These tutorials are where you go for depth on your own schedule. They are worked paths, toolchain guides, and companions to the assignments and the Team Language Project. Most are invitations rather than requirements; a few (marked anchors required work) are the reference behind a required assignment step or reading, and the assignment itself always contains the full instructions.

Interactive Tools

• BNF/EBNF Tester: test a grammar against strings and see the parse tree and leftmost derivation, in the BNF Workshop’s angle-bracket notation or the Grammar Workshop’s token notation, with EBNF off until you turn it on
• regex101 (set the Flavor to Python) and pythex: try regular expressions interactively for the Regular Expressions and Lexer assignments
• FSM Simulator, FSM2Regex, and Automata Studio: step DFAs, NFAs, and ε-NFAs, convert between regular expressions and automata, and check a subset construction for the Finite Automata lab

Companions to the Assignments

• C for Flex and Bison: structs, pointers, strings, linked lists, tagged values, tables of functions, and Make, as the Parser and Interpreter assignments use them
• Python for Language Work: lists, dictionaries, sets, f-strings, JSON, classes, dataclasses, exceptions, generators, unittest, and capture groups, for every programming assignment
• Parser Combinators: Parsers as First-Class Values: companion to Recursive Descent Parsing
• Building a Lexer and Parser with PLY: the generator-toolchain route through the Lexer assignment, and the reading for the first interpretation session
• Grammars in Python: CFGs as dictionaries, left-recursion detection, parse trees as data, a derivation tracer, and an ambiguity detector
• Your Course Development Environment: Docker, Git, and GitHub, anchors required work, the recommended setup route in the Overview assignment: the course container, a GitHub-backed workspace, and the commit/push workflow
• Build an Interpreter: start-to-finish companion for the From Calculator to Scheme activity
• Type Inference: Implementing Hindley-Milner: for a team language that wants static checks
• Property-Based Testing Your Language with Hypothesis, optional depth for testing your team language
• Typing Disciplines: Strong vs. Weak, Static vs. Dynamic, and Gradual Typing, anchors required work, required reading for the Type Systems unit
• Prolog in the Browser with SWISH: companion to the Team Language Project’s optional Logic Programming extension
• Scheme Essentials: companion to the Functional Programming with Scheme assignment, covering the one syntax rule, list recursion, higher-order functions, and closures
• Haskell Essentials: companion to the Functional Programming unit
• Build a Lambda Calculus Reducer: companion to the Lambda Calculus unit
• Building an LR Parser from the Grammar Up, companion to the Parser assignment: closure, GOTO, the canonical collection, FOLLOW, SLR(1) tables, the driver, and conflict diagnosis, worked on a smaller grammar and a simpler table type than the assignment’s
• Flex and Bison, Complete: companion to the Lexer assignment’s generator-toolchain direction and the Interpreter’s Flex and Bison option

Companions to the Team Language Project

• Team Language Extensions Menu: each extension a team can adopt
• The Music and Live-Coding Path: how Direction B fits the course
• The Project Language Guide: a complete worked path for the team project
• A Syntax Highlighter for Your Language with tree-sitter: an editor-support extension (tree-sitter grammar + VS Code highlighting, optional diagnostic) with big Demo-Day payoff
• CI and TDD for Interpreters: test suites, GitHub Actions, and coverage for your language
• Shell Skills for Language Development: run, test, and debug confidently from the command line
• Publishing Your Language: pip, npm, and Docker: release hardening and distribution
• ShipIt: Repo Hygiene, README, Packaging, and Your Portfolio, anchors required work, the self-check scored within the project’s Documentation and Reproducibility dimension
• Demo Day Guide: External Guests: presenting your language to guests at Demo Day
• Build a Bytecode VM: a compilation-target extension for ambitious teams
• From AST to Code: Visitors and Transpilers: expression-oriented design, the Visitor pattern, and transpiling your AST to Python, JavaScript, and Haskell (with source maps)
• Coroutines and Generators: Pausable Computation: yield, send, and async/await built up from the idea of a frozen stack frame, ending with generator objects in your interpreter
• Error Handling: From Return Codes to Algebraic Effects: design your language’s error story: return codes, exceptions, Option/Maybe, and Result/Either
• Garbage Collection: Implementing Memory Management: a runtime extension for the project
• Compiling and Linking: From Source to Executable: what happens below your interpreter
• Advanced C++ for Language Implementers: for teams implementing in C++