User Guide

The user guide is written and maintained in inside MPS using mbeddr's documentation language, because this supports close integration with the mbeddr artifacts documented in the user guide. It is available inside MPS as well as online:

Online User Guide: The HTML version of the user guide is available here. This version has been exported from within MPS and has a few shortcomings including the size of some pictures as well as the layout of some of the embedded sources (because of an MPS bug regarding to-text transformation of collection layouts). On the plus side, you can use the small blue arrows associated with example code to directly select the corresponding node in MPS (MPS has to be running, and the tutorial project must be opened for this to work).

User Guide in mbeddr: To open the user guide, open the tutorial project (which ships with the mbeddr distribution) and open the mbeddrUserGuide node. You can do this by opening the node by name (via Ctrl-Shift-N) or by navigating there manually, according to the picture below. Note that you may have to switch to the nicely readable presentation mode via the menu option Code -> Projection Mode -> Presentation Mode.


Overview Material

High-Level Overview: (EN) A PDF (from Powerpoint) describing the overall mbeddr idea, includes a lot of screenshots of example code.

Two-Page Flyer: (EN) A two-page English flyer used at expos and trade fairs.



Generic Tools, Specific Languages Markus' PhD thesis addresses an approach for building domain-specific tools based on language engineering and language workbenches. The main example of the approach is mbeddr. It is covered in detail. [pdf]


Published Papers


Domain-Specific Languages for Efficient Satellite Control Software Development (DASIA 2016, Andreas Wortmann, OHB): 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. [pdf]

Using C Language Extensions for Developing Embedded Software - A Case Study (OOPSLA 2015): This paper is a detailed report on our experience of building the Smart Meter with mbeddr. [pdf]

Modern model-based development approach for embedded systems - Practical Experience (International Symposium on Systems Engineering): This paper is a case study of the use of mbeddr for developing rail/train systems, written by Siemens CT. [pdf]

Preliminary Experience of using mbeddr for Developing Embedded Software (MBEES Workshop, 2014): In this paper we discuss our experience so far with using mbeddr to develop real systems. The paper discusses several different systems, including the Smart Meter project by itemis France. [pdf]

General/Language Engineering

Automated Testing of DSLs Implementations: Experiences from Building mbeddr (Software Quality Journal - SQJ, 2017): We discuss in detail different techniques that we developed and applied for testing domain specific languages and tooling developed with MPS. The main message of this paper is that modern stacks of DSLs need holistic testing of the front-end (e.g. editors, typing rules, constraints), of the back-end (e.g. generators) and of associated tooling (e.g. debuggers, analyzers). We share our experiences and lessons learnt based on the mbeddr technology stack. [pdf]

Lessons Learned from Developing mbeddr - A Case Study in Language Engineering with MPS (Journal on Software and Systems Modeling - SoSyM, 2017): Lessons learnt from developing mbeddr, one of the largest existing eco-systems of domain specific languages. We share our experiences and lessons learnt. [pdf]

Efficient Development of Consistent Projectional Editors using Grammar Cells (Software Language Engineering, 2016): In this paper we provide an overview over the grammar cells and their implementation. The contributions of this paper advance the state-of-the-art in projectional editors by providing a more text-editor like and consistent editor behaviour. The paper addresses the limitations identified in our previous paper 'Towards Usable Projectional Editors'. [pdf]

Interactive Debugging for Extensible Languages in Multi-Stage Transformation Environments (International Workshop on Executable Modeling, co-located with MODELS, 2016): In this paper we present our approach to build extensible domain specific debuggers at different levels of abstraction: directly at the domain level for end-users and at different intermediate levels for language engineers in order to support them with the debugging of model transformations. [pdf]

IncA: A DSL for the Definition of Incremental Program Analyses (Automated Software Engineering, 2016): This paper present the IncA project which is a framework for the definition and efficient execution of incremental program analyses. We used IncA to develop several real-world case studies including control flow and points-to analyses for C, well-formedness checks for DSLs, and FindBugs analyses for Java. Our evaluation based on real-world code bases shows that incrementalization can provide considerable speedups, and it can make even complex analyses feasible to be executed in a real-time fashion in the IDE. [pdf]

