Theory and practice of syntactic analysis
What you'll learn
- Context-free grammars
- Abstract Syntax Trees
- Parser generators
- Build a full parser from scratch using parser generator
- Top-down LL parsers
- Bottom-up LR parsers
- Backtracking parsers
- Left-recursion and Left-factoring
- Predictive recursive descent parsers
- LL(1)LR(0)SLR(1)CLR(1)LALR(1) parsers
- Shift-reduce algorithm
- Syntax tool: language-agnostic parser generator
Requirements
- Basic data structures and algorithms
- Treesgraphstraversal
- Interest in programming languages
Description
Course overview
Parsing or syntactic analysis is one of the first stages in designing and implementing a compiler. A well-designed syntax of your programming language is a big motivation why users would prefer and choose exactly your language.
----------------------------------------------------------
The problem with “parsers theory” in classic compiler schools and books is that this theory is often considered as “too advanced”going right into complicated formal descriptions from the Theory of Computation and formal grammars. As a result students may lose an interest in building a compiler already at parsing stage.
The opposite problem often seen in describing a parser is a superficial approach describing only manual (usually recursive descent) parsingleaving the students with issues understanding the actual techniques behind the automated parsers.
----------------------------------------------------------
I believe this deep dive into the parsing theory should be combined together with a hands-on approachwhich goes in parallel and allows seeing all the learned theoretical material on practice.
In the Essentials of Parsing (aka Parsing Algorithms) class we dive into different aspects of the parsing theorydescribing in detail the LL and LR parsers. However at the same time to make the learning process and understanding easy and funwe build in parallel an automatic parser for a full programming languagesimilar to JavaScript or Pythonfrom scratch.
After this class not only you will be able to use a parser generator to build parsers for programming languagesbut will also understand how the parser generators work under the hood themselves.
Implementing a parser for a programing language would also make your practical usage of other programming languages more professional.
Who this class is for?
This class is for any curious engineerwho would like to gain skills of building complex systems (and building a parser for a programing language is a pretty advanced engineering task!)and obtain a transferable knowledge for building such systems.
If you are interested specifically in compilersinterpretersand source code transformation toolsthen this class is also for you.
The only pre-requisite for this class is basic data structures and algorithms: treesliststraversal.
What is used for implementation?
Since we build a language very similar in semantics to JavaScript or Python (the two most popular programming languages today) we use specifically JavaScript — its elegant multi-paradigm structure which combines functional programmingclass-basedand prototype-based OOP fits ideal for that.
Many engineers are familiar with JavaScript so it should be easier to start coding right away. To generate the automated parser we use Syntax tool which is a language-agnostic parser generatorand supports plugins for PythonRubyC#PHPJavaRustetc. That isthe implementation of this parser can easily be transferred to any other language of your choice and taste.
Note: we want our students to actually followunderstand and implement every detail of the parser themselvesinstead of just copy-pasting from final solution. The full source code for the language is available in video lecturesshowing and guiding how to structure specific modules.
What’s specific in this class?
The main features of these lectures are:
- Concise and straight to the point. Each lecture is self-sufficientconciseand describes information directly related to the topicnot distracting on unrelated materials or talks.
- Animated presentation combined with live-editing notes. This makes understanding of the topics easierand shows how (and when at time) the object structures are connected. Static slides simply don’t work for a complex content.
- Live coding session end-to-end with assignments. The full source codestarting from scratchand up to the very end is presented in video lectures of the class
What is in the course?
The course is divided into four partsin total of 22 lecturesand many sub-topics in each lecture. Below is the table of contents and curriculum.
Part 1: Context-free grammars and languages
In this part we describe different parsing pipelinestalk about formal grammarsderivationswhat is ambiguous and unambitious grammarand start building our programming language.
Part 2: Top-down LL parsing
In this part we talk in detail about Top-down parsingdescribing manual recursive and backtracking parserand also dive into the LL(1) parsing algorithm.
Part 3: Bottom-up LR parsing
In this part we describe Bottom-up parsers and LR parsing algorithm. In parallel we continue building our programming languageanalyzing shift-reduce conflicts and fixing them.
Part 4: Practice and final parser
The final part of the course is completely practicalwe’re finishing our Letter programming languagebuilding variablesfunctionsloopscontrol structuresobject-oriented programmingand the final parser.
Who this course is for:
- Any curious engineers
- Compiler engineers
