On May 24th and 25th I participated in the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2011), which was co-located with the 33rd International Conference on Software Engineering (ICSE 2011), in Waikiki, Honolulu, Hawaii, USA. I presented a paper called “Awareness Requirements for Adaptive Systems”, which is part of my ongoing PhD work in the University of Trento, Italy.
Back in Trento, some colleagues of mine also work in the area of adaptive systems and would probably be interested in other works that were presented in the Symposium. For this reason, I had already planned to take notes on each presentation and compile a report that I would later send privately to them.
However, on the Welcome note that was in the ICSE material I received when I checked in the conference, I found out that ICSE had a Twitter account (@ICSEconf), a conference blog (http://icse2011.posterous.com) and a workshops blog (http://icse2011w.posterous.com). I then started following @ICSEconf and asked if they would be interested in this summary of the SEAMS presentations, to which they responded positively.
For this reason, I decided to make it a blog post instead of a private report. The downside (for me) is that authors will now be able to see what I wrote about their work and if I write something wrong or imprecise it will look very bad for me. So I would like to apologize in advance if I misunderstood something on any presentation or if I fail to convey the main message of the work. Feel free to leave comments correcting me or adding any further information you might think is important.
Lastly, these are one paragraph summaries that just very briefly explain what was presented by each author and if this short description makes you think the work might be interesting, look for the full paper which are supposed to be published by ACM/IEEE or contact the authors. You can check the full program of the symposium at the SEAMS website.
Without further ado, let’s see those summaries, presented in the same order as the program…
Session I – Applications
The author of the first paper to be presented – “Application of Software Health Management Techniques” – couldn’t make it to the conference because of problems with his flight. The organizers of the conference said a video of his presentation was submitted and it would be published on the SEAMS website soon.
Licia Capra (University College, London, UK) presented “Dynamic Updating of Online Recommender Systems via Feed-Forward Controllers”. In their work, Recommender Systems (in Web 2.0) are implemented as Self-Adaptive Systems, but because the information required to adapt cannot be monitored and used as feedback, a feed-forward controller was used with positive results.
Christopher Zhong (Kansas State University, USA) presented “Runtime Models for Automatic Reorganization of Multi-Robot Systems”. Their proposal is to model goals, roles and capabilities of robot agents (using GMoDS) in order to adapt to failures at runtime.
Session II.a – Modeling and Languages
Markus Luckey (University of Paderborn, Germany) presented “Adapt Cases: Extending Use Cases for Adaptive Systems”. Adapt Cases are an extension of UML Use Cases for Self-Adaptive Systems, which is supposed to fill the gap of Logical Design between Requirements and Technical Design.
Hiroyuki Nakagawa (University of Electro-Communications, Japan) presented “gocc: A Configuration Compiler for Self-Adaptive Systems Using Goal-oriented Requirements Description”. The configuration compiler – gocc – reads KAOS models and generates architectural configurations for Self-Adaptive Systems. Such configurations use multiple control loops based on an extension introduced in KAOS. Goal elements are divided in 3 categories, one for each part of the control loop: Monitor, Analyze & Decide, Act.
Guido Salvaneschi (Politecnico di Milano, Italy) presented “An Evaluation of the Adaptation Capabilities in Programming Languages”. Their work proposes a framework for analyzing the adaptation capabilities of programming languages, covering 6 dimensinos: Abstraction, Generic Code, Variation Combination, Variation Activation, Modularization and Safety.
Session II.b – Research Roadmap on Sofware Engineering for Self-Adaptive Systems
Rogério de Lemos (University of Kent, UK) reported on the Dagstuhl Seminars on Software Engineering for Self-Adaptive Systems. A draft report that summarizes the state of the art in the area and present research challenges for the future is available at the SEAMS website and will be refined into a chapter of a book on Self-Adaptive Systems that is coming soon. In the presentation, he briefly talked about the topics that the Dagstuhl papers focused on. The 1st paper in 2009 talked about modeling, requirements, engineering and assurances. The 2nd paper, the aforementioned draft and future book chapter, discusses the design space for adaptive solutions, processes, from centralized to decentralized control and practical run-time verification & validation.
Session III – Monitoring and Evaluation
My paper, “Awareness Requirements for Adaptive Systems”, opened the session. In it, I presented a new class of requirements called “Awareness Requirements” that consist of requirements that talk about the success/failure of other requirements at runtime. In a goal-oriented requirements engineering approach, this new concept represents the requirements for the feedback loop, which monitors for requirements failures at runtime. In my presentation I quickly talked about Awareness Requirements characterization, elicitation, formalization and validation using a requirements monitoring framework.
Sowmya Balasubramanian (University of Victoria, Canada) presented “Characterizing Problems for Realizing Policies in Self-Adaptive and Self-Managing Systems”. Their work applies greedy algorithms to optimization problems that are of the interest of the SEAMS community.
Norha Villegas (University of Victoria, Canada) presented “A Framework for Evaluating Quality-Driven Self-Adaptive Software Systems”. Such framework is composed of 7 dimensions for the evaluation of approaches for the development of Self-Adaptive Software (SAS). Sixteen proposals were evaluated in a four-phase approach: characterize the SAS; identify adaptation properties that apply for evaluation; map them to quality attributes; devise evaluation metrics. The purpose of the proposal is to improve SAS assessment.
Nikolaus Huber (Karlsruhe Institute of Technology) presented “Model-based Self-Adaptive Resource Allocation in Virtualized Environments”. The work is an approach for Self-adaptive Resource Allocation based on the Collect – Analyze – Decide – Act feedback loop. Experiments show how the approach can be used to maintain SLAs and optimize resource usage.
Session IV – Run-time Support
Daniel Sykes (Imperial College London, UK) presented “FlashMob: Distributed Adaptive Self-Assembly”. They propose an approach for distributed assembly of components of an architecture, extending previous work, which was centralized. Information is distributed using the Gossip framework. When something fails, components spread death certificates for specific configurations and the system adapts by backtracking and generating a different setting.
Marisol García Valls (Universidad Carlos III de Madrid, Spain) presented “Supporting Service Composition and Real-time Execution Through Characterization of QoS Properties”. In the context of the iLAND EU project, the proposal uses a service-oriented and middleware-based approach for real-time reconfiguration. The main problem tackled is the characterization of services using Quality of Service (QoS) properties.
Edzard Hoefig (Fraunhofer FOKUS, Germany) presented “On the Performance of UML State Machine Interpretation at Runtime”. Their proposal splits behavior representation in state-chart diagrams and run-time components that reason over (interpret) the diagrams. The main contribution of the paper is the evaluation of the performance of such interpretation and the conclusion that it is a suitable approach for self-adaptation.
Mahdi Derakhshanmanesh (University of Koblenz-Landau, Germany) presented “GRAF: Graph-Based Runtime Adaptation Framework”. They propose a model-centric approach to support the migration of existing software to adaptive software. Adaptivity is done through querying, transforming and interpreting the model.
Session V – Keynote
Carlo Ghezzi (Politecnico di Milano, Italy) delivered a keynote on “The fading boundary between development time and run time”. Starting from the Zave & Jackson classic D, S |= R statement, and given the assumptions that nowadays we have unprecedented degree of change, which triggers a need to accomplish change in a self-managed way, professor Ghezzi focused on changes in D (adaptation) instead of changes in R (evolution). He went on to present some research that focused specifically on non-functional requirements and systems that are composed of many different external components. The approaches were mainly model-driven, and prof. Ghezzi advocated that models are actually very good for continuous change. Models of D are continuously updated to adapt and, in this way, the boundary between development time and runtime vanishes. Adaptation is done at the model level, and that later reflects in the code and in runtime.
Session VI – Assurance
Benoit Baudry (INRIA, Rennes, France) presented “Pairwise Testing of Dynamic Composite Services”. In a previous work, given an orchestration of services, they accomplished calculation of quality of service (QoS) properties for atomic services and of a single configuration that merged some specific services. However, in some systems the possible set of configurations can be too many to calculate these properties (225 in their example). Their work, then, adapted pair-wise testing over feature models that represent the orchestration as a systematic sampling technique.
Rogério de Lemos (University of Kent, UK) presented “Dynamic Plans for Integration Testing of Self-adaptive Software Systems”. Their work consists on a framework for dynamic generation of plans for integration testing of Self-Adaptive Systems, based on workflows for coordination, AI planning and MDE transformations.
Björn Bartels (Technical University of Berlin, Germany) presented “A CSP-based Framework for the Specification Verification and Implementation of Adaptive Systems”. CSP specifies and verifies properties of concurrent systems. They propose, then, a framework based on CSP for the implementation of SAS. This way, established proof tools for CSP can be used.
Franck Fleurey (SINTEF, Norway) presented “A Model-Driven Approach to Develop Adaptive Firmwares”. Their work applies adaptive techniques to very small embedded systems (e.g. in sensor networks). They use event-driven state machines to model behavior, aspect-oriented modeling techniques to model runtime variability and a domain specific modeling language for the adaptation policies.
Session VII.a – Position Papers (5 minute pitch of short papers)
Iuliam Neamtiu (University of California at Riverside, USA) presented “Elastic Executions from Inelastic Programs”. He presented the context of an “elastic application” which is one that is able to adapt to changes in hardware resources at runtime. Then there’s a problem of legacy applications which are inelastic. The work, then, proposes to run inelastic applications in an elastic way via dynamic updating at runtime, with safety guarantees.
Markus Stumptner (University of South Australia) presented “A Model-driven Framework for Runtime Adaptation of Web Service Compositions”. They motivate the work by stating that in a context where Web Services implement Business Processes, this environment is very unreliable, services might become unavailable at any given time. Using a model-driven approach, the work proposes run-time adaptation of the composition of services.
Raquel Almeida (University of Coimbra, Portugal) presented “Benchmarking the Resilience of Self-Adaptive Sofware Systems: Perspectives and Challenges”. They claim that after performance, dependability and security benchmarking (previous, existing work), we now need resilience benchmarking, which consists of evaluating the capability of self-adaptation of a system and the impact of such adaptation on service providers. Research challenges are defining benchmark elements and procedures for this and assure its validation.
Martin Becker (Fraunhofer IESE, Germany) presented “Approaching Runtime Trust Assurance in Open Adaptive Systems”. They base the work on the increasing need for openness, flexibility but also trustworthiness in systems: safety, reliability, security and even certification. They go on to propose semi-formal, conditional safety certificates, called ConSerts, that could be applied to Adaptive Systems.
Danny Weyns (Katholieke Universiteit Leuven, Belgium) presented “On Interacting Control loops in Self-Adaptive Systems”. The work is based on the need for multiple MAPE loops to manage complexity (separate concerns), scalability (local adaptation) and cross multiple ownership domains. They propose coordination of multiple control loops, integrating M and P components. Also, their work proposes a systematic approach to manage complexity of interacting control loops and patterns for their development.
Session VII.b – Panel on Future Directions for Assurance of Self-Adaptive Systems
David Garlan (Carnegie Mellon University, USA) chaired this panel, first defining assurance as the ability to convince ourselves that our systems avoid bad behaviors, then presenting the questions for the panel: what are the challenges for assurances in Self-Adaptive Systems? How does it differ from assurances for traditional systems? What are promising paths towards good solutions? Following him, each of the panelists made quick presentations: Betty Cheng (University of Illinois at Urbana-Champaign, USA), Paola Inverardi (University of L’Aquila, Italy), Jeff Magee (Imperial College London, UK), and Andreas Zeller (Saarland University in Saarbrücken, Germany).
Session VIII – Frameworks
Sander Van Der Burg (Delft University of Technology, The Netherlands) presented “A Self-Adaptive Deployment Framework for Service-Oriented Systems”. The context consists of service-oriented applications deployed in networks of machines, which have a heterogeneous environment, with events (e.g., nodes failing) having implications in the overall system. Their work extends Disnix – a distributed service deployment tool built on top of the NIX package management tool – to deal with such events in the network and adapt the overall system.
Tharindu Patikirikorala (Swinburne University of Technology, Australia) presented “A Multi-model Framework to Implement Self-managing Control Systems for QoS Management”. The motivation is the common use of control loops in Self-Adaptive System works: fixed gain loops are limited and adaptive controllers are unstable under fast changing conditions. Therefore, their proposal is a multi-model controller (which integrates multiple controllers) that provides better performance and design flexibility than the previous alternatives.
Ryan Moore (University of Pittsburgh, USA) presented “Inflation and Deflation of Self-Adaptive Applications”. Their work deals with the resource allocation/availability problem and they advocate that applications should be aware of resource allocated to them and participate actively on the resource allocation process. They can do this by offering estimator and adapter components – the former indicates the needed resources while the latter deals with inflation (resources being given to the application) and deflation (resources being taken away) at runtime.
Closing and Plans for SEAMS 2012
Betty Cheng made a closing presentation of the Symposium and then handed over the microphone to Hausi Müller and Luciano Baresi for the SEAMS 2012 presentation. A website and call for papers is already available at http://www.seams2012.cs.uvic.ca/.