Michael Langhammer

View-centric engineering with synchronized heterogeneous models

Model-Driven Engineering provides an abstract representation of systems through the use of models and views. For complex systems, however, finding a single model and a single view to represent all relevant information of the system is infeasible. Specialized models for specific subsystems, domains or abstractions are more concise and thus more efficient than monolithic models. Furthermore, different tasks and concerns often require different views on the same model. Sustaining the consistency between different views and models is hard, especially if new models and views are dynamically added. In this paper, we present an approach that supports flexible views that may involve multiple models conforming to different metamodels. The approach is based on Orthographic Software Modeling and synchronizes individual instances using model transformations. These transformations are generated from view type definitions, metamodel correspondence rules and invariants, which are defined in a domain-specific language. We illustrate our approach with an application that combines component-based architectures with object-oriented source code and class diagrams.

Automated Extraction of Rich Software Models from Limited System Information

Reverse engineering a software system is challenged by the typically very limited information available about existing systems. Useful reverse engineering tasks include recovering a systems architectural, behavioral, and usage models, which can then be leveraged to answer important questions about a system. For example, using such models to analyze and predict a systems non-functional properties would help to efficiently assess the systems current state, planned adaptations, scalability issues, etc. Existing approaches typically only extract a systems static architecture, omitting the dynamic information that is needed for such analyses. The contribution of this paper is an automated technique that extracts a systems static architecture, behavior, and usage models from very limited, but readily available information: source code and test cases. These models can then be fed into known performance, reliability, and cost prediction techniques. We evaluated our approach for accuracy against systems with already established usage models, and observed that our approach finds the correct, but more detailed usage models. We also analyzed 14 open source software systems spanning over 2 million lines of code to evaluate the scalability of our approach.

Change-Driven Consistency for Component Code, Architectural Models, and Contracts

During the development of component-based software systems, it is often impractical or even impossible to include all development information into the source code. Instead, specialized languages are used to describe components and systems on different levels of abstraction or from different viewpoints: Component-based architecture models and contracts, for example, can be used to describe the system on a high level of abstraction, and to formally specify component constraints. Because models, contracts, and code contain redundant information, inconsistencies can occur if they are modified independently. Keeping this information consistent manually can require considerable effort, and can lead to costly errors, for example, when security-relevant components are verified against inconsistent contracts. In this paper, we present an approach for keeping component- based architecture models and contracts specified in the Java Modeling Language (JML) consistent with Java source code. We use change-driven incremental transformations and the Vitruvius framework to automate the consistency preservation where this is possible. Using two case studies, we demonstrate how to detect and propagate changes and refactoring operations to keep models and contracts consistent with the source code.

Co-evolution of component-based architecture-model and object-oriented source code

With the evolution of software systems, architecture model and system implementation tend to drift apart. While suitable architecture model supports architects and developers in better understanding the software system, the missing synchronization to source code of the underlying implementation can result in outdated architecture models. In this paper, we address two challenges in todays architecture-driven software development: architecture drift and architecture erosion. We introduce a co-evolution approach of a component-based architecture model and object-oriented source code. Our novel approach supports software architects and software developers by introducing a tight and continuous synchronization of a component-based architecture model and the source code. To get architecture evolution under control, our co-evolution approach maps architecture changes done via the source code to the architecture model and vice versa. This explicit support of changes and refactorings at architecture-level prevents unintended architecture violations. In order to evaluate our approach, we plan different case studies whose layout is designed in the evaluation section.

Reuse and configuration for code generating architectural refinement transformations

The transformation of component-based architectures into object-oriented source code for different platforms is a common task in Model-Driven Software Development. Reusing parts that are common to all supported target-platforms for several model-to-text transformations is challenging. Existing approaches, like parameterized transformations and modularity concepts for transformations, make the reuse of transformations parts easier, but cannot be used to visualize design decisions that are common to all supported target-platforms. In this paper, we propose that platform-independent design decisions and their transformation results should be made explicit in an intermediate view. A single parameterized transformation should yield a common object-oriented model before individual transformations for specific platforms are executed. We argue that the additional view makes it possible to analyze decisions on how a component architecture is implemented and increases the maintainability by decoupling the involved transformations.

Integration of Existing Software Artifacts into a View- and Change-Driven Development Approach

For the description of complex software systems, a variety of different languages can be used, e.g., architecture diagrams, behavior models, source code, etc. Maintaining these artifacts is a complex task, if the contained information is not completely disjoint. There are approaches that keep such redundancies consistent by propagating changes. This is, however, only possible if change descriptions are recorded or provided. Therefore, these change-driven approaches cannot be used to maintain existing software projects, which did not record all changes during development. This results in the need of developing a possibility for the integration of said projects. We therefore propose two different strategies for integrating existing artifacts into a change-driven approach: Our first strategy creates change histories for models, while the second strategy builds correspondences from given trace links and their attached artifacts. Furthermore, we suggest a number of criteria, which determine which strategy is best used, and when. In this paper, we applied our strategies to architectural models and object-oriented source code and used a reverse engineering tool to create the necessary trace links. We evaluated the applicability of our approach with several case studies, containing five real world architectural models and five medium-sized Java projects.

Proposal for a Multi-View Modelling Case Study: Component-Based Software Engineering with UML, Plug-ins, and Java

During the design and development of complex systems, multiple modelling languages are often necessary in order to describe a system for specific tasks and users. The resulting models can show parts of the same system from different perspectives or views, which is described by the term multi-view modelling. The overlap between individual views presents fundamental challenges, e.g. for sustaining consistency among views or for the creation of new views. A common multi-view modelling case study that covers essential challenges and requirements can be used as a basis for the comparison of approaches that address these challenges. In this paper, we propose such a case study in the context of component-based software engineering with UML composite diagrams, Eclipse plug-ins, and Java code. We explain the overlap between the different views, propose new view types that aggregate information from several sources, and discuss essential challenges of multi-view modelling that are posed by this case study. These challenges are, for example, one-to-many and partial relations between elements of different views, and the constraint combination effects of different views. Our proposal contributes to the community effort that is required to obtain a common case study that enables an efficient comparison of multi-view modelling approaches.

Ecoreification: Making Arbitrary Java Code Accessible to Metamodel-Based Tools

Models are used in software engineering to describe parts of a system that are relevant for the computation of specific analyses, or the provision of specific functionality. Metamodeling languages such as Ecore make it possible to realize analyses and functionality with model-driven technology, such as transformation engines. If models conform to a metamodel that was expressed using Ecore, numerous Eclipse-based tools can be reused to directly analyze, display, or transform models. In many software projects, models are, however, realized with objects of plain-old Java classes rather than an explicit metamodel, so these popular toolscannot be used.In this new ideas paper, we present an Ecoreification approach, which can be used to automatically extract Ecore-conforming metamodels from Java code, and a code generator that combines the benefits of both worlds. The resulting code can be used exactly as before, but it also uses the modeling infrastructure and implements all interfaces for Ecore-based tooling. This way, arbitrary non-standard models can be displayed and modified, for example using graphical Sirius editors, or transformed with well-proven transformation languages, such as QVT-O or ATL.