Building a Virtual Machine
Essentials of Low-level Interpretation
How programming languages work under the hood? What’s the difference between compiler and interpreter? What is a virtual machine, and JIT-compiler? And what about the difference between functional and imperative programming?
There are so many questions when it comes to implementing a programming language!
The problem with “compiler classes” in school is such classes are usually presented as some “hardcore rocket science” which is only for advanced engineers.
Moreover, classic compiler books start from the least significant topic, such as Lexical analysis, going straight down to the theoretical aspects of formal grammars. And by the time of implementing the first Tokenizer module, students simply lose an interest to the topic, not having a chance to actually start implementing a programing language itself. And all this is spread to a whole semester of messing with tokenizers and BNF grammars, without understanding an actual semantics of programming languages.
I believe we should be able to build and understand a full programming language semantics, end-to-end, in 4-6 hours — with a content going straight to the point, showed in live coding sessions as pair-programming and described in a comprehensible way.
Implementing a programing language would also make your practical level in other programming languages more professional.
There are two prerequisites for this class.
The Building a Virtual Machine course is a natural extension for the previous class — Building an Interpreter from scratch (aka Essentials of Interpretation), where we build also a full programming language, but at a higher, AST-level. Unless you already have understanding of how programming languages work at this level, i.e. what
eval, a closure, a scope chain, environments, and other constructs are — you have to take the interpreters class as a prerequisite.
Also, going to lower (bytecode) level where production VMs live, we need to have basic C++ experience. This class however is not about C++, so we use just very basic (and transferrable) to other languages constructs.
Watch the introduction video for the details.
Who this class is for?
This class is for any curious engineer, who would like to gain skills of building complex systems (and building a programming language is an advanced engineering task!), and obtain a transferable knowledge for building such systems.
If you are interested specifically in compilers, bytecode interpreters, virtual machines, and source code transformation, then this class is also for you.
What is used for implementation?
Note: we want our students to actually follow, understand and implement every detail of the VM themselves, instead of just copy-pasting from final solution. Even though the full source code for the language is presented in the video lectures, the code repository for the project contains
/* Implement here */ assignments, which students have to solve.
The main features of these lectures are:
- Concise and straight to the point. Each lecture is self-sufficient, concise, and describes information directly related to the topic, not distracting on unrelated materials or talks.
- Animated presentation combined with live-editing notes. This makes understanding of the topics easier, and shows how 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 code, starting from scratch, and up to the very end is presented in the video lectures
What is in the course?
The course is divided into five parts, in total of 29 lectures, and many sub-topics in each lecture. Below is the table of contents and curriculum.
In this part we describe compilation and interpretation pipeline, starting building our language. Topics of Stack and Register VMs, heap-allocated objects and compilation of the bytecode are discussed.
In this part we implement control flow structures such as
if expressions and
while loops, talk about Global object and global variables, nested blocks and local variables, and also implement a disassembler.
In this part we start talking and implementing function abstraction and function calls. We describe concept of the Call stack, native and user-defined functions, and IILEs (Immediately-invoked lambda expressions).
In this part we focus on closures implementation, talking about scope and escape analysis, capturing free variables, and adding runtime support for closures.
This part is devoted to the automatic memory management known as Garbage collection. We discuss a tracing heap and implement Mark-Sweep garbage collector.
In the final part we add support for Object-oriented programming, implementing classes and instances. In addition we build the final VM executable.
Dmitry Soshnikov is a Software engineer, and a lecturer on different computer science topics.
He is passioned about education, and focuses on high-quality educational content: concise and straight to the point animated lectures with live-editing notes.
You will learn:
- Compilers and interpreters: building a Programing language
- Garbage Collectors (Automatic memory management)
- Theory of programming languages
- Automata Theory: Building a RegExp machine
- Parsers theory: Implementing a Parser Generator
PreviewLecture 1: Introduction to Virtual Machines (19:22)
PreviewLecture 2: Stack-based vs. Register-based VMs (9:36)
PreviewLecture 3: Logger implementation (4:00)
PreviewLecture 4: Numbers: introduction to Stack (8:00)
PreviewLecture 5: Math binary operations (7:07)
StartLecture 6: Strings: introduction to Heap and objects (6:39)
StartLecture 7: Syntax: parser implementation (9:20)
StartLecture 8: Compiler | Bytecode (9:13)
StartLecture 9: Complex expressions (5:26)