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.

Companions to the Assignments

• 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 and Parser assignments, 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 Tree-Walking Interpreter assignment
• Type Inference: Implementing Hindley-Milner: companion to the Interpreter assignment’s type-checking direction
• Property-Based Testing Your Language with Hypothesis, anchors required work, companion to the Parser (Step 3e) and Interpreter (Step 2e) property-based-testing requirements
• 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 Functional assignment’s Logic Programming direction (Direction F)
• 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
• Flex and Bison, Complete: companion to the generator-toolchain directions of the Lexer and Parser assignments

Companions to the Team Language Project

• 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 and Technical Interview Practice: presenting to guests, and the final-sprint-studio mock-interview rehearsal
• 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 from first principles, 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++