Pedram Mir Seyed Nazari

First-class variability modeling in Matlab/Simulink

Modern cars exist in an vast number of variants. Thus, variability has to be dealt with in all phases of the development process, in particular during model-based development of software-intensive functionality using Matlab/Simulink. Currently, variability is often encoded within a functional model leading to so called 150%-models which easily become very complex and do not scale for larger product lines. To counter these problems, we propose a modular variability modeling approach for Matlab/Simulink based on the concept of delta modeling [8, 9, 24]. A functional variant is described by a delta encapsulating a set of modifications. A sequence of deltas can be applied to a core product to derive the desired variant. We present a prototypical implementation, which is integrated into Matlab/Simulink and offers graphical editing of delta models.

Integration of heterogeneous modeling languages via extensible and composable language components

Effective model-driven engineering of complex systems requires to appropriately describe different specific system aspects. To this end, efficient integration of different heterogeneous modeling languages is essential. Modeling language integaration is onerous and requires in-depth conceptual and technical knowledge and effort. Traditional modeling lanugage integration approches require language engineers to compose monolithic language aggregates for a specific task or project. Adapting these aggregates to different contexts requires vast effort and makes these hardly reusable. This contribution presents a method for the engineering of grammar-based language components that can be independently developed, are syntactically composable, and ultimately reusable. To this end, it introduces the concepts of language aggregation, language embedding, and language inheritance, as well as their realization in the language workbench MontiCore. The result is a generalizable, systematic, and efficient syntax-oriented composition of languages that allows the agile employment of modeling languages efficiently tailored for individual software projects.

A comparison of mechanisms for integrating handwritten and generated code for object-oriented programming languages

Code generation from models is a core activity in model-driven development (MDD). For complex systems it is usually impossible to generate the entire software system from models alone. Thus, MDD requires mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects with many model and code artifacts, where a sound integration for generated and handwritten code is necessary. We provide an overview of mechanisms for integrating generated and handwritten code for object-oriented languages. In addition to that, we define and apply criteria to compare these mechanisms. The results are intended to help MDD tool developers in choosing an appropriate integration mechanism.

Composition of Heterogeneous Modeling Languages

Model-driven engineering aims at managing the complexity of large software systems by describing their various aspects through dedicated models. This approach requires to employ different modeling languages that are tailored to specific system aspects, yet can be interpreted together to form a coherent description of the total system. Traditionally, implementations of such integrated languages have been monolithic language projects with little modularization and reuse of language parts.

Modeling robot and world interfaces for reusable tasks

Robotics applications involve robots that perform tasks by interacting with specific worlds. Most applications are intertwined with and tied to fixed robots and worlds. Changes and evolution of a robot or world have an invasive and often unpredictable impact on the application software. We propose making the models of robots and worlds explicit in robotics applications and separate these by introducing application-specific and platform-independent interfaces. This separation allows modular model-driven development of robotics applications and enables the reuse and adaptation of models and applications without need for invasive modifications. We present a framework with a family of modeling languages for conceptual, platform-independent applications, tasks, robots, and worlds. The model-driven RoboTask framework integrates these languages with a runtime architecture to execute robotics tasks using a planner and mappings from conceptual models to actual platforms. This enables a separation of domain concerns from software development concerns and modification of applications without invasive impacts on their separated constituents. We believe that the enabled reuse and adaptation lead to more efficient development and higher quality software for robotics applications.

Integration of Handwritten and Generated Object-Oriented Code

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete software system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integration of both forms of code is needed.

Compositional Language Engineering Using Generated, Extensible, Static Type-Safe Visitors

Language workbenches usually produce infrastructure to represent models as abstract syntax trees AST and employ processing infrastructure largely based on visitors. The visitor pattern suffers from the expression problem regarding extensibility and reuse. Current approaches either forsake static type safety, require features unavailable in popular object-oriented languages e.g., open classes, or rely on procedural abstraction and thereby give up the object-oriented data encapsulation the AST itself. Our approach to visitors exploits knowledge about the AST and generation of statically type-safe external visitor interfaces that support extensibility in two dimensions: 1 defining new operations by implementing the interface and 2 extending the underlying data structure, usually without requiring adaptation of existing implemented visitors. We present a concept of visitor development for language engineering that enables an adaptable traversal and provides hook points for implementing concrete visitors. This approach is applicable to single DSLs and to language composition. It thus enables a transparent, easy to use, and static type-safe solution for the typical use cases of language processing.

Using software categories for the development of generative software

In model-driven development (MDD) software emerges by systematically transforming abstract models to concrete source code. Ideally, performing those transformations is to a large extent the task of code generators. One approach for developing a new code generator is to write a reference implementation and separate it into handwritten and generatable code. Typically, the generator developer manually performs this separation - a process that is often time-consuming, labor-intensive, difficult to maintain and may produce more code than necessary. Software categories provide a way for separating code into designated parts with defined dependencies, for example, “Business Logic” code that may not directly use “Technical” code. This paper presents an approach that uses the concept of software categories to semi-automatically determine candidates for generated code. The main idea is to iteratively derive the categories for uncategorized code from the dependencies of categorized code. The candidates for generated or handwritten code finally are code parts belonging to specific (previously defined) categories. This approach helps the generator developer in finding candidates for generated code more easily and systematically than searching by hand and is a step towards tool-supported development of generative software.

Adaptable symbol table management by meta modeling and generation of symbol table infrastructures

Many textual software languages share common concepts such as defining and referencing elements, hierarchical structures constraining the visibility of names, and allowing for identical names for different element kinds. Symbol tables are useful to handle those reference and visibility concepts. However, developing a symbol table can be a tedious task that leads to an additional effort for the language engineer. This paper presents a symbol table meta model usable to define language-specific symbol tables. Furthermore, we integrate this symbol table meta model with a meta model of a grammar-based language definition. This enables the language engineer to switch between the model structure and the symbol table as needed. Finally, based on a grammar annotation mechanism, our approach is able to generate a symbol table infrastructure that can be used as is or serve as a basis for custom symbol tables.

Mixed generative and handcoded development of adaptable data-centric business applications

Consistent management of structured information is the goal of data-centric business applications. Model-driven development helps to automatically generate such applications. Current approaches target full or one shot generation of business applications and often neglect simplicity and adaptability of the code generator and the generated code. Inspection of the generated code is required to add functionality. Thus, here we discuss mechanisms for a code generator to generate a lightweight and highly customizable data-centric business application that is targeted for a variety of users including generated application users, tool developers, and product developers. We achieve simplicity by reducing the mapping of the input model to the generated code to a minimal core of easily understandable concepts. High customizability is achieved by providing a variety of mechanisms to extend the generator and the generated code. These include template overriding and hook points to extend the code generator; and hot spots and additional manual extensions to extend the generated code. It is even possible to fully control the code generator and the entire generation process via a scripting language.