Ivan Paez Anaya - Integrating Predictive Analysis with Self-Adaptive Systems

Recent literatures surveys have shown that the temporal aspects of self-adaptation is an area under explored. Furthermore, most of the current approaches are reactive. In some scenarios such as safety-critical systems (e.g. environmental monitoring), where the cost of failure could involve casualties, public and private property damage, the need for pro-activeness is obligatory. Current monitoring mechanisms in Self-adaptive systems are focus on instant values of the environment. This brings the problem of possible unnecessary adaptations that could happens in transients situations, than means that the event that triggers an adaptation is shorter than the time the system needs to carry on with the adaptation. Another scenario in which pure reactive adaptive adaptation is unfit is when we are facing seasonal behavior (e.g. hourly, daily, weekly, monthly phenomenons.). Failure to recognize these patterns can derive in oscillatory adaptations going from one state to another in a pendulous manner. My research topic focus on the temporal aspects of self-adaptation aiming to improve the current state of self-adaptive systems by introducing predictive analytics techniques into the control loops. Techniques such as data mining, machine learning algorithms and predictors. The contributions of combining Self-Adaptive approach with Predictive Analytics are summarized in the three following points: 1) Multi objective selection of input variables for predictive models. 2) Balancing functional and nonfunctional properties of predictive models. 3) Predictive models as fitness functions in SBSE. We integrate predictive analytics in three phases of the software process. An design time, we propose a multi-objective features input selection, with this, we are able to select those characteristics that best describe the behavior of the system. The machine learning techniques that can be used in this phase are data preprocessing, redimensioning and dimensional analysis. Detecting erroneous readings by removing out-layers form the data is also a beneficial in this phase. At runtime, we propose for the the self-adaptive systems classification and categorization techniques for drawing predictions that will feed the decision making mechanism in the control loop of the autonomic systems. As well as trade-off analysis of functional and non-functional properties of the system by using techniques such as correlation analysis of input variables.

Christopher Bailey - Handling Insider Threats through Self-Adaptation

Authorisation infrastructures are an integral part of any network where electronic resources require protection. As networks expand and organisations begin to federate access to their resources, authorisation infrastructures become increasingly challenging to manage. This talk explores the automatic adaptation of authorisation assets (such as, access control policies and subject access rights) in order to handle the identification and mitigation of insider attacks, in regards to the abuse of privileged access. We demonstrate adaptation with an autonomic controller, capable of managing policy based role/attribute access control authorisation infrastructures. The autonomic controller implements a feedback loop to monitor the authorisation infrastructure in terms of its assets and subject behaviour, analyse a modelled system state for evidence of malicious behaviour, and act upon malicious behaviour by controlling future authorisation decisions. We discuss our evaluation techniques as well as preliminary results gained through the simulation of malicious behaviour within a deployed federated authorisation infrastructure.

Matthias Becker - Engineering Resource-Efficient and Elastic Self-Adaptive Systems

Large business information systems nowadays run in cloud computing environments that have virtually unlimited computing resources. However, a resource-efficiency is still desired, because these computing resources are typically paid per use. Self-adaptive systems can autonomously adapt their architecture during operation and thus can potentially operate resource-efficient at all times. However, in current practice, self-adaptive systems are implemented and configured based on experience of software architects and rule-of-thumb. Design deficiencies limiting resource-efficiency and elasticity are often discovered in late development phases, i.e., in testing or even in operation. We are developing SimuLizar, an engineering method that supports software architects to model resource-efficient and elastic self-adaptive multi-resource systems. The method supports software engineers with identifying and deciding quality trade-offs using the RELAX requirements language. Multiple relevant quality metrics can be predicted with SimuLizar such that design deficiencies in the software architecture and self-adaptation capabilities that limit resource-efficiency and elasticity can be identified already at design-time. Thus, unnecessarily high operation costs can be prevented and marginal costs for higher workloads become predictable.

Amel Belaggoun - Is it Useful to Make AUTOSAR Fully Dynamic?

