Julia Schroeter

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.

Multi-perspectives on feature models

Domain feature models concisely express commonality and variability among variants of a software product line. For supporting separation of concerns, e.g., due to legal restrictions, technical considerations and business requirements, multi-view approaches restrict the configuration choices on feature models for different stakeholders. However, recent approaches lack a formalization for precise, yet flexible specifications of views that ensure every derivable configuration perspective to obey feature model semantics. Here, we introduce a novel approach for preconfiguring feature models to create multi-perspectives. Such customized perspectives result from composition of various concern-relevant views. A structured view model is used to organize features in view groups, wherein a feature may be contained in multiple views. We provide formalizations for view composition and guaranteed consistency of perspectives w.r.t. feature model semantics. Thereupon, an efficient algorithm to verify consistency for entire multi-perspectives is provided. We present an implementation and evaluate our concepts by means of various experiments.

Reducing feature models to improve runtime adaptivity on resource limited devices

Mobile devices like smartphones are getting increasingly important in our daily lifes. They are used in various environments and have to dynamically adapt themselves accordingly in order to provide an optimal runtime behavior. Naturally, adapting to continuously changing environmental conditions is a challenging task because mobile devices are always limited in their resources and have to adapt in real-time. In this paper, we introduce an approach that enables resource limited devices to adapt to changing conditions using dynamic software product lines techniques. Therefore, feature models are reduced to a specific hardware context before installing the adaptive mobile application on the device. This reduces the amount of possible configurations that are compatible with the device and, thereby, minimizes the costs and the duration of an adaptation during runtime.

DropsBox: the Dresden Open Software Toolbox

The Dresden Open Software Toolbox (DropsBox) is a software modelling toolbox consisting of a set of open source tools developed by the Software Technology Group at TU Dresden. The DropsBox is built on top of the Eclipse Platform and the Eclipse Modeling Framework. The DropsBox contributes to the development and application of domain-specific language changes (DSLs) in model-driven software development. It can be customised by tool and language developers to support various activities of a DSL’s life cycle ranging from language design to language application and evolution. In this paper, we provide an overview of the DSL life cycle, the DropsBox tools, and their interaction on a common example. Furthermore, we discuss our experiences in developing and integrating tools for DropsBox in an academic environment.

Elucidative development for model-based documentation

Documentation is an essential activity in software development, for source code as well as modelling artefacts. Typically, documentation is created and maintained manually which leads to inconsistencies as documented artefacts like source code or models evolve during development. Existing approaches like literate/elucidative programming or literate modelling address these problems by deriving documentation from software development artefacts or vice versa. However, these approaches restrict themselves to a certain kind of artefact and to a certain phase of the software development life-cycle. In this paper, we propose elucidative development as a generalisation of these approaches supporting heterogeneous kinds of artefacts as well as the analysis, design and implementation phases of the software development life-cycle. Elucidative development links source code and model artefacts into documentation and thus, maintains and updates their presentation semi-automatically. We present DEFT as an integrated development environment for elucidative development. We show, how DEFT can be applied to language specifications like the UML specification and help to avoid inconsistencies caused by maintenance and evolution of such a specification.

A Role-Based Language for Collaborative Robot Applications

The recent progress in robotic hard- and software motivates novel, collaborative robot applications, where multiple robots jointly accomplish complex tasks like surveillance or rescue scenarios. Such applications impose two basic challenges: (1) the complexity of specifying collaborative behavior and (2) the need for a flexible and lightweight communication infrastructure for mobile robot teams. To address these challenges, we introduce NaoText, a role-based domain-specific language for specifying collaborative robot applications. It contributes dedicated abstractions to conveniently structure and implement collaborative behavior and thus, addresses the complexity challenge. To evaluate NaoText specifications, we introduce an interpreter architecture that is based on (REST) as a lightweight and flexible infrastructure for communication among robot teams. We exemplify the application of NaoText using an illustrative example of robots collaborating in a soccer game and discuss benefits and challenges for our approach compared to state-of-the-art in robot programming.

A framework for role-based feature management in software product line organizations

Product line engineering requires changes in approaching software development. Two main processes are to be established: creating a reusable infrastructure, and utilizing it for developing products. In practice, these two processes cannot strictly be separated as product enhancements are requested frequently by customers and a changeable infrastructure is essential to react on market needs. Thus, various approaches, such as proactive, reactive, or agile, have been introduced to handle changes. At a finer level of granularity, however, changes comprise many activities with variable duration and thus result in sets of concurrent and overlapping software development activities. This paper, therefore, investigates changes in more detail and assumes that provisioning comprehensive information on changes and respective states are crucial to organizations for keeping a software product line manageable. As features are a common notion used in software engineering to reflect customer requirements, the paper proposes a conceptual framework for managing feature information and for defining role-specific views throughout all life cycle processes. Its concepts have been derived from an industrial context.

Automated verification of feature model configuration processes based on workflow Petri nets

Modern software systems are highly configurable in order to satisfy diverse customer requirements and application contexts. Feature models provide a well-established formalism for tailoring configuration spaces of applications. Thereupon, multi-view staged configuration approaches modularize feature models for separation of concerns and apply workflow modeling for scheduling configuration decisions. However, the complex, often oblivious and even cyclic logical dependencies among configuration decisions obstruct compositional semantics of feature model views thus spoiling intuitive modeling and rigorous analysis of staged configuration processes. In this paper, we apply workflow Petri nets (WPNs) as a formal operational model for staged configuration that makes explicit causal dependencies among feature selections. For the internal separation into composable configuration stages we further adopt the principles of open workflow nets. It is shown that the soundness notion of WPNs naturally coincides with fundamental correctness and liveness properties to be verified for staged configuration processes. We present a prototype implementation for an automated computation of staged configuration processes and provide experimental results concerning scalability properties.