Reiner Jung

Architectural run-time models for operator-in-the-loop adaptation of cloud applications

Building software systems by composing third-party cloud services promises many benefits. However, the increased complexity, heterogeneity, and limited observability of cloud services brings fully automatic adaption to its limits. We propose architectural run-time models as a means for combining automatic and operator-in-the-loop adaptations of cloud services.

A Method for Aspect-oriented Meta-Model Evolution

Long-living systems face many modifications and extensions over time due to changing technology and requirements. This causes changes in the models reflecting the systems, and subsequently in the underlying meta-models, as their structure and semantics are adapted to adhere these changes. Modifying meta-models requires adaptations in all tools realizing their semantics. This is a costly endeavor, especially for complex meta-models. To solve this problem we propose a method to construct and refactor meta-models to be concise and focused on a small set of concerns. The method results in simpler metamodel modification scenarios and fewer modifications, as new concerns and aspects are encapsulated in separate meta-models. Furthermore, we define design patterns based on the different roles meta-models play in software. Thus, we keep large and complex modeling projects manageable due to the improved adaptability of their meta-model basis.

MAMBA: Model-Based Software Analysis Utilizing OMG's SMM

Most software system properties can be quantified through applying measurement processes. OMGs Structured Metrics Meta-Model (SMM) supports the meta-model agnostic definition of those measurement processes with an emphasis on architecture-driven modernization scenarios. We present the MAMBA framework that addresses major obstacles software engineers currently face when using SMM in practice. Among those are (1) the lack of appropriate tool support, (2) the cumbersome integration of precomputed measurement data, and (3) the complexity of specifying SMM models and queries.

GECO: A Generator Composition Approach for Aspect-Oriented DSLs

Code and model generators that are employed in model-driven engineering usually face challenges caused by complexity and tight coupling of generator implementations, particularly when multiple metamodels are involved. As a consequence maintenance, evolution and reuse of generators is expensive and error-prone. We address these challenges with a two fold approach for generator composition, called GECO, which subdivides generators in fragments and modules. 1 fragments are combined utilizing megamodel patterns. These patterns are based on the relationship between base and aspect metamodel, and define that each fragment relates only to one source and target metamodel. 2 fragments are modularized along transformation aspects, such as model navigation, and metamodel semantics. We evaluate our approach with two case studies from different domains. The obtained generators are assessed with modularity and complexity metrics, covering architecture and method level. Our results show that the generator modularity is preserved during evolution utilizing GECO.

Architectural Runtime Modeling and Visualization for Quality-Aware DevOps in Cloud Applications

In this paper, we present a tutorial on modeling and visualizing software architectures in form of architectural runtime models to support quality-aware DevOps in cloud applications. The tutorial is held in context of the 2017 14th IEEE International Conference on Software Architecture to share our findings and experiences with conference participants and give them the opportunity to expand their knowledge and skills on software architecture modeling, visualization, and analysis in development and operations.

An Architectural Model-Based Approach to Quality-Aware DevOps in Cloud Applicationsc

Cloud-based software applications are designed to change often and rapidly during operations to provide constant quality of service. As a result the boundary between development and operations is becoming increasingly blurred. DevOps is a set of practices for the integrated consideration of developing and operating software. Software architecture is a central artifact in DevOps practices. Architectural information must be available during operations. Existing architectural models used in the development phase differ from those used in the operation phase in terms of abstraction, purpose and content. This chapter presents the iObserve approach to address these differences and allow for phase-spanning usage of architectural models.