Increasingly, safety critical applications must function reliably and dynamically adapt their structure and /or behavior at runtime in response to changing conditions and environment. Runtime reconfiguration is a powerful mechanism to perform such adaptation. While few works have started developing techniques to perform software dynamic reconfiguration in real-time embedded systems and specifically in AUTOSAR, no work has provided an approach to perform safe runtime adaptation in AUTOSAR. I will present a first step in addressing this challenge.

Lorena Castaneda - Supporting Senior Shoppers with Self-Adaptive Personalized Web-Tasking

E-commerce applications are highly popular among internet shoppers. However, changes on the variety of devices, services and applications add complexity during the web task execution. While technologically savvy people can easily handle this complexity, seniors might be challenged by numerous interaction steps. In particular, health conditions and degenerative diseases affect user’s capability of interacting with devices or performing web tasks properly. Personalized Web-Tasking (PWT) systems automate ordinary and repetitive web tasks while exploiting the personal context of the user to deliver personalized features. Current approaches of web automation and personalization rely on recorded information about users and their web interactions. In addition to this, self-adaptive PWT systems are capable to dynamically understand users’ changing goals and situations, while adapting itself at runtime. Our research focuses on the context-aware and self-adaptive capabilities of PWT systems. The expected results of this work include: (1) a modelling specification for PWT, (2) a reference model for the design of PWT systems, and (3) a PWT model processing infrastructure. This talk presents our recent contributions and ongoing work in the realization of self-adaptive PWT systems. We describe an e-commerce scenario focused on seniors in order to illustrate the importance of self-adaptive PWT systems capable to assist users in the fulfilment of personal goals using internet technologies.

Mahdi Derakhshanmanesh - The Vision of Model-Integrating Development

The development of complex software systems remains a challenge. Model-driven development approaches have been proposed and applied to achieve a certain degree of automation. Moreover, the use of models at runtime receives more and more attention as an enabling technology for separating concerns into explicit models and for controlled change operations on the running software, e.g., to realize self-adaptation. Despite their central role in the software development process, we observe that models are still not being treated as first-class entities: shipped software products still primarily consist of code. In order to leverage the full potential of models, we propose a realization concept for Model-Integrating Components (MoCos) that is compatible with existing component technologies. One can freely choose the portion of (executable) models and code when realizing a software component. These MoCos are the essential building blocks for a novel Model-Integrating Development (MID) approach to software engineering where models and code are artifacts with equal rights.

Benedikt Eberhardinger - Testing Self-adaptive, Self-organising Systems

The characteristics of self-adaptive, self-organising systems lead to a significant higher flexibility and robustness against a changing environment. Unfortunately, this flexibility makes it hard to test these systems adequately. To assure their quality, however, it is inevitable to do so. Our approach for testing is based on the Corridor Enforcing Infrastructure (CEI), an architectural pattern for SOAS. The CEI uses the concepts of feedback-loops to continuously observe and control the system if necessary. On that account monitoring is used to achieve situational awareness which is prerequisite to organise the system in a way to fulfil its requirements. The bulk of concepts and techniques used in the CEI for controlling and organising the system is triggered by the violation of constraints. An error-free CEI will consequently guarantee a system that fulfils its requirements at every time. On this account, we claim that testing SOAS can be achieved by testing the CEI. Here we benefit from specific characteristics: we are able to reduce the relevant state space of the system to be tested tremendously and to gain a clear distinction between correct and incorrect behaviour out of the concepts of the CEI — essential for evaluating the tests. SOAS are highly distributed systems, interacting locally to solve problems. This locality is exploited in our approach, since many test cases can focus on single agents or small agent groups the system is composed of; this focus makes it easier to execute and evaluate them. Furthermore, it is possible to use the test results of local agents and agent groups to make a statement about the whole system.

Antonio Filieri - Automated control synthesis for dependable software adaptation

Self-adaptation enables software to cope with changing and unpredictable environments. Control theory provides a variety of mathematically grounded techniques for adapting the behavior of dynamic systems. While it has been applied to specific software control problems, it has proved difficult to define methodologies allowing non-experts to systematically apply control techniques to create adaptive software. However, at a convenient level of abstraction, broad classes of problems reveal similar behavioral properties, allowing for the automated identification of a suitable dynamic model and the synthesis of controllers with formally proved quality guarantees. As many practical problems fall into treatable classes, automated control synthesis may draw in the near future a new path toward dependable software adaptation.

