Dialects and domain-specific lingo helps people to communicate specifically and effectively. MPS brings the same flexibility into the world of programming languages. Unlike traditional programming languages with strict syntax and semantics, MPS allows a language to be created, altered or extended by its users.

The core problem of extending languages lies mainly in the parsers. Parsers tie code persistent representation with the visual notation and they cannot be combined with other parsers easily, which prevents language modularization.

This naturally leads to the idea of non-textual presentation of program code. A major benefit of this approach is that it eliminates the need for parsing. Our solution is to always have code maintained in an Abstract Syntax Tree (AST), which consists of nodes with properties, children, and references, and which fully describes the program code.

The task of the MPS editor is then to visualize the AST in a user-friendly way and provide the means for effective editing. For classical textual languages, the editor should provide the user with the illusion of editing text in a text-like manner, for graphical notations, on the other hand, the editor should take on the habits of a well-behaved diagramming editor.

When creating a language, you define the rules for code editing and rendering. You can also specify the language type-system and constraints. This allows MPS to check program code on the fly, and so makes programming with the new language easy and less error-prone.

MPS uses a generative approach. You can define generators for a language to transform user code into compilable code written in a more conventional, typically general-purpose, language. Currently, MPS is particularly good at, but is not limited to, generating Java code. You can also generate C, XML, FHTML, PDF, LaTeX, JavaScript, and more.

“Programming languages that raise the level of abstraction beyond programming by specifying the solution that directly uses concepts and rules from a specific problem domain.” Kelly and Tolvanen (2008)

With MPS you can define custom editors for a new language and make using these DSLs simpler. Even domain experts, who are not familiar with traditional programming, can easily work in MPS with domain-specific languages designed around their domain-specific terminology.

Projection Editor

A projectional editor allows the user to edit the Abstract syntax tree (AST) representation of code in an efficient way. It can mimic the behavior of a textual editor for textual notations, a diagram editor for graphical languages, a tabular editor for editing tables and so on. The user interacts with the code through intuitive on screen visuals which they can even switch between for multiple displays of the same code.

IDE Support

JetBrains is well known for its high-performance IDEs and development tools, and MPS is no exception.

MPS is a powerful IDE with all you need to take full advantage of DSLs. Some of the features included are: Code completion, navigation, refactoring, error checking, quick fixes, debugging of DSLs, language versioning with automatic migrations and integration with mainstream version control systems.

Code Generation

Bridging the semantic gap between the business domain and the implementation domain is handled by the MPS generator.

Through a series of steps, the generator gradually transforms the original domain-specific model into a model represented in a low-level general-purpose language, such as Java, C, JavaScript, or XML. The resulting model may then be further transformed into textual source files, which can be fed into traditional compilers in order to generate runnable binaries.

While a domain-specific language formalizes the business knowledge of the domain experts, the generator encapsulates the implementation of that knowledge in a given technology. The generator preserves the expertise of the most senior software developers in a reusable form and lets others benefit from it.

The clear separation of the business knowledge, contained in the language, and the implementation knowledge, held in the generator, allows users to target multiple platforms at the same time by using multiple generators for the same language. Users can also save on efforts when switching the target implementation technology, since only the generator needs to be changed. The business knowledge contained in the existing domain-specific models can remain intact.

MPS for Creating DSLs and Language Extensions

MPS originally included a ready-to-use universal language called BaseLanguage that was a copy of Java. Over time additional languages have been added, like XML, C, and JavaScript. These can themselves be used to create programs. However, the real strength of MPS is when it is used to extend BaseLanguage or other universal languages and create new languages on top of them. MPS comes with several helpful extensions to BaseLanguage for working with strings, collections, dates, regular expressions, etc. You can also use them as a reference for creating new languages. These powerful tools make MPS quite proficient as an instrument for creating Domain-Specific Languages (DSL).