Fast Track to MPS - Ten steps to mastery

Step 1 - Why MPS

Raw time estimate - 15 minutes

Let's start with some motivation for learning MPS.

1. First of all, check out a two-minute overview video about MPS - Why JetBrains MPS, so you can assess whether this tool offers something that you need on your projects.

2. Our new VoiceMenu demo application has been created to give people coming from different domains of expertise a quick understanding of the potential of MPS. Watch this short video.

3. If you care about academic research, you may also check out  a list of all academic publications on MPS  that the MPS users have published over time.

Step 2 - Get your hands dirty

Raw time estimate - 120 minutes

Try MPS right now! Download it from the MPS website and proceed to a hands-on course that we prepared for you. You will join a free, guided on-line tutorial that will let you instantly play with MPS, write some code, improve language definition bits and see how it all works. The focus is on you trying things out so that you can assess whether MPS is for you and what to expect from it. Minimum time is spent explaining the theory. There's always time to dive deep into MPS later, once you know it is the right tool for you. Now, head to The JetBrains MPS for the impatient and learn you some MPS.

Step 3 - MPS from the programmer's perspective

Raw time estimate - 15 minutes

Plain reading about MPS will never teach you as much as trying it for real yourself. You might have done this already, but if not, grab MPS from the download site and install it. With MPS installed you will be able to continue on the Fast Track.

Configure the editor

We are all different. If the default settings that MPS comes with do not fit your habits, you can always change them in the  Preferences (MacOs, press Ctrl+Alt+S) or  Settings (Windows, press Ctrl+Alt+S, or go to the menu File -> Settings ). One of the most likely settings to change is the font size in the  Editor -> General section:

A quick ride

Since we programmers like trying things, how about taking the MPS editor for a simple test ride first? You may get the first impressions instantly, if you start MPS and open the Robot Kaja  sample project. This project defines an artificial language to command a virtual robot. The robot can move within a rectangular area, drop and collect marks and check the surrounding cells for walls and marks. You write Scripts  using the built-in commands as well as new commands that you create on the fly. When you run the script a simulator written in Java is started to visualize the execution of your program.

To open the project, start your fresh MPS, click on the Open Sample Project  button and pick robot_Kaja . The sample projects have been installed into your HOME/MPSSamples  folder.

                                                                                                                              

The following video has been borrowed from the MPS Introductory Online Training course. This instructional screen-cast will help you start using MPS. Check it out.
If you like the video and if you are serious about learning MPS, you may consider enrolling into the MPS Introductory Online Training. It will give you thorough guidance through numerous hands-on exercises and you will be able to discuss your progress and questions with a live trainer.

Step 4 - Study the fundamentals

Raw time estimate - 25 minutes

Watch this video, now! -  The first run. It gives you the essential information into how MPS is organised, how it works and how users are supposed to interact with it.

1. If you are carefully evaluating MPS there must be many questions popping up in your head while watching videos or reading stories about MPS usages. I believe that some of these questions have already been answered in the MPS FAQ page. Check it out,

2. Read a gentle introductory article on MPS fundamentals by Mikhail Barash. This is definitely worth your time at this moment, since you will understand all the principles as soon as you read the article.

3. Stop for a minute now and skim through a short page listing the essential terms like node, Concept, AST in order to understand better the terminology used down the line.

Step 5 - Projectional editing tips and tricks

Raw time estimate - 25 minutes

Before you continue, you should probably get to know the most distinct feature of MPS - the projectional editor. Check out a video that explains all the differences between traditional textual editors and the MPS projectional editor and lists the numerous benefits of this approach.

When editing code in MPS you will run into situations when your coding habits interfere with the projectional nature of the MPS editor. I'm actually pretty confident that you have already discovered such surprises during your experiments. Code in MPS is not text, but instead it is a projection of the abstract syntax (AST). This gives several benefits to language designers and, at the same time, makes the editing experience slightly different and more-restrictive than in the commonplace text editors. This may or may not be considered to be an advantage, nevertheless, there is a learning curve to projectional editing. In general, in projectional code you more rely on the assistance of the editor. Code-completion, block selection and intention actions should become your close friends in order to become an efficient projectional coder. There's a good and a bad side to it:

• good - in less than a week of programming in the MPS editor people typically get back to their full speed of coding they experienced before in text-based IDEs

• bad - projectional editing is highly addictive and you may find text-based editors less compelling and less helpful than you thought they'd been before