Alexander Frömmgen - Design Principles for Adaptive Communication Systems

Today’s distributed systems have to work in changing environments and under different working conditions. To provide high performance under these changing conditions, distributed systems and communication systems have to implement adaptive behaviour. My research concentrates on design principles for such adaptive communication systems. Therefore, I am interested in the general description of adaptive behaviour, the possible configurations and compositions of mechanisms, as well as the concrete execution of transitions between these mechanisms. I am focusing on different network layers, especially the application layer and network protocols. My work is integrated in the Collaborative Research Centre “MAKI” (Multi-Mechanism Adaptation for the Future Internet), which develops adaptive communication systems.

Simos Gerasimou - Runtime Quantitative Verification in Self-Adaptive AI Systems

Modern software systems need to self-adapt while providing service in order to cope with the uncertain environment in which the systems operate, changing requirements and evolution occurring in the system themselves. Consequently, trustworthy and dependable operation in these systems is very important. This is more evident when these systems are deployed in safety-critical or business-critical applications where they are expected to adhere to strict performance, resource usage and other quality-of-service (QoS) requirements. Runtime quantitative verification, a new approach for the analysis of systems exhibiting stochastic behaviour, is a key technology in achieving both adaptation and continual compliance with QoS requirements. Nevertheless, existing runtime quantitative verification techniques suffer from significant overheads and cannot comply with the strict execution time and resource usage constraints that characterise most runtime scenarios. The research we carry out aims at addressing some of these challenges.

Ilias Gerostathopoulos - Adaptation in Ensemble-Based Component Systems: From System Goals to Architecture Configurations

Ensemble-based component systems (EBCS) is a class of software component systems that features the modelling constructs of autonomous components and ad-hoc groups (called ensembles). These constructs have proven suitable for the development of networked, highly dynamic cyber-physical systems, such as an intelligent decentralised car parking system or an emergency coordination system. In this talk, I will focus on the problem of designing such systems so that their situation-specific system-level goals are consistently mapped to implementation-level artefacts. I will present a design method – IRM-SA – that allows for such systematic design. The method establishes traceability between requirements and architecture in EBCS, while the outcome of the method (IRM-SA model) can be used at runtime to provide system adaptation in form of architecture reconfiguration.

Sinem Getir - Model-based Probabilistic Incremental Verification for Evolving Systems

Probabilistic verifiation play an important role for verifying the quality attributes such as reliability, safety and performance. On problem however is, that system re-verification is needed whenever the software changes. Re-verifying of a changing model multiple times is expensive. Recently, incremental approaches have been
found to be promising for the verification of evolving and and self-* systems. However, substantial improvements have not yet been achieved for evaluating structural changes in the model. This talk discusses an incremental verification framework that allows efficient evaluation of the changing models.

Sebastian Götz - Multi-Quality Auto-Tuning: From Energy-neutrality to Robots and Roles

In this talk, I'll first outline a development and operation framework for self-optimizing software systems called MQuAT (Multi-Quality Auto-Tuning). Then, I'll focus on (software-)energy-optimization in particular, including a technique to save energy by frequency scaling and an approach to assess and compare the energy consumption of mobile applications. Additionally, I'll present a concept and prototype to realize energy-neutral software systems. Finally, I'll discuss work in the area of model-driven robot software engineering.

Inti Gonzalez-Herrera - Resource reservation in pervasive middleware

