Sebastian Götz

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.

JavAdaptor-Flexible runtime updates of Java applications

Software is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the programs architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JavAdaptor combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approachs applicability and performance in non‐trivial case studies and compare it with existing dynamic software update approaches. Copyright

JouleUnit: a generic framework for software energy profiling and testing

Energy consumption has become an important characteristic of nowadays information and communication technology (ICT) applications, especially for mobile devices, whose uptime is limited by the available battery capacity. Hence, ICT applications are optimized to provide the best possible user satisfaction for the least possible energy budget. An inevitable prerequisite for such optimizations is the ability to analyze softwares energy consumption. In consequence, many energy profiling frameworks have been developed. The problem we address in this paper is that profiling frameworks are device- and application-specific and, hence, cannot be reused. We analyze the key requirements of energy profiling frameworks and propose a generic framework reusable for different devices and applications, designed according to these requirements. We evaluate the presented framework using two case studies showing the reusability in two significantly different scenarios.

JavAdaptor: unrestricted dynamic software updates for Java

Dynamic software updates (DSU) are one of the top-most features requested by developers and users. As a result, DSU is already standard in many dynamic programming languages. But, it is not standard in statically typed languages such as Java. Even if at place number three of Oracles current request for enhancement (RFE) list, DSU support in Java is very limited. Therefore, over the years many different DSU approaches for Java have been proposed. Nevertheless, DSU for Java is still an active field of research, because most of the existing approaches are too restrictive. Some of the approaches have shortcomings either in terms of flexibility or performance, whereas others are platform dependent or dictate the programs architecture. With JavAdaptor, we present the first DSU approach which comes without those restrictions. We will demonstrate JavAdaptor based on the well-known arcade game Snake which we will update stepwise at runtime.

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.

A Reference Architecture and Roadmap for Models@run.time Systems

The key property of models@run.time systems is their use and provision of manageable reflection, which is characterized to be tractable and predictable and by this overcomes the limitation of reflective systems working on code, which face the problem of undecidability due to Turing-completeness. To achieve tractability, they abstract from certain aspects of their code, maintaining runtime models of themselves, which form the basis for reflection. In these systems, models form abstractions that neglect unnecessary details from the code, details which are not pertinent to the current purpose of reflection. Thus, models@run.time systems are a new class of reflective systems, which are characterized by their tractability, due to abstraction, and their ability to predict certain aspects of their own behavior for the future. This chapter outlines a reference architecture for models@run.time systems with the appropriate abstraction and reflection components and gives a roadmap comprised of short- and long-term research challenges for the area. Additionally, an overview of enabling and enabled technologies is provided. The chapter is concluded with a discussion of several application fields and use cases.

A combined formal model for relational context-dependent roles

Role-based modeling has been investigated for over 35 years as a promising paradigm to model complex, dynamic systems. Although current software systems are characterized by increasing complexity and context-dependence, all this research had almost no influence on current software development practice, still being discussed in recent literature. One reason for this is the lack of a coherent, comprehensive, readily applicable notion of roles. Researchers focused either on relational roles or context-dependent roles rather then combining both natures. Currently, there is no role-based modeling language sufficiently incorporating both the relational and context-dependent nature of roles together with the various proposed constraints. Hence, this paper formalizes a full-fledged role-based modeling language supporting both natures. To show its sufficiency and adequacy, a real world example is employed.

Practical refactoring-based framework upgrade

Although the API of a software framework should stay stable, in practice it often changes during maintenance. When deploying a new framework version such changes may invalidate plugins - modules that used one of its previous versions. While manual plugin adaptation is expensive and error-prone, automatic adaptation demands cumbersome specifications, which the developers are reluctant to write and maintain. Basing on the history of structural framework changes (refactorings), in our previous work we formally defined how to automatically derive an adaptation layer that shields plugins from framework changes. In this paper we make our approach practical. Two case studies of unconstrained API evolution show that our approach scales in a large number of adaptation scenarios and comparing to other adaptation techniques. The evaluation of our logic-based tool ComeBack! demonstrates that it can adapt efficiently most of the problem-causing API refactorings.

Energy-Efficient Databases Using Sweet Spot Frequencies

Database management systems (DBMS) are typically tuned for high performance and scalability. Nevertheless, carbon footprint and energy efficiency are also becoming increasing concerns. Unfortunately, existing studies mainly present theoretical contributions but fall short on proposing practical techniques. These could be used by administrators or query optimizers to increase the energy efficiency of the DBMS. Thus, this paper explores the effect of so-called sweet spots, which are energy-efficient CPU frequencies, on the energy required to execute queries. From our findings, we derive the Sweet Spot Technique, which relies on identifying energy-efficient sweet spots and the optimal number of threads that minimizes energy consumption for a query or an entire database workload. The technique is simple and has a practical implementation leading to energy savings of up to 50% compared to using the nominal frequency and maximum number of threads.