Programming with JetBrains MPS — Textbook for Beginners
This document contains an outline of a textbook on JetBrains Meta Programming System (JetBrains MPS) being written by Mikhail Barash. The purpose of this document is to have a discussion on the content structure of the textbook with MPS community members.
The textbook is meant for those without any prior experience on JetBrains MPS or language engineering. The author has some experience in teaching courses on MPS, and this book is planned as an embodiment of the methodological approaches used in different teaching settings.
The structural unit of the book is a double-page spread, rather than a page. Each spread is a finished piece of information — it has self-contained material on a particular topic. Some topics span over several spreads, and in such cases each of the spreads is devoted to a single subtopic.
The textbook is divided into three parts:
- MPS as a tool for textual UIs
- MPS as a modelling tool
- MPS as a tool for extending existing languages
This choice and order of the parts is explained by a desire to avoid burdening the reader with language engineering terminology (from our experience, even "AST" scares off beginners.) We start with known terminology – classes, interfaces, enumerations – and slowly revise key notions and ideas using "appropriate" terminology. Moreover, the choice of the parts reflects typical patterns for building a software language.
Here are some of the highlights of the content of the textbook.
- As the intro text of each of the parts of the book is still a double-page spread, there is no explicit separation into parts for the reader.
- The book starts with a general discussion on what a workbench is (not only language workbench).
- At first, MPS is presented as a tool to define textual user interfaces. We start with familiar notions of classes, interfaces, enumerations, etc. and throught this part, we introduce their "counterparts" in MPS. For example, classes become concepts and so on.
- Each of the three parts of the book has a running example that we develop from scratch until completition during the course of the corresponding part.
- In the first part, we develop a textual UI for Invoice Calculator, introducing and showcasing necessary MPS notions.
- We postpone as much as possible discussing language aspects. When we finally have to introduce aspects, we do not expose the reader to details unnecessary at a particular point. For example, discussion of
Editoraspect tries to avoid making a big deal of projectional editing (see below).
Actionsaspect in not mentioned until the second part of the book, where it comes naturally in one of the examples.
- We then discuss
Intentionsaspect and make a point about importance of domain-specific error support. We discuss an implementation of Invoice Calculator in Excel for comparison.
- Code generation is discussed throught several spreads of the book, and we start with
TextGenaspect, where we define a generator for Invoice Calculator that generates RTF files.
- We continue with code generation with
Generatoraspect: we define a generator for Invoice Calculator to XML.
- At this point we make an excursion to XML/XSLT and give a conceptual comparison of
Generatoraspect and XSL transformations.
- We then continue with generating Java code with
Generator. We deliberatly discuss Java code generation after RTF and XML to address a frequent opinion of the newcomers that MPS only allows generating Java code.
- Projectional editing does often scary off beginners by its perceived "clumsiness" and limitations. That is why it is not "introduced" until this moment. We try to make the point that there is nothing special in the fact that MPS (only) supports projectional editing, by discussing that most of the functionality of a traditional text editor is replicated in MPS. Putting projectional editing to the backstage was a major decision we made about this book, and it still remains to see whether it makes a difference. We also discuss in details
- In the second part of the book, we use MPS as a modelling tool, i.e., we discuss the raison d'être application of MPS — implementation of domain-specific languages. Running example of this part is
- We revise the metaphor of OOP counterparts in MPS that we introduced in the beginning of the first part, and encourage the reader to focus on notions used in language engineering.
- We return again to code generation with
Generatoraspect, where we discuss in more details reductions, quotations, mapping labels, etc.
- We then continue with type system and data-flow analysis for
Entitieslanguage. By this time, the reader has implemented a tiny domain-specific language. Our goal here was to describe the development of a language from scratch within one "chapter". The second part is concluded by a discussion on evolution of
Entitieslanguage and language migration in MPS.
- The third part of the book is devoted to using MPS to extend
baseLanguage— we introduce several extensions of Java, talk again about
Generatoraspects. We also discuss about extending
- We give an overview of language composition (reference, extension, reuse, embedding) and talk again about projectional editing and how it enables language composition. However, we do not go into further details on language reference/reuse/embedding because these topics, in our opinion, should be covered in a more advanced book.
- For the same reasons, we do not discuss any of the MPS extensions, such as grammar cells or
- We do not discuss testing. This is a drawback, but discussing this topic might complicate reader's perception of already non-trivial material. The purpose on the textbook is to give an introduction to MPS: we don't aim at preparing a reader for deploying a language. Another important topic that is left for a more advanced book is debugging.
- We explicitly mark each spread of the book with "difficulty" level, suggesting several study paths for those interested in superficial acquaintance with MPS, those who already have some basic knowledge, or those who want to study more "advanced" topics.
- Finally, because we revise MPS idioms, notions, and used terminology throughout the book, and because of the very layout of the book, some repetitions of the material are unavoidable.
Below we list the spreads of the book.
|0||What is MPS?|
|1—2||MPS as a Tool for Textual User Interfaces|
|3—6||Object-Oriented Programming in MPS|
|7||Intentions and Quickfixes|
|8—10||Generating Text Output with
|11||Generating XML Output with
|12—13||Generating Java Code with
|14—16||Projectional Editing: Pros and Cons|
|17—18||Tabular and Graphical projections|
|19||MPS as a Modelling Tool|
|20—21||Looking at Code Through MPS Prism|
|25—26||Scoping Rules and
|27—29||Generating Java Code with
|32||Generating VBA Code|
|33—34||Checking Domain Code: Type Systems|
|35||Checking Domain Code: Data-Flow Analysis|
|36||Evolution of Languages|
|37—39||MPS as a Tool for Extending Existing Languages|
|40||MPS in Practice|
When Will the Textbook Be Ready?
Rough estimate is Q2–Q3 2020.
It takes a significant amount of time not only to prepare the content of a spread, but also to layout it in a proper and engaging way. Inspired by this, this and this, we try to use encyclopedia-style layout (only layout — not content), for example, with boxes for extra material, and so on.
The book will be published electronically and will be open-source: all spreads will be published in Adobe Illustrator format (layers preserved etc.) so that they could be (re)used for creating teaching materials.