Antonio Bucchiarone, Claudiu-Bogdan Ciumedean, Kemal Soysal, Nicola
Dragoni, Václav Pech

The status quo of software applications is in a constant evolution due
to emerging of new technologies, performance improvements, and new business requirements. In the past years a new architectural style named microservice architecture emerged which takes an approach to develop application characterised by a suite of small services each running in its own process being decoupled from the other application’s components. Nevertheless, implementing a microservice architecture is not trivial and it also comes with several downsides such as a higher complexity of configuring and developing the services, proper componentisation for supporting a single business capability, and implementing the appropriate related software design patterns. Additionally, it requires writing of boilerplate code templates to configure the communication with the services and their deployment.
State of the art research tries to address these issues by providing domain-specific languages that enable users to specify and generate microservice applications. However, these solutions do not provide a tool for specifying and generating a microservice-based application similar to any other software application. This paper proposes MaGiC, a DSL framework for implementing language agnostic microservice-based web applications. The framework can be used to specify a microservice-based software application end-to-end which can be used as any other application on the internet, and in the same time the implementation of the architecture is developed following the best practices.

Read Manual

Antonio Bucchiarone, Antonio Cicchetti, Federico Ciccozzi and Alfonso Pierantonio

This book covers several topics related to domain-specific language (DSL) engineering in general and how they can be handled by means of the JetBrains Meta Programming System (MPS), an open source language workbench developed by JetBrains over the last 15 years.

The book begins with an overview of the domain of language workbenches, which provides perspectives and motivations underpinning the creation of MPS. Moreover, technical details of the language underneath MPS together with the definition of the tool’s main features are discussed. The remaining ten chapters are then organized in three parts, each dedicated to a specific aspect of the topic. Part I “MPS in Industrial Applications” deals with the challenges and inadequacies of general-purpose languages used in companies, as opposed to the reasons why DSLs are essential, together with their benefits and efficiency, and summarizes lessons learnt by using MPS. Part II about “MPS in Research Projects” covers the benefits of text-based languages, the design and development of gamification applications, and research fields with generally low expertise in language engineering. Eventually, Part III focuses on “Teaching and Learning with MPS” by discussing the organization of both commercial and academic courses on MPS.

MPS is used to implement languages for real-world use. Its distinguishing feature is projectional editing, which supports practically unlimited language extension and composition possibilities as well as a flexible mix of a wide range of textual, tabular, mathematical and graphical notations. The number and diversity of the presented use-cases demonstrate the strength and malleability of the DSLs defined using MPS. The selected contributions represent the current state of the art and practice in using JetBrains MPS to implement languages for real-world applications.

Read book

Samuël Noah Voogd, Kousar Aslam, Louis Van Gool, Bart Theelen and Ivano Malavolta

Software tools known as language workbenches are used to define and deploy custom (domain-specific) languages for the purpose of modeling (specific parts) of a system of interest. Because system modeling is a practice that stands to benefit from real-time collaboration, technologies offering real-time collaborative mechanisms for language workbenches are starting to make an appearance. However, these collaboration technologies are generally limited to providing collaboration among clients of a single designated workbench. If the collaborating engineers wish to use different workbenches to work on the model, cross-platform support for collaborative modeling becomes a necessity. In this paper we propose Parsafix, a tool-based approach for achieving real-time collaboration between different language workbenches for users collaborating on models conforming to the same domain-specific language. We propose the main components and mechanisms that make up Parsafix, as well as the implementation of a prototype tool supporting those mechanisms. The prototype tool allows for collaboration between users of JetBrains MPS and Spoofax (within the Eclipse IDE), by making use of the IDEs’ respective real-time collaboration technologies Modelix and Saros. A hands-on session is proposed to showcase the feasibility of having collaborative modeling across different language workbenches through Parsafix.

Read the paper

Bruno Costa Mendonça

As microservices become more and more common, there is more interest in optimizing their development, making it faster, reducing the complexity and making it less error and bug prone.

This work aims to explore how Model-driven Engineering (MDE) can be used to aid microservices’ development, especially Java microservices using Spring Boot.

Firstly, this work starts by presenting its context, with a brief introduction to MDE and microservices, and how MDE can be used to facilitate microservices’ development.

Then the State of the Art presents MDE base technologies and MDE-based solutions that can be used to develop microservices.

Furthermore, a value analysis was also done, to explore the benefits of using MDE, and to define its value proposition.

Lastly, a case study was elaborated following three different approaches, traditional development, DSL-based approach, and MDE-based tool approach, which were then compared by code quality and time required for development of the microservices.

This work is especially interesting for someone who wants to develop Java microservices and wants to explore the different approaches and technologies to do so, namely by using MDE.

Read thesis

Sofia Meacham, Vaclav Pech, Detlef Nauck

