1. Andreas Prinz
Multi-level Language Descriptions
Abstract: Language descriptions are a multi-level issue. In particular, the de nition and handling of instantiation semantics connects three lev- els. This paper looks at two language workbenches without support for multi-level modelling and their handling of the multi-level part of lan- guage descriptions. From these observations, the importance of runtime instantiation in terms of an underlying machine is established.
2. Andreas Wortmann, Martin Beet
DOMAIN SPECIFIC LANGUAGES FOR EFFICIENT SATELLITE CONTROL SOFTWARE DEVELOPMENT
Conference paper - PDF
Proc. ‘DASIA 2016’, DAta Systems In Aerospace Tallinn, Estonia, 10-12 May 2016 (ESA SP-736, August 2016)
3. Jonáš Klimeš
Domain-Specific Language for Learning Programming
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 programming. 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.
1. S. Erdweg, T. van der Storma, M. Völter, L. Tratt et al.
Evaluating and Comparing Language Workbenches - Existing Results and Benchmarks for the Future
Journal paper - PDF
Abstract: Language workbenches are environments for simplifying the creation and use of com- puter 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.
2. M. Voelter, A. van Deursen, B. Kolb, S. Eberle
Using C Language Extensions for Developing Embedded Software - A Case Study
Conference paper - PDF
Abstract: 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.
3. D. Pavletic, M. Voelter, S. A. Raza, B. Kolb, T Kehrer
Extensible Debuggers for Extensible Languages (Ada Europe 2015)
Conference paper - PDF
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 definig 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.
1. M. Voelter, J. Siegmund, T. Berger, B. Kolb.
Towards User-Friendly Projectional Editors
Conference paper - PDF
Abstract: 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 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 editing experience of parser-based editors.
Citation: 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
2. M. Voelter, S. Lisson.
Supporting Diverse Notations with MPS’ Projectional Editor
Workshop paper - PDF
Abstract: 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.
Citation: M. Voelter, S. Lisson. Supporting Diverse Notations with MPS’ Projectional Editor, 2nd International Workshop on The Globalization of Modeling Languages, MODELS 2014
3. Markus Voelter
Generic Tools, Specific Languages
PhD thesis - http://voelter.de/books/
Abstract: Generic Tools, Specific Languages (GTSL) is an approach for developing tools and applications in a way that supports easier and more meaningful adaptation to specific domains. To achieve this goal, GTSL generalizes programming language IDEs to domains traditionally not addressed by languages and IDEs. At its core, GTSL represents applications as documents/programs/models expressed with suitable languages. Application functionality is provided through an IDE that is aware of the languages and their semantics. The IDE provides editing support, and also directly integrates domain-specific analyses and execution services. Applications and their languages can be adapted to increasingly specific domains using language engineering; this includes developing incremental extensions to existing languages or creating additional, tightly integrated languages. Language workbenches act as the foundation on which such applications are built.
4. Fabien Campagne
The MPS Language Workbench, Volume I
Book - http://books.campagnelab.org
Abstract: The MPS Language Workbench, Volume I. The first volume of the series is both a simple introduction to the JetBrains MPS language workbench and a complete reference manual.
Citation: Fabien Campagne. The MPS Language Workbench, Volume I. March 2014.
5. Federico Tomassetti
Polyglot software development
Abstract: 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 study also 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.
6. M. Voelter, B. Kolb, J. Warmer
Projecting a Modular Future
Journal paper - PDF
Abstract: 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.
Citation: M. Voelter, B. Kolb, J. Warmer. Projecting a Modular Future. IEEE Software, in press
1. Manuele Simi, Fabien Campagne
Composable languages for bioinformatics: the NYoSh experiment
Paper - PDF
Abstract: 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).
Citation: Simi M, Campagne F. (2014) Composable languages for bioinformatics: the NYoSh experiment. PeerJ 2:e241 http://dx.doi.org/10.7717/peerj.241
2. M. Voelter, D. Ratiu and F. Tomassetti
Requirements as First-Class Citizens: Integrating Requirements with Implementation Artifacts
Workshop paper - PDF
Abstract: Requirements often play second ﬁddle 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-speciﬁc languages.
Citation: 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
3. M. Voelter
Integrating Prose as a First-Class Citizen with Models and Code
Workshop paper - PDF
Abstract: 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.
Citation: 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
4. Václav Pech, Alexander Shatalin, Markus Voelter
JetBrains MPS as a Tool for Extending Java
Abstract: 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.
Citation: 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
5. M. Voelter, D. Ratiu, B. Kolb, B. Schaetz, mbeddr
Instantiating a Language Workbench in the Embedded Systems Domain
Journal paper - PDF
Abstract: 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 into an off-the-shelf tool chain 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.
Citation: 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
6. M. Voelter
Abstract: The book provides a thorough read on the subject, introducing the reader into the core aspects of DSL design and implementation. It explains the fundamental principles of using DSLs as part of modern development cycle showcasing JetBrains MPS as one of the tools that aim to make DSL development approachable.
7. Philipp Zech, Michael Felderer, Matthias Farwick, Ruth Breu
A Concept for Language--oriented Security Testing
Citation: 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
8. M. Voelter, D. Ratiu, B. Kolb, B. Schaetz.
mbeddr: an Extensible C-based Programming Language and IDE for Embedded Systems
Conference paper - PDF
Abstract: 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.
Citation: 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
1. Tomáš Fechtner
MPS-based Domain-specific Languages for real time Java development
Diploma thesis - PDF
Abstract: The Real-time Specification of Java (RTSJ) is an intention to introduce Java as a language for developing 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 to develop the systems in more intuitive and safer way. However, it is needed to find compromise between solution’s power and level of usability, because this two attributes go often 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 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.
2. M. Voelter.
Language and IDE Modularization and Composition with MPS
Conference paper - PDF
Abstract: 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.
Citation: 5. 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
3. Markus Voelter, Eelco Visser.
Product Line Engineering with Projectional Language Workbenches
Paper - PDF
Abstract: This paper investigates the application of domainspecific 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.
4. Markus Voelter
Embedded Software Development with Projectional Language Workbenches
Paper - PDF
Abstract: 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 is unified using projectional language workbenches. These allow the incremental, domain-specific extension of C and a 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 extension 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 for implementing embedded software.
5. M. Voelter
Implementing Feature Variability for Models and Code with Projectional Language Workbenches
Workshop paper - PDF
Abstract: 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.
Citation: 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
Submit new article proposals
Have you read a new article about MPS? Have you written one? Let us know so we could add it to this list.