An Extensible Framework for Variable-Precision Data-Flow Analyses in MPS (Automated Software Engineering, 2016): This tool paper presents the data-flow support of MPS. It gives details on the modular architecture of the tool and elaborates on the support for inter-procedural analyses. The two key characteristics are variable-precision and extensibility. The former one means that analysis developers can easily trade off precision for runtime performance and/or memory use thus tailoring an analysis to a particular use case. The latter one mean that analyses, similar to languages, are extensible, and making an analysis work on language compositions requires only minimal additional effort. [pdf]

Efficient Development of Consistent Projectional Editors using Grammar Cells (Software Language Engineering, 2016): In this paper we provide an overview over the grammar cells and their implementation. The contributions of this paper advance the state-of-the-art in projectional editors by providing a more text-editor like and consistent editor behaviour. The paper addresses the limitations identified in our previous paper 'Towards Usable Projectional Editors'. [pdf]

Extensible Debuggers for Extensible Languages (Ada-Europe 2015): This is an extension of the paper with the same title published at WSR in 2013. This paper discusses the implementation of the debugger for complex DSLs from the mbeddr stack. [pdf]

Testing Extensible Language Debuggers (International Workshop on Executable Modeling, co-located with MODELS, 2015): This paper presents DeTeL - an extensible domain specific language to test domain specific debuggers. This language is used extensively for testing the mbeddr debugger. [pdf]

Projecting a Modular Future (IEEE Software, 2015): We present two recent innovations in domain specific languages: languages modularity which offers the capability to combine two independently developed languages without changing their definitions and projectional editors which allow the definition and combination of rich notations like textual, graphical, tabular or mathematical. We illustrate how we used these advantages in order to build the mbeddr stack of domain specific languages. [pdf]

Supporting Diverse Notations with MPS' Projectional Editor (GEMOC 2014 Workshop): In this paper we provide an overview over the notations supported by JetBrains MPS, including text, prose, math tables and graphics. The various supported notations are illustrated with examples from real-world systems, most of them are taken from mbeddr. [pdf]

mbeddr: Instantiating a Language Workbench in the Embedded Software Domain (Journal of Automated Software Engineering, 2013): This is our most comprehensive publication so far, providing a detailed look at mbeddr. In contrast to the next paper, it looks at mbeddr more from a tooling perspective (less from language engineering) and also contains some preliminary experience of using mbeddr. [pdf]

mbeddr: an Extensible C-based Programming Language and IDE for Embedded Systems (SplashCON/Wavefront 2012): This paper provides a general overview over mbeddr, emphasizing the language engineering perspective. It details some of the challenges for embedded software development, and how mbeddr addresses them. [pdf]

Extensible Debuggers for Extensible Languages (WSR 2013 Workshop): Language workbenches significantly reduce the effort for building extensible languages. However, they do not facilitate programmers with built-in debugging support for language extensions. This paper presents an extensible debugger architecture that enables debugging of language extensions. This is established by defining mappings between the base language and the language extensions. We show an implementation of our approach for the mbeddr language workbench. [pdf]

Extracting variability from C and lifting it to mbeddr (REVE 2013 Workshop): In this paper we describe approaches for lifting textual C code into mbeddr, understanding product-line variability expressed with preprocessor statements and factoring it into mbeddr's feature models. [pdf]

Requirements as First-Class Citizens (MBEES 2013 Workshop): In this paper we discuss mbeddr's approach to requirements engineering including: requirements themselves, paritial formalization of requirements using DSLs embedded in requirements, CRC-card-like high-level architectures and tracing from implementation artifacts to requirements and other "trace targets". [pdf, bib]


Increasing Usability of Spin-based C Code Verification Using a Harness Definition Language (24th International SPIN Symposium on Model Checking of Software): This paper describes the integration of the Spin model checker in mbeddr and shows how do DSLs from mbeddr increase the usability of the verification of C-code (approach known as 'model driven code checking'). [pdf]

On Using Results of Code-level Bounded Model Checking in Assurance Cases (4th International Workshop on Assurance Cases for Software-intensive Systems): This paper describes our preliminary experience with using the CBMC model checker and the mbeddr environment to verify three safety-critical software components. [pdf]

