Oliver Kautz

Systematic Language Extension Mechanisms for the MontiArc Architecture Description Language

Architecture description languages (ADLs) combine the benefits of component-based software engineering and model-driven development. Extending an ADL to domain-specific requirements is a major challenge for its successful application. Most ADLs focus on fixed features and do not consider domain-specific language extension. ADLs focusing on extensibility focus on syntactic augmentation only and neither consider semantics, nor the ADL’s tooling. We present a systematic extension method for the MontiArc component and connector ADL that enables extending its syntax and infrastructure. The MontiArc ADL is built on top of the MontiCore workbench for compositional modeling languages and leverages its powerful language integration facilities. Based on these, we conceived systematic extension activities and present their application to customizing MontiArc for three different domains. This application of software language engineering to ADLs reduces effort for their extension and the presented method guides developers in applying it to their domain. This ultimately fosters the application of ADLs to real-world domain-specific challenges.

Modeling language variability with reusable language components

Proliferation of modeling languages has produced a great variety of similar languages whose individual maintenance is challenging and costly. Reusing the syntax and semantics of modeling languages and their heterogeneous constituents, however, is rarely systematic. Current research on modeling language reuse focuses on reusing abstract syntax in form of metamodel parts. Systematic reuse of static and dynamic semantics is yet to be achieved. We present an approach to compose syntax and semantics of independently developed modeling languages through language product lines and derive new stand-alone language products. Using the MontiCore language workbench, we implemented a mechanism to compose language syntaxes and the realization of their semantics in form of template-based code generators according to language product line configurations. Leveraging variability of product lines greatly facilitates reusing modeling language and alleviates their proliferation.

Retrofitting Type-safe Interfaces into Template-based Code Generators

Model-driven development leverages transformations to produce general-purpose programming language artifacts. Model-to-text (M2T) transformations facilitate ad-hoc transformation development by requiring less preparation than model-to-model transformations. Employing template engines is common for M2T transformations. However, the M2T transformation artifacts (templates) rarely provide interfaces to support their black-box integration. Instead, composing templates requires in-depth expertise of their internals to identify and pass the required arguments. This complicates their reuse, and, hence, code generator development. Where switching to more expressive template engines is not feasible, conceiving templates as models can alleviate these challenges. We present a method to retrofit type-safe signatures into templates, generate typed interfaces from these, and show how this can be utilized to compose independently developed templates for more efficient code generator engineering.

Semantic Differencing for Message-Driven Component & Connector Architectures

Stepwise refinement is a development methodology in which software components progressively evolve under strict adherence of proven properties. This requires means to check whether a new version of a component – with potentially different interface and behavior implementation – refines the behavior of its predecessor. Where architecture description languages (ADLs) support refinement checking, the complexity of their semantic domain requires (partially) manual proving to establish refinement between component versions. We identified a subset of the FOCUS semantics for describing distributed systems as stream processing functions that is powerful enough to model complex and realistic systems, yet sufficiently powerful to support fully automated refinement checking. Leveraging this, we present a refinement checking method for ADLs yielding semantics that can be expressed as stream processing functions. This method relies on transforming architectures into composed port automata and translating these to Buchi automata prior to proving refinement using RABIT for language inclusion checking. This method enables to compare the behaviors of component versions with minimal effort, yields witnesses for non-refining component pairs, and, thus, ultimately facilitates stepwise component refinement.

On Computing Instructions to Repair Failed Model Refinements

A model refinement step is the process of removing underspecification from a model by applying syntactic changes such that the transformed models semantics is subsumed by the semantics of the original model. Performing a refinement step is error-prone and thus needs automated and meaningful support for repair in case an intended refinement step yields an incorrect result. This paper introduces sufficient conditions on a modeling language that enable fully automatic calculation of syntactic changes, which transform one model to a refinement of another model. In contrast to previous work, this papers approach is independent of a concrete modeling language, computes shortest syntactic changes to maintain the developers intention behind the model as much as possible, and does not assume availability of powerful model composition operators. The method relies on partitioning the syntactic change operations applicable to each model in equivalence classes and on excluding syntactic changes that are not part of shortest changes leading to a refining model. This paper contains formal proofs for the modeling language independent results and shows the methods applicability and usefulness by instantiating the framework with three modeling languages. The results provide a language independent and fully automated method to repair refinement steps under intuitive assumptions as well as language independent foundational insights concerning the relation between syntactic changes and the impact of their application on a models semantics.

Achievements, Failures, and the Future of Model-Based Software Engineering

Model-based software engineering (MBSE) is used in research and industry for quite a while. After three decades of improving modeling techniques, concepts, and explicit modeling languages as well as understanding the usability and failures of modeling in development projects, this chapter summarizes the principal obstacles, achievements, and failures of MBSE projects from a personal perspective. We consider the use of MBSE as a failure in a development project, if the methodology fails to meet its goals with respect to the particular project. For example, some reasons for failures are as follows: developers initially decide not to use models (negative cost/benefit analysis), decrease in productivity (increase in development time), or decrease in software quality (e.g., decrease in maintainability, understandability, or performance). On the contrary, the use of MBSE in a development project is an achievement, if it succeeds to accomplish all desired goals with respect to the particular project. Besides the aspects mentioned above, this could also be increased analyzability of the system under development due to the introduced high-level abstraction of models.

Retrofitting Controlled Dynamic Reconfiguration into the Architecture Description Language MontiArcAutomaton

Component & connector architecture description languages (C&C ADLs) provide hierarchical decomposition of system functionality into components and their interaction. Most ADLs fix interaction configurations at design time while some express dynamic reconfiguration of components to adapt to runtime changes. Implementing dynamic reconfiguration in a static C&C ADL by encoding it into component behavior creates implicit dependencies between components and forfeits the abstraction of behavior paramount to C&C models. We developed a mechanism for retrofitting dynamic reconfiguration into the static C&C ADL MontiArcAutomaton. This mechanism lifts reconfiguration to an architecture concern and allows to preserve encapsulation and abstraction of C&C ADLs. Our approach enables efficient retrofitting by a smooth integration of reconfiguration semantics and encapsulation. The new dynamic C&C ADL is fully backwards compatible and well-formedness of configurations can be statically checked at design time. Our work provides dynamic reconfiguration for the C&C ADL MontiArcAutomaton.

Model-driven separation of concerns for service robotics

Robotics currently adopts model-driven engineering focusing software modeling languages. This forces domain experts to employ these languages instead of enabling application of more appropriate DSLs. This ultimately produces monolithic, hardly reusable applications. We present an infrastructure for the development of service robotics applications employing DSLs aimed at domain experts and tailored to domain challenges. It facilitates separation of concerns of participating robotics, domain, and software engineering experts and integrates their models via a component & connector reference architecture and a combined code generation framework. The infrastructure was successfully deployed and evaluated with robotics manufacturers, caregivers, and software engineers in a German hospital. We believe that model-driven engineering with languages tailored to the various stakeholders’ needs can greatly facilitate robotic application engineering.