The interest on distributed component-based software development is growing stronger due to, among other factors, the future Internet of Things (IoT). In a vision of the IoT, the infrastructure is shared among many stakeholders who deploy their own components independently. As a result, no single stakeholder is able to centrally manage the computing resources and such a task must be carry on by the middleware. In a context where components share resources as memory and CPU cycles, the middleware must provide the each component with the resources it demands but it also must enforce quotas of consumption. To do so, the middleware monitors the system and executes adaptations as components’ migration, modification of components’ behaviour and modification of communication’s patterns. This research focuses in two aspects of the control loop, monitoring and execution of the plan. In particular, it aims at providing mechanisms for Java-based middleware to: i) perform resource consumption monitoring, ii) enforce resource reservation and, iii) execute runtime reconfiguration to provided distributed resource reservation. We describe mechanisms to perform scalable resource consumption monitoring and reservation. We also discuss approaches to identify the source of a faulty behaviour regarding resource usage. Finally, we present our vision on distributed decision making about resource reservation and how the paradigm of Models@runtime can be used as foundation for its implementation.

Robert Heinrich - Integrating Observation and Modeling Techniques to Support Adaptation and Evolution of Software-intensive Systems

The increased adoption of service-oriented technologies and cloud computing creates new challenges for the adaptation and evolution of long-living and software-intensive systems. Software services and cloud platforms are owned and maintained by independent parties. Software engineers and system operators of these systems only have limited visibility and control over the third-party elements. Traditional monitoring provides software engineers and system operators with execution observation data which are used as basis to detect anomalies. If the services and the cloud platform are not owned and controlled by the system engineers, monitoring the execution is a challenging task. The aim of our research is to develop and validate advanced techniques which empower the system engineers to observe and detect upcoming quality flaws and anomalies of the execution of software-intensive systems. For this, we extend and integrate previous work on adaptive monitoring, software system modeling and analysis. We apply models@runtime as means to adjust the observation and anomaly detection techniques during system operation. For demonstrating the feasibility and potential benefits gained and for providing feedback to guide the research, we continuously evaluated our results using the established research benchmark CoCoME.

Alessia Knauss - Elicitation, Discovery and Evolution of Contextual Requirements

Increasingly complex socio-technical systems operate in continually changing environments. Such systems involve the interplay of human actors and technology. Changes in the context of the system might lead to changed user needs requiring a socio-technical system to adjust its behaviour. Due to uncertainty and increasingly changing operational environment such systems need to update their knowledge about end-user needs and context that influences the execution of end-user requirements. While self-adaptive systems are designed to address the challenges of changing context, the uncertainty in the operational environment poses outstanding challenges to capture and evolve requirements at runtime. By exploiting the concept of contextual requirements as composed of requirements and context as two entities that can evolve separately, my dissertation presents a framework for the analysis and discovery of contextual requirements at runtime. In three studies I explore the usefulness of existing techniques, i.e., requirements elicitation techniques and machine learning techniques, for the elicitation, discovery and evolution of contextual requirements. In my presentation I will give a short overview of my PhD thesis.

Filip Krikava - System-Level Abstractions for Integrating Control Mechanisms into Software Systems

Control theory provides solid foundations and tools for designing and developing a reliable feedback control that drives software adaptations at runtime. However, the integration of the resulting control mechanisms is usually left to an extensive handcrafting of a non-trivial implementation code. This is a challenging task when considering the variety and complexity of contemporary distributed computing systems. In our work, we aim to address this by providing flexible system-level abstractions in a form of runtime software models—i.e., models that are causally connected with running systems to monitor and manage specific aspects of their state and their environments. Such models allow to seamlessly observe and modify the underlying systems without the need for coping with low-level implementation and infrastructure details. Furthermore, techniques from model-driven engineering, such as model consistency checking and model transformations, can be used to systematically develop monitoring and reconfiguration parts of feedback control loops. As a result, this should allow researchers and engineers to experiment and to put easily in practice different self-adaptation mechanisms and policies.

Juan Carlos Muñoz Fernández - Requirements Engineering Framework for Self Adaptive Software Systems

Self-adaptation is a promising approach to manage the complexity of modern software systems that are required to adapt themselves autonomously. The dynamic nature of changing and evolving requirements is an important aspect in these systems. This kind of systems must be able to adapt to these changes, being it necessary to have a representation of their own requirements definition and to process their changes at runtime. Several results have shown that dynamic software product lines are feasible and useful in different software contexts including the modeling of requirements. From a literature review, we conclude that the modeling and characterization of requirements for SAS systems is an area that requires further exploration to be fully solved. With this project will work the in the definition of the requirements engineering phase in the software development life cycle for self-adaptive systems based on the language proposed by Sawyer et al. With improvements on this language to propose a requirement framework aim at advancing the way of specifying requirements for SAS systems.