Safety.Lab: Model-based Domain Specific Tooling for Safety Argumentation (3rd International Workshop on Assurance Cases for Software-intensive Systems): This paper describes a set of DSLs for safety analysis, integrated with mbeddr, built by Siemens CT. [pdf]

Verification-Cases: Characterizing the Completeness Degree of Incomplete Verification for C Programs (Verification and Assurance Workshop): This paper introduces the notion of Verification Cases as a means to make explicit the incomplete parts of verification. [pdf]

mbeddr - Extensible languages for embedded software development (HILT 2014): This paper is an overview of the mbeddr features and toolset mainly focusing on the applications for safety-critical domains. It points out how the various extensible modules could be used to create high-integrity and robust systems. [pdf]

Automated Domain-Specific C Verification with mbeddr (ASE 2014): This is the definitive paper on integrating C-level verification tools into mbeddr in a user-friendly way. It contains examples from the Pacemaker Challenge. [pdf]

Using Language Engineering to Lift Languages and Analyses at the Domain Level (NASA Formal Methods Symposium 2013): In this paper we discuss how we integrate the static checking of pre- and postconditions as well as protocol checking (based on C-level model checking) into mbeddr. [pdf, bib]

Language Engineering as an Enabler for Incrementally Defined Formal Analyses (FORMSERA 2012 Workshop): In this paper we discuss our approach for integrating formal verification into the development process. The approach relies on using language extension to provide meaningful abstractions directly in the language, avoiding the need to "reverse engineer" the semsntics from low-level implementation code. We show two examples for formal verification in mbeddr. [pdf]

Implementing Modular Domain Specific Languages and Analyses (accepted at Modevva 2012 Workshop; Best Paper and Best Presentation Awards): In this paper we discuss how language engineering makes the implementation of formal analyses simpler by reusing the same core language in several DSLs. By hooking the verification onto the single core language, we can get verification support for several DSLs with very limited effort. [pdf, bib]


Towards Usable Projectional Editors (SLE 2014): In this paper we discuss how MPS has improved the usability of the projectional editor over the last few years. This is obviously very relevant to (prospective) mbeddr users as well. The paper includes a survey of ca. 20 MPS/mbeddr users. [pdf]


Case Studies

This section collects (over time) a set of example applications developed with mbeddr as a means to illustrate its capabilities.

ASIC Testing: This case study describes how Daniel Stieger from die modellwerkstatt and Michael Gau from Bachmann electronics built a DSL and a C generator for testing ASICs. [pdf]

SmartMeter: This case study describes a real-world commercial development project for a Smart Meter application. It runs on a custom processor, requires a different compiler, makes use of several of the mbeddr default extensions and also uses a set of project-specific language extensions. [pdf]

Lego Mindstorms This case study is the original demo we built with mbeddr. Although a Lego Mindstorms robot seems like a joke, the case study used the OSEK operating system and contains interesting C extensions for OSEK. [pdf]


Other Publications

In this section we list other publications, typically contributed to online or print magazines.

mbeddr: Embedded-Entwicklung mit erweiterbarem C (ElektronikPRAXIS) Ein deutschsprachiger Überblick über mbeddr.

Sprachschöpfer: (bei heise developer) Noch ein deutschsprachiger Überblick über mbeddr.

mbeddr C: (at InfoQ) This is a recording of a presentation from the Code Generation 2012 conference in cambridge, providing an overview over mbeddr.


MPS Documentation

Since mbeddr relies on JetBrains MPS for the language engineering, learning about MPS itself is also useful for those people who want to extend mbeddr with their own languages. The MPS documentation page contains an extensive list of links to various documentation artifacts. Not all of them are up to date. Hence we refer to a few specific ones below:

The Shapes tutorial explains how to build a simple language in under two hours. It is a good first contact with MPS language engineering.

Fabien Campagne's book on MPS is now available on Google Play Books. It is a comprehensive introduction to the MPS language workbench.

Markus Voelter's book on DSL Engineering contains a detailed discussion of the concepts behind MPS in its Part III on language implementation. It is less detailed than Fabien's book, but also covers advanced aspects such as language modularization and composition.