This paper describes the design and development of a Classification Algorithms Framework (CAF) using the JetBrains MPS domain-specific languages (DSLs) development environment. It is increasingly recognized that the systems of the future will contain some form of adaptivity, therefore, making them intelligent systems as opposed to the static systems of the past. These intelligent systems can be extremely complex and difficult to maintain. Descriptions at higher-level of abstraction (system-level) have long been identified by industry and academia to reduce complexity. This research presents a Framework of Classification Algorithms at system level that enables quick experimentation with several different algorithms from Naive Bayes to Logistic Regression. It has been developed as a tool to address the requirements of British Telecom’s (BT’s) data-science team. The tool has been presented at BT and JetBrains MPS, and feedback has been collected and evaluated. Beyond the reduction in complexity through the system-level description, the most prominent advantage of this research is its potential applicability to many application contexts. It has been designed to be applicable for intelligent applications in several domains from business analytics, eLearning to eHealth, etc. Its wide applicability will contribute to enabling the larger vision of Artificial Intelligence (AI) adoption in context.

Read the paper

Andreas Prinz, Gergely Mezei

Language workbenches are used to define languages using appropriate meta-languages. Meta-languages are also just languages and can, therefore, be defined using themselves. The process is called bootstrapping and is often difficult to achieve. This paper compares four different bootstrapping solutions. The EMF environment and the Meta-Programming System (MPS) use a compiled bootstrapping for their own definition. The platforms LanguageLab and DMLA are using interpreted bootstrapping. This paper compares these kinds of bootstrapping and relates them to the definition of instantiation. Besides the structural aspects of the bootstraps, the dynamism is also elaborated. It is shown how the bootstrap is related to the execution environment. Finally, the level of changeability is also discussed. It is shown that all approaches are quite similar and provide very flexible environments.

P. Andreas, G. Mezei.The Art of Bootstrapping. MODELSWARD 2019. Communications in Computer and Information Science, vol 1161. Springer, Cham

Read the paper

Sofia Meacham, Vaclav Pech, Detlef Nauck

This paper contains the design and development of an Adaptive Virtual Learning Environment (AdaptiveVLE) framework to assist educators of all disciplines with creating adaptive VLEs tailored to their needs and to contribute towards the creation of a more generic framework for adaptive systems. Fully online education is a major trend in education technology of our times. However, it has been criticised for its lack of personalisation and therefore not adequately addressing individual students’ needs. Adaptivity and intelligence are elements that could substantially improve the student experience and enhance the learning taking place. There are several attempts in academia and in the industry to provide adaptive VLEs and therefore personalise educational provision. All these attempts require a multiple-domain (multi-disciplinary) approach from education professionals, software developers, data scientists to cover all aspects of the system. An integrated environment that can be used by all the multiple-domain users mentioned above and will allow for quick experimentation of different approaches is currently missing. Specifically, a transparent approach that will enable the educator to configure the data collected and the way it is processed without any knowledge of software development and/or data science algorithms implementation details is required. In our proposed work, we developed a new language/framework using MPS JetBrains Domain-Specific Language (DSL) development environment to address this problem. Our work consists of the following stages: data collection configuration by the educator, implementation of the adaptive VLE, data processing, adaptation of the learning path. These stages correspond to the adaptivity stages of all adaptive systems, such as monitoring, processing, and adaptation. The extension of our framework to include other application areas such as business analytics, health analytics, etc., so that it becomes a generic framework for adaptive systems and more usability testing for all applications will be part of our future work.

Read the paper

Antonio Bucchiarone, Kemal Soysal, Claudio Guidi

Microservices have received and are still receiving increasing attention, both from academia and the industrial world. To guarantee scalability and availability while developing modern software systems, microservices allow developers to realize complex systems as a set of small services that operate independently and that are easy to maintain and evolve. Migration from monolithic applications to the microservices-based application is a challenging task that very often it is done manually by the developers taking into account the main business functionalities of the input application and without a supporting tool. In this paper, we present a model-driven approach for automatic migration to microservices. The approach is implemented by means of JetBrains MPS, a text-based metamodelling framework, and validated using a first migration example from a Java-based application to Jolie — a programming language for defining microservices.

In book: Software Engineering Aspects of Continuous Development and New Paradigms of Software Production and Deployment (pp.15–36)

Read the paper

Andreas Prinz, Alexander Shatalin

Language workbenches are designed to enable the definition of languages using appropriate meta-languages. This makes it feasible to define the environments by themselves, as the meta-languages are also just languages. This approach of defining an environment using itself is called bootstrapping. Often, such bootstrapping is difficult to achieve and has to be built deeply into the environment. The platform Meta-Programming System (MPS) has used bootstrapping for its own definition. In a similar way, the environment LanguageLab is using bootstrapping for its definition. This paper reports the implementation of LanguageLab in MPS, thereby also porting the bootstrapping. From the experiences general requirements for bootstrapping language workbenches are derived.

P. Andreas, A. Shatalin. How to Bootstrap a Language Workbench. 7th International Conference on Model-Driven Engineering and Software Development, 2019.

Read the paper

