Karl M. Göschka

Software Engineering for Self-Adaptive Systems: A Second Research Roadmap

The goal of this roadmap paper is to summarize the state-of-the-art and identify research challenges when developing, deploying and managing self-adaptive software systems. Instead of dealing with a wide range of topics associated with the field, we focus on four essential topics of self-adaptation: design space for self-adaptive solutions, software engineering processes for self-adaptive systems, from centralized to decentralized control, and practical run-time verification & validation for self-adaptive systems. For each topic, we present an overview, suggest future directions, and focus on selected challenges. This paper complements and extends a previous roadmap on software engineering for self-adaptive systems published in 2009 covering a different set of topics, and reflecting in part on the previous paper. This roadmap is one of the many results of the Dagstuhl Seminar 10431 on Software Engineering for Self-Adaptive Systems, which took place in October 2010.

On Patterns for Decentralized Control in Self-Adaptive Systems

Self-adaptation is typically realized using a control loop. One prominent approach for organizing a control loop in self-adaptive systems is by means of four components that are responsible for the primary functions of self-adaptation: Monitor, Analyze, Plan, and Execute, together forming a MAPE loop. When systems are large, complex, and heterogeneous, a single MAPE loop may not be sufficient for managing all adaptation in a system, so multiple MAPE loops may be introduced. In self-adaptive systems with multiple MAPE loops, decisions about how to decentralize each of the MAPE functions must be made. These decisions involve how and whether the corresponding functions from multiple loops are to be coordinated (e.g., planning components coordinating to prepare a plan for an adaptation). To foster comprehension of self-adaptive systems with multiple MAPE loops and support reuse of known solutions, it is crucial that we document common design approaches for engineers. As such systematic knowledge is currently lacking, it is timely to reflect on these systems to: (a) consolidate the knowledge in this area, and (b) to develop a systematic approach for describing different types of control in self-adaptive systems. We contribute with a simple notation for describing interacting MAPE loops, which we believe helps in achieving (b), and we use this notation to describe a number of existing patterns of interacting MAPE loops, to begin to fulfill (a). From our study, we outline numerous remaining research challenges in this area.

Engineering complex World Wide Web services with JESSICA and UML

Complex Web services are comparable to large software systems thus their management and engineering process requires feasible and sophisticated methodologies and processes. Standard Web page editors and Web site management tools are not built for architecting complex services and cannot handle all tasks in the Web service engineering process. We introduced the JESSICA system to utilize object-oriented concepts for the Web service management. To support all stages of a services life cycle, from the architectural design via the object-based JESSICA model definition to the implementation and maintenance of Web documents and dynamic server scripts, we propose an engineering environment for Web services. The approach consists of three components: the graphical editor JAZZ provides visual features to model the architecture with objects that abstractly describe the entire Web service in the Uniform Modeling Language UML. The object-oriented language JESSICA defines Web service components of any granularity and their internal and external relations based on the Extended Markup Language XML. A Java-based compiler transfers the abstract service model into a consistent Web site. UML is used to support the decomposition of complex services into manageable units. The JESSICA system utilizes object-oriented concepts such as abstraction, encapsulation, inheritance and reuse of commonalities. We demonstrate the feasibility of our process on the engineering of the Vienna International Festival Web site.

Dynamic hyperlink generation for navigation in relational databases

Information processing is the key issue of the 20th Century. Databases are designed to store information and the World Wide Web has turned out to be the place for the gathering and distribution of information. While these two seem to be made for each other, there are inherent difficulties in linking them together due to quite different technologies. Nevertheless, it turned out that most real-life Web applications need an underlying database [1] to be stable, flexible and scalable. Appropriate design methodologies are hence needed to implement complex functionality. Moreover, there already exist databases which people want to connect to the Web with similar functionality as in classic implementations. Most of them rely on the proven technology of relational databases.

Explicit Connectors in Component Based Software Engineering for Distributed Embedded Systems

The increasing complexity of todays embedded systems applications imposes the requirements and constraints of distributed, heterogeneous subsystem interaction to software engineers. These requirements are well met by the component based software engineering paradigm: complex software is decomposed into coherent, interacting units of execution, the so called components. Connectors are a commonly used abstraction to model the interaction between them. We consequently contribute with the application of explicit connectors for distributed embedded systems software. Explicit connectors encapsulate the logic of distributed interaction, hence they provide well defined contracts regarding properties of inter-component communication. Our approach allows model level validation of component composition and interaction incorporating communication related constraints beyond simple interface matching. In addition, by using explicit connectors, the complexity of application components is reduced without the need for any heavy weight middleware. In fact, the set of all deployed explicit connectors forms the smallest possible, custom tailored middleware.

