From parsing to interpretation: let's build a language and explore both the interesting and oddly simple algorithms employed in making a language.
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
assets
README
implementation.scala
presentation.pdf
presentation.rkt

README

**From parsing to interpretation: let's build a language**

An understanding of program evaluation can be a truly enlightening thing for a
programmer. By breaking down the process to its essence and implementing the
parsing and interpretation steps for a Lisp, we will explore both the
interesting and oddly simple algorithms employed in making a language.

Our Lisp will have familiar characteristics like variables, higher-order
functions, conditionals, and lexical scope.


Outline:

- Topic introduction
  - What is this talk about?
  - Who is this talk for?
  - What are we building?
  - What is an interpreter?
  - What does our language look like?
  - Why does our language look the way it does?
- What are languages?
- Why one might care about languages?
- What one might get out of learning about languages?
- Overview of an interpreter
- Tokenizer
  - Tokenizer generators
- Parser
  - BNF/EBNF
  - Parser generators
  - Top down parsers
  - Recursive descent parsers
- Evaluator
  - Pattern matching in Scala


Assets:

- Computer image: https://pixabay.com/en/cartoon-computer-tooned-in-2026805/
- Google search image: https://www.google.com/search?q=define+interpreter


Resources:

- https://en.wikipedia.org/wiki/Extended_Backus-Naur_form
- https://en.wikipedia.org/wiki/Abstract_syntax_tree
- https://en.wikipedia.org/wiki/Recursive_descent_parser
- https://en.wikipedia.org/wiki/Multi-pass_compiler