Since we are now about to get really serious about designing languages and I will need your full commitment to learning MPS, if you still hesitate, whether to invest more of your time into exploring MPS, you may consider checking out the following materials before proceeding. If you are already convinced, just rush to the next step.

• JetBrains MPS is an efficient and reliable development tool that has been adopted by software vendors on both commercial and academic projects. MPS-based DSLs have been adopted in wide range of domains, such as legislation modelling, electrical engineering, insurance industry, embedded software, medicine systems, bio-informatics and data analysis. The "The "When MPS" section of the MPS home page" lists several of the successful projects and gives a high-level overview of the technology used.

• You may also like to slow down a bit and let Mikhail Barash inspire you to your own ideas on building something great around MPS with his excellent A tale about domain-specific languages. You are welcome!

Step 6 - MPS from the language designer's perspective

Raw time estimate - 20 minutes

Now you must be curious about how the robot sample language has been created. Please, open again the Robot Kaja  sample project and play our explanatory screen-cast showing you round the language definition fundamentals.
Again, this video has been borrowed from the MPS Introductory Online Training course to give you a taste of this paid course that JetBrains provides.
As you go through the video, pause frequently and look around the sample project yourself. This way you will understand a typical language structure and see the relationships between its individual parts.

At this point you should understand that language definition consists of several aspects. Some of these are mandatory, some are optional:

• Structure  - Defines the kinds of nodes (called  Concepts) that may be used in user models. Each node in the program (model) refers to its concept.  Concepts  specify, which  properties ,  children  and  references  nodes may have.  Concepts  can extend other  Concepts  and implement  ConceptInterfaces.

• Constraints  - Restricts the relationships between nodes as well as the allowed values for properties beyond the rules defined in  Structure . Constraints typically define:

  • the target scope for references (a collection of allowed nodes a reference can point to) 

  • situations, in which a node can be a child/parent/ancestor of another node 

  • allowed values for properties 

  • property accessor methods (getters and setters)

• Behavior  - Just like classes in OOP hold methods,  Concepts  may define methods and static methods that can be invoked on nodes in a polymorphic way.  Nodes  thus carry behaviour alongside their properties and relationships.

• Editor  - Instead of defining a parser that would translate code from an editable form (i.e. text) into the tree-like structure that a computer could manipulate, MPS offers the concept of  projectional editor, which let's the user edit the AST directly. The  Editor  aspect enables language designers to create a UI for editing their concept concepts.

• Actions  - Since the MPS editor manipulates the underlying AST directly, some editing actions, such as copy-paste or replacing one node with another one translate into non-trivial AST changes. The  Actions  aspect holds definitions of such customised AST transformations.

• Intentions  - All modern IDEs assist developers with instant code manipulating action available under a handy key-shortcut (Alt+Enter in MPS). Language authors can define such little code transformations for their languages in the  Intentions  aspect.

• Typesystem  - Language that need to type-check their code need to provide type-system rules. The MPS type-system engine will evaluate the rules on-the-fly, calculate types for nodes and report 
  errors, wherever the calculated type differs from the expectations.
  So called  checking rules  may additionally be defined to verify non-typesystem assertions about the model.

• Dataflow  - The ability to understand the flow of values and the flow of control through language constructs helps languages report issues such as  unreachable code  or  potential null-pointer error . Language designer can leverage the  Dataflow  aspect to define the flow for each concept, which MPS will then use to calculate the dataflow for the whole program.

• Generator  - Models written in one or more languages get ultimately translated into runnable code in some target general-purpose language and platform, such as Java. Along the way models get gradually transformed so that repeatedly concepts get replaced with concepts from a lower level of abstraction until the bottom-line level is reached. The rules for translating concepts and their proper ordering is defined in the  Generator  aspect.

• TextGen  - During code generation after the  Generator  has reached the bottom-line AST representation, the  TextGen  phase kicks in and translates all nodes in the model into their textual representation and saves the resulting textual source files on disk.

Step 7 - Shapes tutorial

Raw estimate - 2 hours

The Shapes Tutorial gives you an opportunity to quickly create your own language. Check out the MPS entry-level Shapes Tutorial and build a language that enables non-programmers to build scenes of graphical shapes.

Step 8 - Calculator tutorial

Raw time estimate - 8 hours

Now you must be curious to find out more details about language design in MPS, right? Having given you all the fundamental information and some level of experience, the introductory tutorials should have left you in a good position to dive deeper and build a sample language all the way from the ground up. The  Calculator tutorial  will guide you through the process of language creation. You start with an empty project and end up with a language to build Java Swing-based visual applications. Try it out and have fun.

