Taming Graphical Modeling

Visual models help to understand complex systems. However, with the user interaction paradigms established today, activities such as creating, maintaining or browsing visual models can be very tedious. Valuable engineering time is wasted with archaic activities such as manual placement and routing of nodes and edges. This report presents an approach to enhance productivity by focusing on the pragmatics of model-based design. Our contribution is twofold: First, the concept of meta layout enables the synthesis of different diagrammatic views on graphical models. This modularly employs sophisticated layout algorithms, closing the gap between MDE and graph drawing theory. Second, a view management logic harnesses this auto layout to present customized views on models. These concepts have been implemented in the open source Kiel Integrated Environment for Layout Eclipse Rich Client (KIELER). Two applications---editing and simulation---illustrate how view management helps to increase developer productivity and tame model complexity

Semantics of UML 2.2 State Machines in Rewriting Logic

While the semantics of (labeled) transition systems and the relations between these are well understood. However, the same has not yet been achieved for UML 2.2 state machines. Their many semantics often is defined in terms of labeled transition systems, because the standard document is ambiguous. A formal, modular core semantics for UML 2.2 state machines is given in rewriting logic

Tool Support for System-Theoretic Process Analysis

Hazard analysis techniques such as System-Theoretic Process Analysis (STPA) are used to guarantee the safety of safety-critical systems. Our goal is to improve the tool support for STPA. The preliminary result is the PASTA Visual Studio Code (VSCode) Extension that provides verification checks and diagrams. PASTA uses elkjs to layout the diagrams and Sprotty to draw them. We evaluate PASTA by recreating the ROLFER analysis. In the future we plan to further evaluate whether PASTA improves upon existing tools and to add more features such as reevaluation suggestions, model checking, and support for other risk analysis techniques

Transient View Generation in Eclipse

Graph-based model visualizations can effectively communicate information, but their creation and maintenance require a lot of manual effort and hence reduce productivity. In this report we build on the concept of Model Driven Visualization by presenting a meta model for graphical views and an infrastructure for configurable automatic layout. This enables the transient views approach, in which we efficiently derive and draw graph representations from arbitrary models

Executing Domain-Specific Models in Eclipse: KLEPTO - KIELER leveraging Ptolemy

We present a two-level approach to extend the abstract syntax of domain-specific models with concrete semantics in order to execute such models. First, a light-weight execution infrastructure for executable models with a generic user interface allows the tool smith to provide arbitrary execution and visualisation engine implementations for a Domain-Specific Language (DSL). Second, as a concrete but nevertheless generic implementation of a simulation engine for behaviour models, we present semantic model specifications and a runtime interfacing to the Ptolemy II tool suite as a formally founded backbone for model execution. We present our approach as an open source extension to Eclipse modelling projects

Synchronous Java: Light-Weight, Deterministic Concurrency and Preemption in Java

A key issue in the development of reliable embedded software is the proper handling of reactive controlow, which typically involves concurrency. Java and its thread concept have only limited provisions for implementing deterministic concurrency. Thus, as has been observed in the past, it is challenging to develop concurrent Java programs without any deadlocks or race conditions. To alleviate this situation, the Synchronous Java (SJ) approach presented her adopts the key concepts that have been established in the world of syschronous programming for handling reactive controlow. Thus SJ not only provides deterministic concurrency, but also dierent variants of deterministic preemption. Furthermore SJ allows concurrent threads to communicate with Esterel-style signals. As a case study for an embedded system usage, we also report on how the SJ concepts have been applied in the context of Lego Mindstorms

Language-Driven Engineering An Interdisciplinary Software Development Paradigm

We illustrate how purpose-specific, graphical modeling enables application experts with different levels of expertise to collaboratively design and then produce complex applications using their individual, purpose-specific modeling language. Our illustration includes seven graphical Integrated Modeling Environments (IMEs) that support full code generation, as well as four browser-based applications that were modeled and then fully automatically generated and produced using DIME, our most complex graphical IME. While the seven IMEs were chosen to illustrate the types of languages we support with our Language-Driven Engineering (LDE) approach, the four DIME products were chosen to give an impression of the power of our LDE-generated IMEs. In fact, Equinocs, Springer Nature's future editorial system for proceedings, is also being fully automatically generated and then deployed at their Dordrecht site using a deployment pipeline generated with Rig, one of the IMEs presented. Our technology is open source and the products presented are currently in use.Comment: 43 pages, 30 figure

Assisted-modeling requirements for model-driven development tools

Model-driven development (MDD) tools allow software development teams to increase productivity and decrease software time-to-market. Although several MDD tools have been proposed, they are not commonly adopted by software development practitioners. Some authors have noted MDD tools are poorly adopted due to a lack of user assistance during modeling-related tasks. This has led model-driven engineers—i.e., engineers who create MDD tools—to equip MDD tools with intelligent assistants, wizards for creating models, consistency checkers, and other modeling assistants to address such assist-modeling-related issues. However, is this the way MDD users expect to be assisted during modeling in MDD tools? Therefore, we plan and conduct two focus groups with MDD users. We extract data around three main research questions: i) what are the challenges perceived by MDD users during modeling for later code generation? ii) what are the features of the current modeling assistants that users like/dislike? and iii) what are the user’s needs that are not yet satisfied by the current modeling assistants? As a result, we gather requirements from the MDD users’ perspective on how they would like to be assisted while using MDD tools. We propose an emerging framework for assisting MDD users during modeling based on such requirements. In addition, we outline future challenges and research efforts for next-generation MDD tools

Evolution of ecosystems for Language-Driven Engineering

Language-Driven Engineering (LDE) is a means to model-driven software development by creating Integrated Modeling Environments (IMEs) with Domain/Purpose-Specific Languages (PSLs), each tailored towards a specific aspect of the respective system to be modeled, thereby taking the specific needs of developers and other stakeholders into account. Combined with the powerful potential of full code generation, these IMEs can generate complete executable software applications from descriptive models. As these products themselves may again be IMEs, this approach leads to LDE Ecosystems of modeling environments with meta-level dependencies. This thesis describes new challenges emerging from changes that affect single components, multiple parts or even the whole LDE ecosystem. From a top-down perspective, this thesis discusses the necessary support by language definition technology to ensure that corresponding IMEs can be validated, generated and tested on demand. From a bottom-up perspective, the formulation of change requests, their upwards propagation and generalization is presented. Finally, the imposed cross-project knowledge sharing and transfer is motivated, fostering interdisciplinary teamwork and cooperation. Based on multifaceted contributions to full-blown projects on different meta-levels of an exemplary LDE ecosystem, this thesis presents specific challenges in creating and continuously evolving LDE ecosystems and deduces a concept of PUTD effects to systematically address various dynamics and appropriate actions to manage both product-level requests that propagate upwards in the meta-level hierarchy as well as the downward propagation of changes to ensure product quality and adequate migration of modeled artifacts along the dependency paths. Finally, the effect of language-driven modeling on the increasingly blurred line between building and using software applications is illustrated to emphasize that the distinction between programming and modeling becomes a mere matter of perspective