Thursday, 19th of April.
8:30 - 9:00: Registration.
9:00 - 9:15: Welcome message.
9:15 - 10:15:
10:15 - 10:45: Coffee break.
10:45 - 10:30:
At the Dutch Tax and Customs Administration, we use controlled natural language for the specification of legislation. This language aims to be both intuitively clear and formally precise. The former, so that legal people can write and validate the specifications, and the latter, so that the specification can be formally analysed and used as a basis for code generation. To help in validating the specifications we use example cases, interpret the application of rules on these cases, and show feedback to the user that helps to explain the meaning of the rules. We will show how the interpretation of specifications can be explained to users using trace information.
11:30 - 12:00:
Modern computed tomography (CT) scanners are highly complex and flexible devices. This versatility is realized by a multitude of interconnected parameters and rules which are defined by domain experts. The result is a so-called scanner model specification distributed over almost a hundred documents. The primarily used tools to write these documents (e.g. MS Word, MS Excel) are not dedicated to capture the semantics of the CT scanner domain. Consequently, maintaining a valid scanner model is a tedious and error-prone and therefore expensive process. To counteract this pain, we introduced a model driven approach, with which we benefit from a higher level of abstraction and more automation. At the same time we increase the quality with modeling guidance and advanced consistency checks. In the talk I will present our ongoing work of the last two years in which we address above mentioned problems by developing and deploying an eco-system of domain specific languages (DSLs), covering a central portion of the CT scanner domain. The languages are developed using the Jetbrains' Meta Programming System with Itemis’ mbeddr framework plugins. I present the language architecture, the design and development process that led us there, and our approach towards quality assurance, which includes continuous integration for both, the DSLs as well as the scanner models designed by domain experts. I conclude with some best practices and lessons learned and give an outlook of a set of topics that require further research.
12:00 - 12:30:
Arne Norman: (Semi-Automatic) Safety Analysis and Optimization (VIDEO)
The complexity and performance demands of safety-critical systems within the automotive domain are continuously increasing. At the same time, safety standards like the ISO 26262 require labor-intensive analysis methods like the Fault Tree Analysis (FTA) and Failure Mode and Effects Analysis (FMEA). Currently, these time-consuming analysis methods are mainly performed manually without much systematic reuse of previously analyzed artifacts and without a traceable link to the system model. In this presentation, we introduce our Semi-Automatic Safety And Optimization (SASAO) methodology. The functional or technical system model is extended by fault propagation information using known approaches like component fault trees (CFT). From this, the FTA and FMEA of the entire system can be derived automatically. Based on the safety analysis, a model-based safety optimization step can further optimize the architecture (in terms of costs, reliability etc.) by applying a reusable set of design patterns, which are often described as model transformations. As part of a model-driven development, SASAO increases the degree of automation and shortens the development time. The SASAO methodology is evaluated in a prototypical tool based on JetBrain’s Meta Programming System, which we deemed a perfect fit for exploration of this method. We equipped MPS with a set of languages to describe automotive architectures with safety attributes, code generators, and integration with third-party (and certified) analysis tools.
12:30 - 13:30: Lunch
13:30 - 14:00:
Norman Köster: A Model-Driven Approach for Eased Knowledge Storage and Retrieval in Interactive HRI Systems (SLIDES)
Efficient storage and querying of long-term human-robot interaction data require application developers to have an in-depth understanding of the involved domains. It is an error-prone task that can immensely impact the interaction experience of humans with robots and artificial agents. In the development cycle of HRI applications, queries towards storage solutions are often created once, copied into according components, and are rarely revisited. Beyond possible syntactical errors (especially impacting query design time), any change in the underlying storage solution structure results in semantic errors at runtime which are not easy to spot in existing applications. To address this issue, we present a model-driven software development approach to create a long-term storage system to be used in highly interactive HRI scenarios. We created multiple domain-specific languages that allow us to model the domain and seamlessly embed its concepts into a query language. Along with corresponding model-to-model and model-to-text transformations, we generate a fully integrated workbench facilitating data storage and retrieval. It supports developers in the query design process and allows in-tool query execution without the need to have prior in-depth knowledge of the domain. We evaluated our work in an extensive user study and can show that the generated tool yields multiple advantages compared to the usual query design approach.
14:00 - 14:30:
Workday offers an enterprise cloud suite of financial and human capital management applications. These are built by a few thousand application developers, who define data models, business logic, and APIs in a web-based metadata programming language called XpressO (XO). We are working on a successor to XO, called YP, including an MPS-based IDE and various DSLs. With 10+ years of XO code, we focus heavily on interoperation and a migration path from old to new. I’ll talk about where we started, what we’re building, how it’s going, and the road ahead towards thousands of Workday application developers developing in the YP platform, powered by MPS.
14:30 - 14:45:
In this talk, I will discuss my experience with developing and teaching a course on domain-specific languages [ http://dsl-course.org ]. The course has been given at three universities (Åbo/Finland, Bergen/Norway, Queen's/Canada) to groups of students both with and without background on model-driven software development. A substantial part of the course was devoted to language implementation with JetBrains MPS. I will talk about students' feedback on MPS' projectional editor and their comments on "development workflow" in MPS. I will also reflect on how teaching both parsing-based and projectional language workbenches in the same course helped students grasp fundamental ideas behind MPS.
14:45 - 15:15: Coffee break.
15:15 - 16:15:
The MPS team will prepare a talk covering a variety of different topics, from technical stuff to some marketing insights. During the talk, we will show what we are doing to improve the product and our plans for the future. This will be your opportunity to ask any questions you have directly to the MPS team.
16:15 - 17:00: Networking.
Friday, 20th of April:
9:00 - 9:30:
Daniel Ratiu: Enable Domain Experts Use their Language! – Developing and Deploying Domain Specific Languages and Tooling with MPS Inside Siemens: Challenges, Successes, and Future Prospects (VIDEO)
Complex products are developed by big teams of domain experts. Many such teams are working with generic tooling, evolved over the years, with weakly structured content like spreadsheets or diagrams-based modeling mostly used for documentation. These tools can only be weakly customized and are unable to deal with the business domain complexity -- their users are held captured and simply miss opportunities to increase the automation and quality or even to explore innovative approaches. Domain experts got used along the years with this situation, which is unsatisfactory but assumed to be a given fact, and think that the development of modern semantically rich domain specific tooling to address their concerns is prohibitively expensive. They are of course wrong! In this talk, I will present our work to disseminate, develop and deploy MPS-based DSLs and tooling inside Siemens. Based on the experienced from the last four years I will present lessons learned and discuss how MPS can be further used in future to leverage the deep knowledge of domain experts.
9:30 - 10:00:
The mbeddr Platform interpreter framework is an MPS language for implementing interpreters for *your* MPS language. Implement your logic in BaseLanguage, tightly integrated with your typesystem and structure. The framework supports type guards, conditional evaluators, recursive evaluation, method calls, and stack frames. It's heavily used in several real-world projects, and proved to be modular, composable, and well-documented. This talk will focus on live demos of the interpreter in different scenarios, and how to implement your own interpreter. We will present an outlook on future developments, like creating a regular language aspect for interpreters and integrating the interpreter with GraalVM / Truffle for compile-like performance.
10:00 - 10:30:
Blockly is a JS library that allows to create block-based languages with a drag and drop interface running in the browser. The drag and drop interface is very accessible for beginners, but may limit more advanced users. We use MPS to experiment with a more keyboard-oriented implementation of Blockly which offers a more advanced development experience than the original implementation.
10:30 - 10:45:
Federico Tomassetti: A few ideas on tools support: simulators, debuggers, and templates (VIDEO)
Tools support is crucial for the success of a DSL. After all users benefits of DSLs through tools: tools to debug DSLs, generate code or documentation from DSLs, interpret DSLs, and so on. In this quick talk we are going to see three ideas of tools which made clients happy and show how flexible MPS can be.
10:45 - 11:15: Coffee break.
11:15 - 11:45:
Kemal Soysal: Continuous Integration with MPS and Maven (VIDEO)
11:45 - 12:00:
Andreas Wortmann: Overview of MPS in OHB System AG (VIDEO)
OHB System AG is a German satellite manufacturer with a software department. Why do we think MPS might be of interest for us in the future? Is it possible to introduce a new tool and in an established conservative environment?
12:00 - 12:30:
Sanjit Kumar, Jan Richter, and Dinesh Kumar Rajamani: Simcenter Embedded Software Designer (VIDEO)
Cars are more and more becoming computers on wheels managing user’s entertainment, connection to infrastructure and other vehicles, and ultimately the driving itself. Conflicting targets such as safety and security critical functions, mass-customization, and shorter development cycles require manufacturers to apply new approaches to software development. Their implementation requires new software tools to complement and replace the established ones. Simcenter Embedded Software Designer (ESD) built on JetBrains MPS puts forward the approach of integrated Model-Based Software Engineering. Simcenter ESD is designed to create a digital model continuity and to close the gaps between architecture modeling, platform modeling, implementation, and verification/validation. We leverage the projectional editing capabilities of MPS to allow the users to model in textual, graphical and in different architectural projectional modes. Model transformation of MPS plays a key role in the implementation and verification/validation phase of Simcenter ESD. We make use of the MPS's inbuilt web server to expose the required functionality from the Simcenter ESD. The customizability (branding, RCP etc.) of MPS is leveraged to the maximum extent to adapt the Siemens brand and to provide ease of use. The version control integration from MPS is leveraged for model management. MPS IDE features like auto-completion, correct by construction etc. helps us to increase the productivity of Simcenter ESD users.
12:30 - 13:30: Lunch
13:30 - 14:00:
Felix Vollmer: Domain Specific Language for Factor Graphs
Factor graphs are a graphical tool to visualize the factorization of a function. In the context of probabilistic graphical models, it can be used to model conditional independence statements and thus form the basis for efficient inference algorithms based on message passing. A wide range of algorithms ranging from signal processing, communications, machine learning, and control can be efficiently expressed in this framework leading to new and even cross-domain algorithms. By introducing a domain specific language for factor graphs, users from different domains can easily express their algorithms in a variety of ways without having to implement all mathematical details by hand. Apart from directly editing the factor graph, various other forms of graphical models such as Baysian networks or Markov random fields form a subclass of factor graphs and may thus be introduced as alternative means of modeling. The projectional nature of JetBrains MPS editors allows textual and graphical notations to make development easy and user friendly for the end user. Checking rules on the factor graph allow verification of the user input while editing. The code generation to C, based on the mbeddr framework, enables deployment to almost any target platform. In this presentation, we will discuss the concept and aims of the factor graph DSL and illustrate the current state of the proof of concept implementation.
14:00 - 14:45:
DTCA is one of the largest government organizations in the Netherlands. It is responsible for implementation of 50 laws and is servicing over 10 million citizens. The largest custom build applications are developed in COBOL, CoolGen and Java. Legal policies are hard coded in these legacy systems and mostly forgotten. Our vision is to derive specifications directly from the legal documents, thus maintaining traceability to the source. DTCA believes that controlled natural languages should be used for creating the specifications of their systems. JetBrains MPS enables DTCA to develop DSL’s to create and test their specifications and generate our applications from it.
14:45 - 15:15: Coffee break.
15:15 - 15:30:
Daniel Stieger: Modelling Business Applications with MPS (VIDEO)
Business application development covers various problem domains, like data persistence, business logic handling, and user interface design. A single DSL is not sufficient to achieve productivity and quality gains, nor are multiple DSLs that are not neatly integrated with each other. Only a holistic approach, where several DSLs can be used seamlessly to model solutions for the different problem domains, can bring significant improvements in development. Our company - modellwerkstatt.org - provides 3 languages that are tightly integrated: (1) manmap is used to describe object-relational mappings providing concepts like "Entity" and "Mapping", (2) objectflow is capable of structuring business logic and providing controllers while (3) dataux describes data user interfaces in a rather concise way. We will showcase a typical application and some concepts used to work within the problem domains.
15:30 - 16:15:
Océ is a more than hundred-year-old company and a global leader in digital imaging, industrial printing, and collaborative business services. To better, faster, and cheaper design and understand our systems, we have a long history of modeling across all disciplines and departments. The majority in management as well as on the work floor does not need to be convinced by the added value of modeling and its need for our innovative potential. Having various types of models within various disciplines and departments, our current challenge is for the majority of the developers to be able to create, (re-)use, connect, and maintain models, because we believe that the human component in our modeling ecosystem is crucial and those connecting models yield exponential added value. Within the software departments, we use MPS in a number of cases to tackle that challenge. In this talk, we will show you a few examples.
16:15 - 16:45:
Workday has a rapidly growing MPS codebase with many developers working on shared projects. Pull requests are our primary means of collecting team feedback and iterating on features. When paired with traditional source code, pull requests intuitively allow their participants to place comments in the context of a line-by-line diff. However, when paired with MPS sources, it is a time-consuming and manual process to correlate comments with particular nodes of interest in MPS. In order to improve this experience, we've created a code review plugin that focuses on pull request interactions. By leveraging conditional editors and custom UI components, it allows developers to view and exchange feedback within MPS's projectional editor. Comments authored with the plugin are automatically published to the relevant pull request along with metadata that retains the intended MPS node context. These metadata-adorned comments are then used to populate the in-IDE comments for other developers participating in the same pull request.
16:15 - 16:30: Closing message