Step 9 - Managing dependencies and imported languages

Raw time estimate - 30 minutes

As you must have noticed already, MPS lets you manage dependencies between models as well as import languages. Since it is essential to understand these, read a user guide chapter on getting the dependencies right . It will teach you the distinction between dependencies and imported languages and how to set/manage them.

Step 10 - The Garage project tutorial

Raw time estimate - 5 hours

The  Calculator tutorial  should have left you with good overall knowledge of language design. Now it is time for a more thorough exercise. The garage project will have you create several interconnected languages, package them as reusable plugins and stack languages one above the other. To handle the complexity of this tutorial, we leverage the  Stepik platform for online education. Enrol in the free MPS Elementary Course.

Got questions?

As with learning any new technology, you may have questions you need help with. Don’t worry, we’ve got your back! There are a few options available for getting answers to your questions:

• For questions that aren’t urgent, you can use our forum.

• You can get quick answers by asking your questions on the Community Slack channel. We have a great community that is always willing to help newcomers.

• You can also attend the free MPS Office hours that experienced members of our community hold.

Reviewing the progress

Congratulations! By completing the above tutorials and exercises you've made a serious dent into the language design world. Your knowledge and command of MPS could now be qualified somewhere above the Advanced beginner  stage of the  Dreyfus model of skill acquisition. This is definitely a good time to celebrate and perhaps also to let us know about you success.

Moving up the ladder

The next stage in the  Dreyfus model of skill acquisition  is Competent. Once you reach that stage you'll be able to work on your own without concrete guidelines and supervision. But for this to happen, you'll need to spend more time solving various problems with MPS. If you already have an idea of a language to implement, go ahead and do it. If not, try to come up with a useful little language. You could as well try to re-implement one or more of the MPS samples and then see how closely you got. Or just pick a sample as the starting point and move it forward - add language features, implement a generator, add type-system rules, polish the editing experience - whatever feels like the right challenge for you.

Additionally, you should try these in order to become Competent in MPS and language design:

1. Apply for the MPS Advanced Course by JetBrains. Both online and on-site options are available. In the advanced course you will learn about:

   • making the editors fluent, intelligent and convenient to use

   • implementing non-trivial generators

   • defining type-system rules

   • specifying code analysis rules and quick-fixes

   • building customized IDEs and language plugins

   • a ton of other things

2. Study the  Common language patterns

3. Study the cookbooks to deepen your knowledge of the various aspects of language design

4. Get to know quotations and anti-quotations

5. The  Generator tutorial  will teach you more subtle options that the MPS generator offers. You will learn about the different types of macros, generator scripts, utility models and more.

6. Familiarise yourself with the languages bundled in MPS, such as closures, collections, concept functions ,  regexp, tuples, smodel, build language and other

7. Learn how to build MPS projects from the command line , how to package languages into IntelliJ IDEA as well as  MPS  plugins, how to use the plugins and how to build standalone DSL IDEs

8. Get a feel for the user guide so you can quickly find the information that you need

9. Learn some of the keyboard shortcuts by heart

10. Become active in the MPS community and try to answer the forum  questions of people that walk behind you on the same path to MPS mastery

After becoming Competent you should definitely continue gaining experience. The more you work with MPS and the more divert your projects are, the faster you'll be moving up on the  Dreyfus model of skill acquisition  scale. If you set yourself a goal to become  Proficient  and ultimately an Expert  in MPS, you might consider trying:

1. Studying and practising advanced topics, such as:

   1. Find usages

   2. MPS Make Framework

   3. Debugger enhancements and customisation

   4. Custom persistence

   5. Dependency analyzer and Module dependency tool

   6. Custom dataflow analyzers

   7. Extensions  

2. Helping MPS expand into there areas by creating a base language for a different target language/platform - Python, Ruby, Dart, Haskell, Go, etc

3. Speaking about MPS at events

4. Helping us evolve the documentation

5. Contributing code to the MPS project

Although there's not much detailed documentation to guide you at this experience level and you'll have to be self-driven most of the time, we'll always be happy to discuss, advise and cooperate with you.

Documentation sources

Here's a list of documentation sources that you may need on your path to MPS mastery

Books

Fabien Campagne wrote The MPS Language Workbench: Volume I and Volume II books, which you can purchase both electronically and as paper-back. Although the books cover an older version of MPS, most of their contents is still relevant. Get them  here.