Refactoring an Automotive Embedded Software Stack using the Component-Based Paradigm

The number of electronic systems in cars is continuously growing. Electronic systems, consisting of so-called electronic control units (ECUs) interconnected by a communication network, account for up to 30% of a modern cars worth. Consequently, software plays an ever more important role, both for the implementation of functions and the infrastructure. In order to benefit from the reuse of software modules, the major automotive companies have standardized a large number of these modules in the context of the AUTOSAR consortium. In this paper we propose the refactoring of the AUTOSAR stack of system software modules by applying the component-based paradigm in order to increase the scalability of the software stack according to the particular requirements of the application. We demonstrate the feasibility of this approach by performing the refactoring of the modules FlexRay Driver and FlexRay Interface as an example and by deploying the resulting refactored components in a sample automotive application. Finally, we measure the execution time as well as the memory consumption of the refactored components and compare these measures to the measures obtained from the corresponding ordinary AUTOSAR modules.

Interaction Markup Language-an open interface for device independent interaction with e-commerce applications

Modern e-commerce applications tend to have a lot of different user interfaces; the most important today are Java and HTML, but there are also emerging technologies like agents, WAP cellular telephones, or even 3D environments (VRML). The difficulty is to make all those interfaces work together with the same application in an almost similar and transparent way and to keep them synchronized with each other during the lifetime of the application. Our approach is to describe the interactions of a user interface (rather than the elements or components) with an XML description called IML (Interaction Markup Language). Unlike UIML (User Interface Markup Language), these interactions are then assigned to technology-specific interactions first, which in turn are then finally assigned to a particular implementation. An IML description is also stable against future developments: to enable an application for a new device, only the IML renderer has to be implemented.

Source Code Based Component Recognition in Software Stacks for Embedded Systems

Current trends in embedded systems software aim at an increase of reusability, exchangeability and maintainability and thus at a significant reduction of time- and costs-to-market. One way to reach these goals is the adaption of Component Based Software Engineering (CBSE) for the embedded systems domain. Unfortunately most existing embedded systems applications are realized as coarse-grained layered or even monolithic software that can hardly be reused. This paper demonstrates how to recognize reusable and exchangeable components within existing typically monolithic or stacked embedded systems software via a semi-automatic analysis of the systems source code. The complexity of the proposed analysis is kept linear to code size by utilizing expert-knowledge on the application-domain, and deployment specific configuration data. To prove our approach, a functional decomposition for an existing automotive middleware stack is calculated and is finally compared to a human designed one.

A Unified Benchmarking Process for Components in Automotive Embedded Systems Software

During the last years, component based software development has become a well accepted software engineering paradigm within the automotive industry. This fact is not only reflected by upcoming development tools but also by newly arising automotive software standards. In component based software engineering, applications are built by assembling small reusable building blocks, the components. Typically more than one component implementation meets the application developers requirements, so proper selection of the assembled components becomes a key element of the whole procurement and engineering process. This papers contribution is twofold: First, a basic set of performance and dependability metrics and measures for automotive components is identified. Second, a unified benchmarking process is proposed, that allows an unambiguous comparison of distinct component implementations of a given component class.

Component Based Middleware-Synthesis for AUTOSAR Basic Software

Distributed real-time automotive embedded systems have to be highly dependable as well as cost-efficient due to the large number of manufactured units. To close the gap between raising complexity and cutting costs, upcoming software standards like AUTOSAR introduce a clear separation of concerns into their system architecture. An AUTOSAR application is built from components that deal with business logic only whereas infrastructural services are provided by standardized middleware. Unfortunately, this middleware tends to be heavy-weight due to its coarse-grained layered design. By applying a component based design to AUTOSARs middleware, a custom-tailored version for each specific application and system node can be built to overcome this problem. This paper demonstrates how to automatically synthesize component based middleware via the Connector Transformation: Component connectors in platform independent application models are utilized to automatically assemble platform- and application specific middleware. As a result, AUTOSAR middleware becomes custom-tailored and hence light-weight and flexible. In addition, the described synthesis algorithm is capable of incorporating timing annotations via interface contracts at model level, and thus reflects upcoming ambitions to cover real-time constraints at middleware level within AUTOSAR. To prove our approach we successfully synthesized middleware for a demonstrator application and compared it to its conventional counterpart.