This intensive 4-day course is dedicated to developing the core of a small programming language in Rust—with the same semantic capabilities found in real languages. Participants will implement the evaluation of mathematical expressions, work with scopes and mutable variables, higher-order functions, mutable data structures, error handling, memory management (including garbage collection), types, objects, and macros.
Unlike the traditional academic approach, the course offers a more "hands-on immersion": instead of using convenient educational languages, you will work with Rust—a language known for its strict ownership model, borrowing system, and mutability control. As the project becomes more complex, participants face real challenges related to recursion, mutability, and the constraints of the borrow checker, which allows for a deeper understanding of the internal logic of the language.
The course views Rust not as a set of syntactic constructs, but as a tool for building programming languages. This approach helps to go beyond superficial study and truly understand the key concepts.
Program:
- basics of working with structures, enums, and pattern matching
- implementation of complex mechanisms: mutable data structures and higher-order functions
- advanced topics: macros, unsafe code, and integration with external libraries
At the same time, the course intentionally does not focus on writing a parser to devote maximum attention to more complex and fundamental aspects.
The course is suitable for developers who are already familiar with the basics of Rust and want to delve deeper into complex topics: data ownership, the borrow checker, object relationships, and mutability management.
Such a project is an effective way to learn the language: it covers key data structures, demonstrates complex interrelationships, and provides knowledge applicable to any programming language. Additionally, it is a rare opportunity to see how the language you created truly works.