Markus Voelter, Klaus Birken, Sascha Lisson, Alexander Rimer

Shadow Models is an incremental transformation framework for MPS. The name is motivated by the realization that many analyses are easier to do on a model whose structure is different from what the user edits. To be able to run such analyses interactively in an IDE, these “shadows” of the user-facing model must be maintained in real-time, and incrementality can deliver the needed short response times. Shadow Models is an incremental model transformation engine for MPS. In the paper, we motivate the system through example use cases and outline the transformation framework.

M. Voelter, K. Birken, S. Lisson, A. Rimer. Shadow Models — Incremental Transformations for MPS. SLE 2019 Conference.

Read the paper

Markus Voelter

Modeling, in general, is of course different from programming (think: climate models). However, when we consider the role of models in the context of “model-driven”, i.e., when they are used to construct software automatically, it is much less clear that modeling is different from programming. In this paper, I argue that the two are conceptually indistinguishable, even though in practice they traditionally emphasize different aspects of the (conceptually indistinguishable) common approach. The paper discusses and illustrates language-oriented programming, the approach to {modeling| programming} we have successfully used over the last seven years to build a range of innovative systems in domains such as insurance, healthcare, tax, engineering, and consumer electronics. It relies on domain-specific languages, modular language extension, mixed notations, and in particular, the Jetbrains MPS language workbench.

M. Voelter. Fusing Modeling and Programming into Language-Oriented Programming. ISoLA 2018 Conference — UVMP Track

Read the paper

Markus Voelter, Bernd Kolb, Federico Tomassetti, Patrick Alff, Laurent Wiart, Andreas Wortmann, Arne Nordmann

Language workbenches support the efficient creation, integration, and use of domain-specific languages. Typically, they execute models by code generation to programming language code. This can lead to increased productivity and higher quality. However, in safety-/mission-critical environments, generated code may not be considered trustworthy because of the lack of trust in the generation mechanisms. This makes it harder to justify the use of language workbenches in such an environment. In this paper, we demonstrate an approach to use such tools in critical environments. We argue that models created with domain-specific languages are easier to validate and that the additional risk resulting from the transformation to code can be mitigated by a suitably designed transformation and verification architecture. We validate the approach with an industrial case study from the healthcare domain. We also discuss the degree to which the approach is appropriate for critical software in space, automotive, and robotics systems.

M. Voelter, B. Kolb, F. Tomassetti, P. Alff, L. Wiart, A. Wortmann, A. Nordmann. Using Language Workbenches and Domain-Specific Languages for Safety-Critical Software Development . SOSYM Online, 2018.

Read the paper

Inna Vistbakka, Mikhail Barash, Elena Troubitsyna

Role-Based Access Control (RBAC) is a popular authorization model used to manage resource-access constraints in a wide range of systems. The standard RBAC framework adopts a static, state-independent approach to define the access rights to the system resources. It is often insufficient for correct implementation of the desired functionality and should be augmented with the dynamic, i.e., a state-dependent view on the access control. In this paper, we present a work in progress on creating a domain-specific language and the tool support for modelling and verification of dynamic RBAC. They support a tabular representation of the static RBAC constraints together with the graphical model of the scenarios and enable an automated translation of them into an Event-B model.

I. Vistbakka, M. Barash, E. Troubitsyna. Towards Creating a DSL Facilitating Modelling of Dynamic Access Control in Event-B. ABZ 2018: Abstract State Machines, Alloy, B, TLA, VDM, and Z pp 386–391

Read the paper

Markus Voelter, Bernd Kolb, Tamás Szabó, Daniel Ratiu, Arie van Deursen (SoSyM)

Language workbenches are touted as a promising technology to engineer languages for use in a wide range of domains, from programming to science to business. However, not many real-world case studies exist that evaluate the suitability of language workbench technology for this task. This paper contains such a case study. In particular, we evaluate the development of mbeddr, a collection of integrated languages and language extensions built with the Jetbrains MPS language workbench. mbeddr consists of 81 languages, with their IDE support, 34 of them C extensions. The mbeddr languages use a wide variety of notations—textual, tabular, symbolic and graphical—and the C extensions are modular; new extensions can be added without changing the existing implementation of C. mbeddr’s development has spanned 10 person-years so far, and the tool is used in practice and continues to be developed. This makes mbeddr a meaningful case study of non-trivial size and complexity. The evaluation is centered around five research questions: language modularity, notational freedom and projectional editing, mechanisms for managing complexity, performance and scalability issues and the consequences for the development process. We generally draw positive conclusions; language engineering with MPS is ready for real-world use. However, we also identify a number of areas for improvement in state of the art in language engineering in general, and in MPS in particular.