Liliana Pasquale - Topology Aware Adaptive Security

Adaptive security systems aim to protect valuable assets in the face of changes in their operational environment. They do so by monitoring and analysing this environment, and deploying security functions that satisfy some protection (security, privacy, or forensic) requirements. This talk suggests that a key characteristic for engineering adaptive security is the topology of the operational environment, which represents a physical and/or a digital space - including its structural relationships, such as containment, proximity, and reachability. For adaptive security, topology expresses a rich representation of context that can provide a system with both structural and semantic awareness of important contextual characteristics. These include the location of assets being protected or the proximity of potentially threatening agents that might harm them. Security-related actions, such as the physical movement of an actor from a room to another in a building, may be viewed as topological changes. The detection of a possible undesired topological change (such as an actor possessing a safe’s key entering the room where the safe is located) may lead to the decision to deploy a particular security control to protect the relevant asset. By monitoring changes in topology at runtime one can identify new or changing threats and attacks, and deploy adequate security controls accordingly. The talk elaborates on the notion of topology and provides a vision and research agenda on its role for systematically engineering systems that satisfy their security, privacy and forensic requirements.

Alexander Schiendorfer - Constraints in Self-organizing, adaptive Systems

Self-organizing, adaptive systems (SOAS) such as those considered in Organic Computing benefit from redundancies introduced to assert a certain fault tolerance and the ability to stay functional in case of failures. Resource allocation problems such as the distribution of a given predicted energy demand to a set of power plants are instances of tasks that can benefit from a self-organizing structure to deal with uncertainty and scalability. However, in order to control these systems (or even understand their behaviour), we need to devise algorithms and techniques dealing with their complex nature. Constraint programming and mathematical programming are successful paradigms designed to model a variety of satisfaction and optimization problems and solve them with generic algorithms. Therefore, a systematic integration of these declarative approaches into the engineering process of self-adaptive software is desirable. We present several techniques that are designed to incorporate preferences by means of soft constraints, physical relational models to add a semantic layer over pure constraint models and abstraction techniques to scale systems using hierarchies. An overview of this approach has been published in the Proceedings of the Second Organic Computing Doctoral Dissertation Colloquium 2014 and is available online.

Eric Schmieders - Runtime Model based Privacy Checks of Cloud Services

Cloud elasticity enables cloud services to automatically adapt to workload changes by dynamically allocating and de-allocating hardware resources. Hardware allocation is achieved by virtual machine replication and migration that adds, removes, and re-deploys service components within or across data centers and thus alternates components and their deployments during runtime. Dynamically replicated or migrated components being part of complex cloud services may transfer data (even via intermediate components) to locations that are excluded by privacy policies. As dynamic adaptations are unpredictable during design time, changed compositions and deployments have to be observed and checked against privacy policies during runtime. In order to support the prevention of privacy violations, we focus on potential privacy violations that result from potential data transfers occurring once related cloud service functions are invoked. However, potential data flows are not observable, as they are not reflected in replication and migration events emitted by cloud infrastructures. This makes the detection of potential privacy violations problematic. To tackle this problem, we explore the utilization of runtime models in order to reflect cloud services, their components, and interactions, which allows for reasoning on potential privacy violations among the cloud service composition. Based on the key idea of detecting privacy violations on runtime models, this talk will discuss two main technical challenges faced when putting the approach into practice and, further, points out how we address these challenges: (a) the challenge of observing cloud elasticity despite the limited visibility of cloud internals and (b) the challenge of checking realistic cloud services of large size and complexity.

Adnan Shahzada - A Comprehensive Framework for the Development of Dynamic Smart Spaces

