During the development of component-based software systems, it is often impractical or even impos... more 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. Since 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 technical report, we present details on realizing an approach for keeping component-based architecture models and contracts specified in the Java Modeling Language (JML) consisten...
Constraints that have to hold for all models of a modeling language are often specified as invari... more Constraints that have to hold for all models of a modeling language are often specified as invariants using the Object Constraint Language (OCL). If violations of such invariants shall be documented or resolved in a software system, the exact model elements that violate these conditions have to be computed. OCL validation engines provide, however, only a single context element at which a check for a violated invariant originated.Therefore, the computation of elements that caused an invariant violation is often specified in addition to the invariant declaration with redundant information. These redundancies can make it hard to develop and maintain systems that document or resolve invariant violations. In this paper, we present an automated approach and tool for declaring and binding parameters of invariants to violating elements based on boolean invariant expressions that are similar to OCL invariants. The tool computes a transformed invariant that returns violating elements for each...
Several research approaches in the field of Model-Driven Engineering (MDE) are concerned with the... more Several research approaches in the field of Model-Driven Engineering (MDE) are concerned with the development of model transformation languages. No controlled experiments have, however, been conducted yet to evaluate whether it is easier to write model transformations in a model transformation language (MTL) than in a general purpose programming language (GPPL). Such experiments are difficult to design and conduct. To write and maintain code in an MTL, it is necessary to understand the code. Thus, an evaluation of the effect on program comprehension is a first step towards empirically evaluating the benefit of model transformation languages. In this study design paper, we propose an experiment template for empirically measuring the potential understandability gain of using an MTL instead of a GPPL. We discuss a randomized experiment setup, in which subjects fill out a paper-based questionnaire to prove their ability to understand the effect of transformation code snippets, which are...
Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings, 2018
Software designers often lack an understanding of the effects of design decisions on quality prop... more Software designers often lack an understanding of the effects of design decisions on quality properties of their software. This results in costly and time-consuming trial-and-error testing, delayed and complicated rollouts of the software. In this tool demonstration paper we present an integrated tool environment-the Palladio-Bench-for modeling and analyzing software architectures. The analysis results provided by Palladio support making design decisions by identifying the best-suited design from a set of given alternatives. The demonstration video for the Palladio-Bench can be found at the URL https://youtu.be/vG7WQPcp-uI.
In model-driven software development, source code and other artifacts are used to describe and de... more In model-driven software development, source code and other artifacts are used to describe and develop a software system. UML class diagrams are one of the most common models that are used. A UML class diagram models classes and interfaces of a software system as well as their relations. The usage of UML class diagrams in addition to source code can lead to drift and erosion if the models are not kept consistent with code changes and vice versa: Existing solutions solve this problem using consistency mechanisms that update the source code and UML class diagram accordingly. The development and maintenance of such consistency mechanisms can result in considerable e↵ort and costs. In this paper, we present a prototype for a new UML class diagram editor that is realized as a projection of a Java source code model. The editor does not use an explicit UML model. It provides another concrete syntax for a subset of the source code elements and their relations. A model represenation of the s...
During the development of large software-intensive systems, developers use several modeling langu... more During the development of large software-intensive systems, developers use several modeling languages and tools to describe a system from different viewpoints. Model-driven and view-based technologies have made it easier to define domain-specific languages and transformations. Nevertheless, using several languages leads to fragmentation of information, to redundancies in the system description, and eventually to inconsistencies. Inconsistencies have negative impacts on the system's quality and are costly to fix. Often, there is no support for consistency management across multiple languages. Using a single language is no practicable solution either, as it is overly complex to define, use, and evolve such a language. View-based development is a suitable approach to deal with complex systems, and is widely used in other engineering disciplines. Still, we need to cope with the problems of fragmentation and consistency. In this paper, we present the Vitruvius approach for consistency in view-based modeling. We describe the approach by formalizing the notion of consistency, presenting languages for consistency preservation, and defining a model-driven development process. Furthermore, we show how existing models can be integrated. We have evaluated our approach at two case studies from component-based and embedded automotive software development, using our prototypical implementation based on the Eclipse Modeling Framework.
Proceedings of the 4th International Conference on Model-Driven Engineering and Software Development, 2016
Despite the crucial importance of metamodeling for Model-Driven Engineering (MDE), there is still... more Despite the crucial importance of metamodeling for Model-Driven Engineering (MDE), there is still little discussion about the quality of metamodel design and its consequences in model-driven development processes. Presumably, the quality of metamodel design strongly affects the models and transformations that conform to these metamodels. However, so far surprisingly few work has been done to validate the characterization of metamodel quality. A proper characterization is essential to automate quality improvements for metamodels such as metamodel refactorings. In this paper, we present an empirical study to sharpen the understanding of the perception of metamodel quality. In the study, 24 participants created metamodels of two different domains and evaluated the metamodels in a peer review process according to an evaluation sheet. The results show that the perceived quality was mainly driven by the metamodels completeness, correctness and modularity while other quality attributes could be neglected.
Proceedings of the 18th International ACM SIGSOFT Symposium on Component-Based Software Engineering, 2015
During the development of component-based software systems, it is often impractical or even impos... more 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 componentbased 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.
Completion and Extension Techniques for Enterprise Software Performance Engineering
Progress in IS, 2014
Software performance engineering supports software architects in identifying potential performanc... more Software performance engineering supports software architects in identifying potential performance problems in software systems during the design phase. Details of the implementation and execution environment of a system are crucial for accurate performance predictions. Yet, only little information about these details is available during early stages of the software life-cycle; furthermore, model-based architectural description languages used by software architects are lacking support for performance-relevant information. Architectural models need to be extended, so they are ready to include design details as they become available when development advances. Model extensions, however, give rise to the problem of model and metamodel evolution. We report on our experiences with a variety of metamodel extension techniques, covering completions, direct invasive techniques, decorator models, and profiles in the context of model-driven performance engineering. Our goal is to enable performance engineers to find the optimal solution when metamodel variability and evolution support is required. In a case study, we extend a component-based system with thread management information, thereby illustrating the benefit of performance completions with respect to the accuracy of performance predictions.
Proceedings of the 1st Workshop on View-Based, Aspect-Oriented and Orthographic Software Modelling, 2013
The transformation of component-based architectures into object-oriented source code for differen... more 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 platformindependent design decisions and their transformation results should be made explicit in an intermediate view. A single parameterized transformation should yield a common objectoriented 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.
Proceedings of the 1st Workshop on View-Based, Aspect-Oriented and Orthographic Software Modelling, 2013
Model-Driven Engineering provides an abstract representation of systems through the use of models... more 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 objectoriented source code and class diagrams.
Proceedings of the 2nd Workshop on View-Based, Aspect-Oriented and Orthographic Software Modelling, 2014
During the design and development of complex systems, multiple modelling languages are often nece... more 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.
Uploads
Papers by Max Kramer