M. Voelter, B. Kolb, T. Szabo, D. Ratiu, A. van Deursen. Lessons Learned from Developing mbeddr: A Case Study in Language Engineering with MPS. ACM/IEEE 20th International Conference on Model Driven Engineering Languages and Systems (MODELS'17).

Read the paper

Daniel Ratiu, Vaclav Pech, Kolja Dummann

Domain-specific languages (DSLs) bring a substantial increase in productivity and quality and thus look very appealing to software engineering practitioners. Because language workbenches can drastically reduce the cost of building and maintaining DSLs and associated tooling, they catch the attention of technical leads and project managers in the industry. Effective use of language engineering technologies for software development requires specific knowledge about building DSLs in general and about language workbenches in particular. Practicing software engineers need to enrich their skills with a new software development approach and supporting tools. In this paper, we present our experiences with training and coaching software practitioners in the field to develop domain specific languages and tooling by using Jetbrains’ Meta-Programming System. We distill the experience gained in the last three years during 16 trainings which are offered by three organizations. The training were absolved by over 50 developers who belong to different business domains and have a wide variety of technical backgrounds, previous experiences, and concrete needs. We present a set of challenges faced with teaching language engineering technologies in the industry. To address these challenges, we developed a curriculum containing increasingly complex topics and an approach that combines classical trainings with continuous coaching either remote or on site. Based on our experience, we distill a set of lessons learnt about the dissemination of language engineering technologies to practitioners and about the concrete needs which need to be fulfilled to enable their broader adoption in practice.

D. Ratiu, V. Pech, K. Dummann. Experiences with Teaching MPS in Industry — Towards Bringing Domain-Specific Languages Closer to Practitioners. ACM/IEEE 20th International Conference on Model Driven Engineering Languages and Systems (MODELS'17)

Read the paper

Stian Mathias Guttormsen, Andreas Prinz and Terje Gjøsæter

For modelling and domain-specific languages, projectional editors have become popular. These editors implement the MVC pattern and provide a direct connection to the underlying model. In particular, projectional editors allow much more freedom in defining the concrete syntax than traditional grammars. The downside is that it is possible to define presentations that are of bad quality, and that this is not easily visible. In this article, we identify some of the problems with projectional editors and propose ways to resolve them. We also demonstrate a proof-of-concept solution, showing how problematic editor presentations could be identified automatically.

P. Andreas, S. Mathias Guttormsen, T. Gjøsæter. Consistent Projectional Text Editors. MODELSWARD 2017.

Read the paper

Daniel Ratiu, Markus Voelter, Domenik Pavletic

Domain-specific languages promise to improve productivity and quality of software development by providing problem-adequate abstractions to developers. Projectionallanguage workbenches, in turn, allow the definition of modular and extensible domain-specific languages, generators, and development environments. While recent advances in language engineering have enabled the definition of DSLs and tooling in a modular and cost-effective way, the quality assurance of their implementation is still challenging. In this paper, we discuss our work on testing different aspects of the implementation of domain-specific languages and associated tools and present several approaches to increase the automation of language testing. We illustrate these approaches with the Jetbrains MPS language workbench and our experience with testing mbeddr, a set of domain-specific languages and tools on top of C tailored to embedded software development. Based on the experience gained from the mbeddr project, we extract generic lessons for practitioners as well as challenges that need more research.

D. Ratiu, M. Voelter, D. Pavletic. Automated Testing of DSL Implementations — Experiences from Building mbeddr. AST '16: Proceedings of the 11th International Workshop on Automation of Software Test, 2016.

Read the paper

Markus Voelter

Modeling, in general, is of course different from programming (think: climate models). However, when we consider the role of models in the context of “model-driven”, i.e., when they are used to construct software automatically, it is much less clear that modeling is different from programming. In this paper, I argue that the two are conceptually indistinguishable, even though in practice they traditionally emphasize different aspects of the (conceptually indistinguishable) common approach. The paper discusses and illustrates language-oriented programming, the approach to {modeling| programming} we have successfully used over the last seven years to build a range of innovative systems in domains such as insurance, healthcare, tax, engineering, and consumer electronics. It relies on domain-specific languages, modular language extension, mixed notations, and in particular, the Jetbrains MPS language workbench.

M. Voelter. Fusing Modeling and Programming into Language-Oriented Programming. ISoLA 2018 Conference — UVMP Track

Read the paper

Andreas Wortmann, Martin Beet

We present the motivation and an approach for the efficient development of satellite control software (flight software, onboard software) based on domain-specific languages. Significant technological advances in the field of language workbenches have enabled us to develop extensions to the C programming language specific to the needs of satellite flight software. The approach is very promising as it combines the flexibility and efficiency of the C language with high-level abstractions known from modeling tools and allows for additional adaptation specific to the space domain.

A. Wortmann, M. Beet. Domain-Specific Languages for Efficient Satellite Control Software Development. Proc. ‘DASIA 2016’, Data Systems In Aerospace Tallinn, Estonia.

Read the paper

Přemysl Vysoký

JetBrains MPS is a language workbench focusing on domain-specific languages. Unlike many other language workbenches and IDEs, it uses a projectional editor for code. The developer directly manipulates the program in its tree form (AST) and not by editing a text source code. This brings many advantages, but on the other hand, it requires time-consuming and complicated MPS language definition. The thesis elaborates on the possibility of automating the process of creating MPS language definition from its grammar description. It introduces the MPS editor, evaluates approaches of related projects, and describes the author's efforts to implement an MPS plugin that allows this import. The chosen approach and the selection of tools used for implementation are justified in the thesis. We point out important problems that any similar project might deal with, and we introduce some possible solutions. Furthermore, the thesis contains examples of imported languages, showing the potency of the chosen approach. The thesis also aims to lay the groundwork for future extensions and suggest possible improvements.

Read the paper

Jonáš Klimeš

In the scope of this thesis, we designed a language for programming education. At first, we described eight existing tools for learning programming and identified key features in the learning process. Second, we designed an educational domain-specific language, Eddie. Eddie is suitable for teenagers and adults who want to learn to program. It uses a domain based on Karel the Robot language, where users can control a robot character in a two-dimensional grid. We implemented a prototype of Eddie using the MPS Language Workbench and its projectional editor. The Eddie language gradually introduces loops, conditionals, variables, functions, and objects. Eddie programs can be created, executed and visualized in the Eddie Studio IDE.

Read the paper

Source code

Markus Voelter, Tamás Szabó, Sascha Lisson, Bernd Kolb, Sebastian Erdweg and Thorsten Berger

The definition of a projectional editor does not just specify the notation of a language, but also how users interact with the notation. Because of that it is easy to end up with different interaction styles within one and between multiple languages. The resulting inconsistencies have proven to be a major usability problem. To address this problem, we introduce grammar cells, an approach for declaratively specifying textual notations and their interactions for projectional editors. In the paper we motivate the problem, give a formal definition of grammar cells, and define their mapping to low-level editor behaviors. Our evaluation based on project experience shows that grammar cells improve editing experience by providing a consistent and intuitive ``text editor-like'' user experience for textual notations. At the same time they do not limit language composability and the use of non-textual notations, the primary benefits of projectional editors. We have implemented grammar cells for Jetbrains MPS, but they can also be used with other projectional editors.

Read the paper

TDomenik Pavletic, Markus Voelter, Syed Aoun Raza, Bernd Kolb, Timo Kehrer

Language extension enables integration of new language constructs without invasive changes to a base language (e. g., C). Such extensions help to build more reliable software by using proper domain-specific abstractions. Language workbenches significantly reduce the effort for building such extensible languages by synthesizing a fully-fledged IDE from language definitions. However, in contemporary tools, this synthesis does not include interactive debugging for programs written with the base language or its extensions. This paper describes a generic framework for extensible debuggers that enables debugging of the language extensions by defining mappings between the base language and the language extensions. The architecture is designed for extensibility, so debug support for future extensions can be contributed with little effort. We show an implementation of our approach for mbeddr, which is an extensible version of the C programming language. We also discuss the debugger implementation for non-trivial C extensions such as components. Finally, the paper discusses the extent to which the approach can be used with other base languages, debugger backends and language workbenches.

D. Pavletic, M. Voelter, S. Aoun Raza, B. Kolb., T. Kehrer Extensible Debuggers for Extensible Languages, 20th International Conference on Reliable Software Technologies, 2015

Read the paper

Markus Voelter, Arie van Deursen, Bernd Kolb, Stephan Eberle

We report on an industrial case study on developing the embedded software for a smart meter using the C programming language and domain-specific extensions of C such as components, physical units, state machines, registers and interrupts. We find that the extensions help significantly with managing the complexity of the software. They improve testability mainly by supporting hardware-independent testing, as illustrated by low integration efforts. The extensions also do not incur significant overhead regarding memory consumption and performance. Our case study relies on mbeddr, an extensible version of C. mbeddr, in turn, builds on the MPS language workbench which supports modular extension of languages and IDEs.

M. Voelter, A. Van Deursen, B. Kolb, S. Eberle. Using C Language Extensions for Developing Embedded Software. 4th annual conference on Systems, programming, and applications: software for humanity (SPLASH), ACM, 2015

Read the paper

Sebastian Erdweg, Tijs van der Storma, Markus Voelter, Laurence Tratt

Language workbenches are environments for simplifying the creation and use of computer languages. The annual Language Workbench Challenge (LWC) was launched in 2011 to allow the many academic and industrial researchers in this area an opportunity to quantitatively and qualitatively compare their approaches. We first describe all four LWCs to date, before focussing on the approaches used, and results generated, during the third LWC. We give various empirical data for ten approaches from the third LWC. We present a generic feature model within which the approaches can be understood and contrasted. Finally, based on our experiences of the existing LWCs, we propose a number of benchmark problems for future LWCs.

Read the paper

Markus Voelter, Janet Siegmund, Thorsten Berger, Bernd Kolb

Today's challenges for language development include language extension and composition, as well as the use of diverse notations. A promising approach is projectional editing, a technique to directly manipulate the abstract syntax tree of a program, without relying on parsers. Its potential lies in the ability to combine diverse notational styles — such as text, symbols, tables, and graphics — and the support for a wide range of composition techniques. However, projectional editing is often perceived as problematic for developers. Expressed drawbacks include the unfamiliar editing experience and challenges in the integration with existing infrastructure. In this paper we investigate the usability of projectional editors. We systematically identify usability issues resulting from the architecture. We use JetBrains Meta Programming System (MPS) as a case study. The case study discusses the concepts that MPS incorporates to address the identified issues, evaluates the effectiveness of these concepts by surveying professional developers, and reports industrial experiences from realizing large-scale systems. Our results show that the benefits of flexible language composition and diverse notations come at the cost of serious usability issues — which, however, can be effectively mitigated with facilities that emulate the editing experience of parser-based editors.

M. Voelter, J. Siegmund, T. Berger, B. Kolb. Towards User-Friendly Projectional Editors. Proc. of the 7th Intl. Conf. on Software Language Engineering (SLE 2014), 20 pages, 2014

Read the paper

Markus Voelter, Sascha Lisson

To be able to build effective DSLs, these DSLs must not just use language concepts that are aligned with their respective domain, but also use notations that correspond closely to established domain notations — and those are often not purely textual or graphical. The underlying language workbench must support these notations, and combining different notations in a single editor must be supported as well in order to support the coherent definitions of systems that use several DSLs. In this paper we provide an overview over the notations supported by JetBrains MPS. MPS is a language workbench that uses a projectional editor, which, by its very nature, can deal with many different notational styles, including text, prose, math tables and graphics. The various supported notations are illustrated with examples from real-world systems.

M. Voelter, S. Lisson. Supporting Diverse Notations with MPS’ Projectional Editor, 2nd International Workshop on The Globalization of Modeling Languages, MODELS 2014

Read the paper

Federico Tomassetti

In the first part of this dissertation, we study the adoption of modeling and domain-specific languages. On the basis of an industrial survey we individuate a list of benefits attainable through these languages, how frequently they can be reached and which techniques permit to improve the chances to obtain a particular benefit. In the same way we also study the common problems which either prevent or hinder the adoption of these languages. We then analyze the processes through which these languages are employed, studying the relative frequency of the usage of the different techniques and the factors influencing it. Finally, we present two case studies performed in a small and in a very large company, with the intent of presenting the peculiarities of the adoption in different contexts.

Read the paper

IMarkus Voelter, Bernd Kolb, Jos Warmer

We describe two innovations in programming languages: modularity and projectional editing. Language modularity refers to the ability to combine independently developed languages without changing their respective definitions. A language is not anymore a fixed quantity, instead it can be extended with domain-specific constructs as needed. Projectional editing refers to a technique of building editors and IDEs that avoid the need for parsers. They support a wide range of tightly integrated notations including textual, symbolic, tabular and graphical. In addition, by avoiding parsers, the well-known limitations of grammar composition are avoided as well. The article illustrates the consequences of these two innovations for the design of (programming) languages with three examples. First, we discuss a set of modular extensions of C for embedded programming that enables efficient code generation and formal analysis. Second, we discuss a language for requirements engineering that flexibly combines structured and unstructured (prose) data. Third, we illustrate a language for defining insurance rules that makes use of mathematical notations. All examples rely on the open-source JetBrains MPS language workbench.

M. Voelter, B. Kolb, J. Warmer. Projecting a Modular Future. IEEE Software, in press

Read the paper

Manuele Simi, Fabien Campagne

Language WorkBenches (LWBs) are software engineering tools that help domain experts develop solutions to various classes of problems. Some of these tools focus on non-technical users and provide languages to help organize knowledge while other workbenches provide means to create new programming languages. A key advantage of language workbenches is that they support the seamless composition of independently developed languages. This capability is useful when developing programs that can benefit from different levels of abstraction. We reasoned that language workbenches could be useful to develop bioinformatics software solutions. In order to evaluate the potential of language workbenches in bioinformatics, we tested a prominent workbench by developing an alternative to shell scripting. To illustrate what LWBs and Language Composition can bring to bioinformatics, we report on our design and development of NYoSh (Not Your ordinary Shell).

Simi M, Campagne F. (2014) Composable languages for bioinformatics: the NYoSh experiment. PeerJ 2:e241.

Read the paper

qMarkus Voelter, Daniel Ratiu and Federico Tomassetti

Requirements often play a second fiddle in software development projects. The tools for managing requirements often just support ”numbered lists of prose paragraphs,” and they don’t integrate well with the tools used for implementing the system. This leads to all kinds of challenges in terms of versioning and traceability. Moreover, because they are mainly prose text, they cannot easily be checked for consistency and completeness, limiting their usefulness. In this paper we describe an alternative approach, where requirements are (at least partially) formalized to support consistency checking, where parts of requirements can be used directly as the implementation, and where requirements are managed with the same tools that are used for system development. The approach is illustrated with the mbeddr system, a comprehensive IDE for embedded software development based on an extensible version of C and domain-specific languages.

M. Voelter, D. Ratiu and F. Tomassetti. Requirements as First-Class Citizens: Integrating Requirements with Implementation Artifacts. 6th International Workshop on Model-Based Architecting/Construction of Embedded Systems (ACES-MB) 2013, 10 pages, MODELS 2013.

Read the paper

Markus Voelter

In programming and modeling we strive to express structures and behaviors as formally as possible to support tool-based processing. However, some aspects of systems cannot be described in a way that is suitable for tool-based consistency checking and analysis. Examples include code comments, requirements and software design documents. Consequently, they are often out-of-sync with the code and do not reflect the current state of the system. This paper demonstrates how language engineering based on language workbenches can help solve this problem by seamlessly mixing prose and program nodes. These program nodes can range from simple references to other elements over variables and formulas to embedded program fragments. The paper briefly explains the language engineering techniques behind the approach as well as a number of prose-code integrated languages that are part of mbeddr, an integrated language and tool stack for embedded software engineering.

M. Voelter. Integrating Prose as a First-Class Citizen with Models and Code. 7th International Workshop on Multi-Paradigm Modeling (MPM'13), 10 pages, MODELS 2013.

Read the paper

Václav Pech, Alexander Shatalin, Markus Voelter

JetBrains MPS is an integrated environment for language engineering. It allows language designers to define new programming languages, both general-purpose and domain-specific, either as standalone entities or as modular extensions of already existing ones. Since MPS leverages the concept of projectional editing, non-textual and non-parseable syntactic forms are possible, including tables or mathematical symbols. This tool paper introduces MPS and shows how its novel approach can be applied to Java development. Special attention will be paid to the ability to modularize and compose languages.

V. Pech, A. Shatalin, M. Voelter, PPPJ '13 Proceedings of the 2013 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools, Pages 165-168

Read the paper

Markus Voelter, Daniel Ratiu, Bernd Kolb, Bernhard Schätz

Tools can boost software developer productivity, but building custom tools is prohibitively expensive, especially for small organizations. For example, embedded programmers often have to use low-level C with limited IDE support and integrated it into an off-the-shelf toolchain in an ad-hoc way. To address these challenges, we have built mbeddr, an extensible language and IDE for embedded software development based on C. mbeddr is a large-scale instantiation of the Jetbrains MPS language workbench. Exploiting its capabilities for language modularization and composition, projectional editing and multi-stage transformation, mbeddr is an open and modular framework that lets third parties add extensions to C with minimal effort and without invasive changes. End users can combine extensions in programs as needed. To illustrate the approach, in this paper we discuss mbeddr's support for state machines, components, decision tables, requirements tracing, product line variability and program verification and outline their implementation. We also present our experience with building mbeddr, which shows that relying on language workbenches dramatically reduces the effort of building customized, modular and extensible languages and IDEs to the point where this is affordable by small organizations. Finally, we report on the experience of using mbeddr in a commercial project, which illustrates the benefits to end-users.

M. Voelter, D. Ratiu, B. Kolb, B. Schaetz. mbeddr - Instantiating a Language Workbench in the Embedded Systems Domain. Journal of Automated Software Engineering, September 2013, Volume 20, Issue 3, pp 339-390, 51 pages, 2013.

Read the paper

Philipp Zech, Michael Felderer, Matthias Farwick, Ruth Breu

Today’s ongoing trend towards intense usage of web service-based applications in daily business and everybody’s dailylife poses new challenges for security testing. Additionally, such applications mostly do not execute in their own runtime environment but instead are deployed in some data center, run alongside multiple other applications, and serve different purposes for sundry user domains with diverging security requirements. As a consequence, security testing also has to adapt to be able to meet the necessary requirements for each application in its domain and its specific security requirements. In addition, security testing needs to be feasible for both service providers and consumers. In our paper we identify drawbacks of existing security testing approaches and provide directions for meeting emerging challenges in future security testing approaches. We also introduce and describe the idea of language–oriented security testing, a novel testing approach building upon domain–specific languages and domain knowledge to meet future requirements in security testing.

Zech, P., Felderer, M., Farwick, M., & Breu, R. (2013). A concept for language-oriented security testing. In Proceedings — 7th International Conference on Software Security and Reliability Companion, SERE-C 2013 (pp. 53–62). Ieee. doi:10.1109/SERE-C.2013.16

Read the paper

Markus Voelter, Daniel Ratiu, Bernd Kolb, Bernhard Schaetz.

While the C programming language provides very good support for writing efficient, low-level code, it does not offer adequate means for defining higher-level abstractions relevant to embedded software. In this paper we present the mbeddr technology stack that supports extension of C with constructs adequate for embedded systems. In mbeddr, efficient low-level programs can be written using the well-known concepts from C. Higher-level domain-specific abstractions can be seamlessly integrated into C by means of modular language extension regarding syntax, type system, semantics and IDE. In the paper we show how language extension can address the challenges of embedded software development and report on our experience in building these extensions. We show that language workbenches deliver on the promise of significantly reducing the effort of language engineering and the construction of corresponding IDEs. mbeddr is built on top of the JetBrains MPS language workbench. Both MPS and mbeddr are open source software.

M. Voelter, D. Ratiu, B. Kolb, B. Schaetz. mbeddr: an Extensible C-based Programming Language and IDE for Embedded Systems. Proc. of the 3rd annual conference on Systems, programming, and applications: software for humanity (SPLASH), ACM, pp 121-140, 20 pages, 2013

Read the paper

Tomáš Fechtner

The Real-time Specification of Java (RTSJ) is an intention to introduce Java as a language for developing a real-time system. However, the complexity of their development and a non-trivial programming model of RTSJ with its manual memory management often lead to programming errors. To mitigate the development of RTSJ systems, it would be beneficial to provide an internal domain-specific language (DSL) extending the Java language which would allow developing the systems in a more intuitive and safer way. However, it is needed to find a compromise between solution’s power and level of usability, because this two attributes often go against each other. One possible way of DSLs creation concerns the Meta-Programming System (MPS). It allows to develop new domain-specific languages and corresponding projectional editors, enabling different views on code. This thesis proposes a design and implementation of the DSL on the top of the MPS platform and corresponding code generator enabling the development of RTSJ systems. Furthermore, the thesis provides a simple case study to evaluate a proposed DSL. Additionally, the thesis assesses the suitability of MPS as a DSL development platform.

Read the paper

Markus Voelter

JetBrains MPS is an Open Source language workbench. It uses projectional editing, which means that no parser is involved, and textual, tabular and graphical notations are handled with the same approach. As a consequence, it is an ideal language and IDE development environment. This tutorial has three parts: In part one, I will give a very short introduction to projectional editing. Part two provides examples of existing (modular) languages developed with MPS, showcasing the benefits of the tool and its possibilities. In part three, the longest one, I will show how to define languages in MPS, reusing/extending existing language modules. The tutorial will be mostly live demos; only part one will use a small number of slides.

M. Voelter. Language and IDE Modularization and Composition with MPS. International Summer School on Generative and Transformational Techniques in Software Engineering, GTTSE 2011, LNCS 7680, pp 383-430, 47 pages, 2011

Read the paper

Markus Voelter, Eelco Visser

This paper investigates the application of domain-specific languages in product line engineering (PLE). We start by analyzing the limits of expressivity of feature models. Feature models correspond to context-free grammars without recursion, which prevents the expression of multiple instances and references. We then show how domain-specific languages (DSLs) can serve as a middle ground between feature modeling and programming. They can be used in cases where feature models are too limited, while keeping the separation between problem space and solution space provided by feature models. We then categorize useful combinations between configuration with feature model and construction with DSLs and provide an integration of DSLs into the conceptual framework of PLE. Finally we show how use of a consistent, unified formalism for models, code, and configuration can yield important benefits for managing variability and traceability. We illustrate the concepts with several examples from industrial case studies.

Read the paper

Markus Voelter

This paper describes a novel approach to embedded software development. Instead of using a combination of C code and modeling tools, we propose an approach where modeling and programming are unified using projectional language workbenches. These allow the incremental, domain-specific extension of C and seamless integration between the various concerns of an embedded system. The paper does not propose specific extensions to C in the hope that everybody will use them; rather, the paper illustrates the benefits of domain-specific extensions using projectional editors. In the paper we describe the problems with the traditional approach to embedded software development and how the proposed approach can solve them. The main part of the paper describes our modular embedded language, a proof-of-concept implementation of the approach based on JetBrains MPS. We implemented a set of language extensions for embedded programming, such as state machines, tasks, type system extensions as well as a domain-specific language (DSL) for robot control. The language modules are seamlessly integrated, leading to a very efficient way to implement embedded software.

M. Voelter. Embedded Software Development with Projectional Language Workbenches. International Conference on Model Driven Engineering Languages and Systems (MODELS'10).

Read the paper

Markus Voelter

It is often considered a binary decision whether something is domain-specific or not. Consequently, there are domain-specific languages (DSL) and general purpose languages (GPL), there are domain specific and non-domain specific modeling tools, there are domain specific and non-domain specific methodologies etc. In this paper we argue, that domain specificity is not a hard decision but rather one extreme on a continuum. We also argue that many systems can be more efficiently described with a mix of domain-specific and non-domain specific abstractions. This view of the world has consequences for languages, tools and methodologies, specifically the ability to modularize and compose languages. Additionally we outline these consequences and provide an extensive example based on embedded systems.

M. Voelter. Implementing Feature Variability for Models and Code with Projectional Language Workbenches. 2nd International Workshop on Feature-Oriented Software Development (FOSD) 2010, pp 41–48, 8 pages, 2010

Read the paper