The conception of efficient smart spaces requires a reliable framework for their design, implementation, testing, and deployment. The development life cycle of these smart spaces differs greatly from the conventional software systems, as it poses various challenges during each development phase such as: provision of appropriate design abstractions, integration and coordination of heterogeneous components, incremental evaluation and deployment of the system, and formation of ad-hoc network to cater dynamism in diverse smart spaces. There have been numerous solutions proposed to solve different aspects related to smart spaces, but we still lack a conceptual framework that provides tools for the whole development life cycle. This work presents a generic and comprehensive development framework that allows the developer to move seamlessly from a fully virtual, simulated solution to a completely deployed system. The framework uses a group-based organization for the coordination and cooperation among the heterogeneous components of a smart space. It also provides interfaces to surrogate certain sets of system components through external simulators, and ease the deployment of physical elements. The usefulness of the proposed framework has been demonstrated with the help of diversified smart spaces.

Romina Spalazzese - Automated approaches to build self-adaptive systems

Nowadays, our living environment is pervaded by a wide variety of heterogeneous digital systems that are connected to the Internet. The number and kind of connected systems have been always increasing and this growth trend will continue in the future. In this context, systems meet and know each other dynamically, when they want to start to interoperate to achieve some goal. Key challenges, thus, are to enable systems to interoperate seamlessly and to guarantee some properties despite context changes. Given the huge heterogeneity and dynamism characterizing the described environment, automated solutions appear to be the only way to face such challenges timely and with the needed level of flexibility. In this talk I will present our recent and current work and future research directions. I will describe a solution for the automated synthesis of connectors (a) that takes into account performance concerns during the synthesis process and (b) whose synthesized connectors are (self-)adaptive with respect to runtime performance requirement changes. Moreover, I will talk about our ongoing work on an approach to automatically build context-aware (self-)adaptive systems. Our approach elicits automatically relevant context-variability and properly extends the systems to make them self-adaptive to context changes.

Nina Taherimakhsousi - Context-based Face Recognition for Smart Application

Face recognition is a challenging computational task which assigns an identity to detected faces. There has been prodigious improvement on face recognition in recent years. At first, researchers focused on face recognition under controlled conditions. Facilitated by classic datasets, researchers investigated face recognitions invariant to changes in pose, facial expression and illumination. Despite their initial success, substantial face recognition research is required in less-controlled or uncontrolled conditions, such as in personal photo collections, web images and videos, as found in on-line social networks. Searching over a large set of images amplifies the need more robust face recognition methods. I propose to investigate real-time context-based approaches for face recognition available to improve face recognition processes. My expected contributions include a context-based face recognition framework for mobile devices to improve accuracy rate. For example, with the help of location sensors on the mobile devices annotated images with location information. I propose an algorithm that exploit context to reduce the search space of face recognition and, therefore, achieve better result. Photos are clustered by locations on the server that are then associated with a face classifier. A client can send a query to the server by uploading a subject image with the location information. The face recognition algorithm suitable for narrow the search space on the server. My results are quite promising with respect to accuracy and queries are answered in real-time.

Sebastian Wätzoldt - Modeling Collaboration in Cyber-Physical Systems

Cyber-Physical Systems (CPS) evolved from embedded systems that combine physical processes with computing. Whereas embedded systems are mostly closed, self-contained and do not expose the computing capability to the outside, an increasing number of devices and demands of combined functionalities led to a more and more interconnection of embedded systems to so-called networked embedded systems. As a consequence, such isolated control systems and afterwards interconnected embedded systems become open to its environment and build different variants of cyber-physical systems that integrate the cyber (software) and physical part. While a CPS is a federation of open, ubiquitous systems that dynamically and automatically reconfigure themselves and cooperate with other CPS, the modeling of this cooperation (collaboration) has yet not gained the necessary attention as the modeling of feedback loops traditionally emphasized in embedded system design still dominates the thinking. By lifting collaborations to the level of first class entities when modeling CPS and by covering diverse forms of feedback loop interactions such as hierarchy as well as adaptation a modeling language can enable the appropriately exploring of the solution space for CPS. In this talk, I will present ideas of my current research concerning the modeling of collaboration in CPS.