Uwe Aßmann

Ontologies, Meta-models, and the Model-Driven Paradigm

Ontologies are no silver bullet. They can be employed in the software process as descriptive standardized domain models, domain-specific languages, and modelling (description) languages. However, they should not be mingled with specifications of software systems. In MDE, both forms of models are needed and complement each other. It is time to develop appropriate mega-models that clarify the role of ontologies in MDE. This chapter has presented one approach; however, this can be only an intermediate step, because we restricted ourselves to the standard IRDS metapyramid. Other, more sophisticated meta-pyramids exist and must be extended to be ontology-aware.

Towards modeling a variable architecture for multi-tenant SaaS-applications

A widespread business model in cloud computing is to offer software as a service (SaaS) over the Internet. Such applications are often multi-tenant aware, which means that multiple tenants share hardware and software resources of the same application instance. However, SaaS stakeholders have different or even contradictious requirements and interests: For a user, the applications quality and non-functional properties have to be maximized (e.g., choosing the fastest available algorithm for a computation at runtime). In contrast, a resource or application provider is interested in minimizing the operating costs while maximizing his profit. Finally, tenants are interested in offering a customized functionality to their users. To identify an optimal compromise for all these objectives, multiple levels of variability have to be supported by reference architectures for multi-tenant SaaS applications. In this paper, we identify requirements for such a runtime architecture addressing the individual interests of all involved stakeholders. Furthermore, we show how our existing architecture for dynamically adaptive applications can be extended for the development and operation of multi-tenant applications.

A Metamodel Family for Role-Based Modeling and Programming Languages

Role-based modeling has been proposed almost 40 years ago as a means to model complex and dynamic domains, because roles are able to capture both context-dependent and collaborative behavior of objects. Unfortunately, while several researchers have introduced the notion of roles to modeling and programming languages, only few have captured both the relational and the context-dependent nature of roles. In this work, we classify various proposals since 2000 and show the discontinuity and fragmentation of the whole research field. To overcome discontinuity, we propose a family of metamodels for role-based modeling languages. Each family member corresponds to a design decision captured in a feature model. In this way, it becomes feasible to generate a metamodel for each role-based approach. This allows for the combination and improvement of the different role-based modeling and programming languages and paves the way to reconcile the research field.

Co-evolution of models and feature mapping in software product lines

Software Product Lines (SPLs) are a successful approach to software reuse in the large. Even though tools exist to create SPLs, their evolution is widely unexplored. Evolving an SPL manually is tedious and error-prone as it is hard to avoid unintended side-effects that may harm the consistency of the SPL. The main contribution of this paper is the conceptual basis of a system for the evolution of model-based SPLs, which maintains consistency of models and feature mapping. As further contribution, a novel classification is introduced that distinguishes evolutions by their potential to harm the mapping of an SPL. In addition, multiple remapping operators are presented that can remedy the negative side-effects of evolutions in order to co-evolve the feature mapping. Finally, an implementation of the evolution system in the SPL tool FeatureMapper is provided to demonstrate the capabilities of the presented approach when co-evolving models and feature mapping of an SPL.

Role-based generic model refactoring

Refactorings can be used to improve the structure of software artifacts while preserving the semantics of the encapsulated information. Various types of refactorings have been proposed and implemented for programming languages such as Java or C#. With the advent of Model-Driven Software Development (MDSD), the need for restructuring models similar to programs has emerged. Previous work in this field [1,2] indicates that refactorings can be specified generically to foster their reuse. However, existing approaches can handle only certain types of modelling languages and reuse refactorings only once per language. In this paper a novel approach based on role models to specify generic refactorings is presented. We discuss how this resolves the limitations of previous works, as well as how specific refactorings can be defined as extensions to generic ones. The approach was implemented based on the Eclipse Modeling Framework (EMF) [3] and evaluated using multiple modelling languages and refactorings.

Reference attribute grammars for metamodel semantics

While current metamodelling languages are well-suited for the structural definition of abstract syntax and metamodelling platforms like the Eclipse Modelling Framework (EMF) provide various means for the specification of a textual or graphical concrete syntax, techniques for the specification of model semantics are not as matured. Therefore, we propose the application of reference attribute grammars (RAGs) to alleviate the lack of support for formal semantics specification in metamodelling. We contribute the conceptual foundations to integrate metamodelling languages and RAGs, and present JastEMF - a tool for the specification of EMF metamodel semantics using JastAdd RAGs. The presented approach is exemplified by an integrated metamodelling example. Its advantages, disadvantages and limitations are discussed and related to metamodelling, attribute grammars (AGs) and other approaches for metamodel semantics.

Automatic Roundtrip Engineering

A systematic method for roundtrip engineering of systems, automatic roundtrip engineering (ARE), is presented. It relies on the automatic derivation of inverses for domain transformations. While roundtrip engineering is a well known system engineering method, systematic conditions for its deployment have not yet been formalized, and this is done in the paper. Secondly, ARE is a generic architectural style for different architectural scenarios. To show this, the paper gives a first classification, defining several subclasses of ARE systems: sequenced ARE systems, automatic Model-View-Controller engineering (MVARE), and bidirectional aspect systems (Beavers). Sequenced ARE systems extend the ARE principle to chains of transformations. MVARE systems project a domain into a set of simpler ones, simplifying system understanding. Beaving systems generalize aspect-oriented programming to roundtrip engineering. All ARE classes describe different generic application architectures and have a great potential to simplify the construction of roundtrip engineering tools and applications.

Extending grammars and metamodels for reuse: the Reuseware approach

The trend toward domain-specific languages leads to an ever-growing plethora of highly specialized languages. Developers of such languages focus on their specific domains rather than on technical challenges of language design. Generic features of languages are rarely included in special-purpose languages. One very important feature is the ability to formulate partial programs in separate encapsulated entities, which can be composed into complete programs in a well-defined manner. This paper presents a language-independent approach for adding useful constructs for defining components. We discuss the underlying concepts and describe a composition environment and tool supporting these ideas ‐ the Reuseware Composition Framework. To evaluate our approach we enrich the (Semantic) Web query language Xcerpt with an additional useful reuse concept—modules.

Towards modeling and analyzing variability in evolving software ecosystems

A software ecosystem (SECO) encompasses a set of interdependent software systems where individual products are created by combining a common software platform with variable extensions. Examples are the SECOs surrounding Eclipse or Android. Due to independent release cycles of the multiple vendors for platform and extensions, SECOs are evolving frequently. This makes it hard to get a concise impression of the structure of a SECO and its variable artifacts during a given period of time. We contribute a metamodel to capture the variability in an arbitrary SECO and its evolution based on the notion of real time. We further present a procedure to create temporal perspectives on the SECO. Additionally, we provide means to analyze evolution of variability in between explicit releases of the platform, e.g., in accordance with the different release cycles of individual extensions. We demonstrate feasibility of our approach by modeling a part of the Eclipse SECO over a period of three years.

Comparing mobile applications' energy consumption

As mobile devices are nowadays used regularly and everywhere, their energy consumption has become a central concern. However, todays mobile applications often do not consider energy requirements and users lack information on their energy consumption before they install and try them. In this paper, we compare mobile applications from two domains and show that they reveal different energy consumption while providing similar services. We define microbenchmarks for emailing and web browsing and evaluate apps from these domains. We show that non-functional features such as web page caching can but not have to have a positive influence on an applications energy consumption.