How Does MPS Work?

Dialects and domain-specific lingo frequently arises to help people communicate effectively. MPS brings the same flexibility into the world of programming languages. Unlike traditional programming languages with strict syntax and semantics, MPS allows languages to be created, altered or extended by their 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 fully describes the program code.

The task of the MPS editor is then to visualize the AST in some user-friendly way and provide means for effective editing. For classical textual languages, the editor should give the user 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-behaving 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 thus 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 in, but is not limited to, generating Java code. You can also generate C, XML, FHTML, PDF, LaTeX, JavaScript, and more.

Watch video tutorial

What are Domain Specific Languages (DSL)?

“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 any 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 projection 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, tabular editor for editing tables and so on. The user interacts with the code through some intuitive on the screen visuals and can even switch between multiple displays of the same code.

Watch video tutorial

IDE Support

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

MPS is a powerful IDE with all you need to get full advantage of the 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 on one side and the implementation domain on the other 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. This 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, MPS real strength is when it is used to extend BaseLanguage or another universal language 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).

Built with MPS

Aveco — DSLs for describing the distributed architecture of our real-time systems and generating C++ code implementing the server, the client and the transportation layers

An extensible C language and IDE with support for formal verification, requirements and PLE

die modellwerkstatt — developing business applications made easy

Meta R IDE — blending user interfaces and scripting to help biologists analyze data

PEoPL — An IDE for flexible and view-based engineering of software product lines