Raising the level of abstraction when developing a software system is the driving force behind Model-driven software development (MDSD) – a software engineering paradigm which gained more and more attention during the last decade. The current state of the art in MDSD allows software engineers to capture the static structure in a model, e.g., by using class diagrams provided by the Unified Modeling Language (UML), and to generate source code from it. Furthermore, when it comes to expressing the behavior, i.e., method bodies, the UML offers a set of diagrams which may be used for this purpose. Unfortunately, not all UML diagrams come with a precisely defined execution semantics and thus, code generation is hindered. Recently, the OMG issued the standard for an Action Language for Foundational UML (ALF) which allows for textual modeling of software system and which provides a precise execution semantics. In this paper, a tight integration between our UML-based CASE tool and our ALF tool is presented. The resulting tool chain allows to express structure and behavior of a software system on the model level and to generate fully executable Java source code.

Model-driven software product line engineering is an integrating discipline for which tool support has become available recently. However, existing tools are still immature and have several weaknesses. Among others, limitations in variability, caused by meta model restrictions, and unintended information loss are not addressed. In this paper, we present two conceptual extensions to model-driven product line engineering based on negative variability, being alternative mappings and surrogates. Alternative mappings allow for unconstrained variability, mitigating meta model restrictions by virtually extending the underlying multi-variant domain model. Surrogates prevent unintended information loss during product derivation based on a contextsensitive product analysis, which can be controlled by a declarative OCL-based language. Both extensions have been implemented in FAMILE, a model-driven product line tool that is based on EMF, provides dedicated consistency repair mechanisms, and completely automates application engineering. The added value of alternative mappings and surrogates is demonstrated by a running example.

Model Transformations are a key element of Model-Driven Software Engineering. As soon as variability is involved, transformations become increasingly complicated. The lack of support for variability in model transformations impairs the acceptance of approaches to organized reuse such as software product lines. In this position paper, the general problem of multi-variant model transformations is formulated for MOF-based, XMI-serialized models. A simplistic case study is presented to specify the input and the expected output of such a transformation. Furthermore, requirements for tool support are defined, including a standardized representation of both multi-variant model instances and variability information, as well as an execution specification for multi-variant transformations. A literature review reveals that the problem is weakly identified and often solved using ad-hoc solutions; there exists no tool providing a general solution to the proposed problem statement. The observations presented here may serve for the future development of standards and tools.

Model-driven software engineering has become more and more important during the last few years. Model transformations constitute the core essence of model-driven development. Throughout the years, the concept of unidirectional model transformations and corresponding tool support has become mature and usable. Transformations of this kind are widely used in model-driven development, for forward or reverse engineering or mainly for code generation. Bidirectional transformations, on the other hand, aim to provide support for (incrementally) transforming one or more source models to one or more target models and vice versa from only one transformation description. However, they seem to be rarely used in model-driven software development although modelers need round-trip support between the different stages of development models. In this paper we present a QVT implementation of a bidirectional model transformation. Our case study keeps UML class diagrams consistent with a Java model during round-trip engineering and thereby shows a real world application. The results and experiences gained in this case study are discussed in detail.

Model-Driven Software Engineering (MDSE), Software Product Line Engineering (SPLE) and Software Configuration Management (SCM) have been established as independent disciplines to ease different aspects of software development. The usage of models as high-level abstractions promises to increase productivity, while software product lines manage variability within a family of similar software products; software configuration management systems manage evolution and support collaborative development. In this paper, we explore the state of the art regarding the pairwise combinations MDSE/SPLE, SPLE/SCM, and MDSE/SCM and show that an integrated solution combining all three disciplines is missing. We present a conceptual framework to integrate MDSE, SPLE and SCM uniformly based on a filtered editing model. The framework implies a number of advantages, namely unconstrained variability, a reduction of cognitive complexity, improved consistency, tool independence, and a higher level of automation. Our formalism is based on a uniform versioning model for temporal, cooperative, and logical versioning of models. By an example, we show the feasibility of our approach.

Programming robots is a complicated and time-consuming task. A robot is essentially a real-time, distributed embedded system. Often, control and communication paths within the system are tightly coupled to the actual physical configuration of the robot. Thus, programming a robot can hardly be achieved by experts of the domain in which the robot is used. In this paper we present an approach towards a domain specific language, which is intended to empower domain experts or even end users to specify robot programs with a dedicated background in programming techniques, but not with special knowledge in the robotics domain. Furthermore we introduce an idea to integrate a software product-line for a hardware and software transparent plug and play mechanism.

Model-driven engineering is a wide-spread paradigm in modern software engineering.During the last couple of years, many tools and languages have been developed, which are especially designed for model transformations -a discipline which is needed in many model-driven engineering approaches.While most of the existing model-to-model tools and languages are tailored towards batch transformations for specific model instances, they lack support for generic transformation problems, where the metamodel is unknown beforehand.In this paper we present a two-step meta-code generation approach that derives a metamodel-specific modelto-model transformation from a model-to-text transformation.The approach has been successfully applied to the problem of product derivation in model-driven software product lines.