phase5_bib.bib

% Encoding: UTF-8

@Article{Boton-Fernandez2015,
  author   = {Botón-Fernández, María and Vega-Rodríguez, Miguel A. and Prieto Castrillo, Francisco},
  journal  = {Concurrency and Computation: Practice and Experience},
  title    = {Intelligent self-adaptive resources selection for grid applications},
  year     = {2015},
  number   = {14},
  pages    = {3539-3560},
  volume   = {27},
  abstract = {Summary Grid computing is considered a promising trend, which enables the sharing of a wide variety of computational and storage resources geographically distributed. Despite the advantages of such paradigm, several problems have emerged during the last decade; most of them caused by an inefficient utilization of grid resources. The present contribution proposes an approach to improve the grid resources selection process. An optimization model for choosing grid resources in an intelligent way has been designed. A mathematical formulation to monitor the resources efficiency has also been established. Furthermore, the model provides a self-adaptive capability to grid applications, enhancing them for dealing with the changing environmental conditions. The model applies an artificial intelligence algorithm for ensuring an efficient selection. In particular, three different versions have been implemented. Each of them uses a different algorithm. Finally, during the evaluation phase of the model, the experimental tests were performed in a real grid infrastructure. The results show that the model improves the infrastructure throughput, by increasing the finished tasks rate and by reducing the applications execution time. Copyright © 2014 John Wiley \& Sons, Ltd.},
  doi      = {10.1002/cpe.3348},
  eprint   = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/cpe.3348},
  file     = {:download_papers/Fernández-2015-Intelligent self-adaptive resources selection for grid app.pdf:PDF},
  groups   = {wiley, systematic_search},
  keywords = {optimization, self-adaptive application, grid computing, evolutionary computing},
  url      = {https://onlinelibrary.wiley.com/doi/abs/10.1002/cpe.3348},
}

@Article{Henricksen2006,
  author   = {Henricksen, Karen and Indulska, Jadwiga and Rakotonirainy, Andry},
  journal  = {Software: Practice and Experience},
  title    = {Using context and preferences to implement self-adapting pervasive computing applications},
  year     = {2006},
  number   = {11‐12},
  pages    = {1307-1330},
  volume   = {36},
  abstract = {Abstract Applications that exploit contextual information in order to adapt their behaviour to dynamically changing operating environments and user requirements are increasingly being explored as part of the vision of pervasive or ubiquitous computing. Despite recent advances in infrastructure to support these applications through the acquisition, interpretation and dissemination of context data from sensors, they remain prohibitively difficult to develop and have made little penetration beyond the laboratory. This situation persists largely due to a lack of appropriately high-level abstractions for describing, reasoning about and exploiting context information as a basis for adaptation. In this paper, we present our efforts to address this challenge, focusing on our novel approach involving the use of preference information as a basis for making flexible adaptation decisions. We also discuss our experiences in applying our conceptual and software frameworks for context and preference modelling to a case study involving the development of an adaptive communication application. Copyright © 2006 John Wiley \& Sons, Ltd.},
  doi      = {10.1002/spe.760},
  eprint   = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.760},
  file     = {:download_papers/Henricksen-2006-Using context and preferences to implement self-adapting.pdf:PDF},
  groups   = {wiley, systematic_search},
  keywords = {context-awareness, self-adapting applications, pervasive computing, preference modelling},
  url      = {https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.760},
}

@Article{Wang2017f,
  author   = {Wang, Jun and Yin, Haibing and Fu, Yongfeng and Yang, Xiaokang},
  journal  = {International Journal of Communication Systems},
  title    = {A self-adaptive load-dispatching control framework for device data accessing in IoT-based systems},
  year     = {2017},
  note     = {e3260 IJCS-16-0402.R1},
  number   = {12},
  pages    = {e3260},
  volume   = {30},
  abstract = {Summary The Internet of things (IoT) information system plays important roles in disposing of huge volumes of real-time service requests from heterogeneous devices, targeting for different complex application requirements. Load-dispatching control (LDC) is a key problem to be solved for devices accessing concurrently in cluster systems. Self-adaptive LDC optimizes the resource allocation to ensure no overloading node, thus, improving the performance of IoT systems. This paper focuses on adaptive dispatching control problem in IoT information system. First, a device data access platform is proposed for reducing the load imbalance and improving the efficiency of data processing. Then, we propose a processing capability prediction model to evaluate the system performance. On the basis of the model, we present a practical self-adaptive LDC framework with a self-adaptive control strategy and a load dispatching method. Finally, a case study is given to verify the framework and the control strategy. Experimental results show that the proposed strategy can meet the requirements of dynamic load balancing with the ability to avoid the load imbalance problem, and the LDC-based device access platform can process data accessing effectively and ubiquitously.},
  doi      = {10.1002/dac.3260},
  eprint   = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/dac.3260},
  file     = {:download_papers/Wang-2017-A self-adaptive load-dispatching control framework.pdf:PDF},
  groups   = {wiley, systematic_search},
  keywords = {adjust strategy, cluster system, data access, load dispatching, self-adaptive control},
  url      = {https://onlinelibrary.wiley.com/doi/abs/10.1002/dac.3260},
}

@InProceedings{Abbas2016,
  author        = {N. {Abbas} and J. {Andersson} and M. U. {Iftikhar} and D. {Weyns}},
  booktitle     = {2016 Qualitative Reasoning about Software Architectures (QRASA)},
  title         = {Rigorous Architectural Reasoning for Self-Adaptive Software Systems},
  year          = {2016},
  month         = {April},
  note          = {cited By 3},
  pages         = {11-18},
  abstract      = {Designing a software architecture requires architectural reasoning, i.e., activities that translate requirements to an architecture solution. Architectural reasoning is particularly challenging in the design of product-lines of self-adaptive systems, which involve variability both at development time and runtime. In previous work we developed an extended Architectural Reasoning Framework (eARF) to address this challenge. However, evaluation of the eARF showed that the framework lacked support for rigorous reasoning, ensuring that the design complies to the requirements. In this paper, we introduce an analytical framework that enhances eARF with such support. The framework defines a set of artifacts and a series of activities. Artifacts include templates to specify domain quality attribute scenarios, concrete models, and properties. The activities support architects with transforming requirement scenarios to architecture models that comply to required properties. Our focus in this paper is on architectural reasoning support for a single product instance. We illustrate the benefits of the approach by applying it to an example client-server system, and outline challenges for future work.},
  art_number    = {7484101},
  document_type = {Conference Paper},
  doi           = {10.1109/QRASA.2016.9},
  file          = {:download_papers/Abbas-2016 - Rigorous Architectural Reasoning for Self Adaptive Software Systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 1st Workshop on Qualitative Reasoning about Software Architectures, QRASA 2016},
  keywords      = {reasoning about programs;software architecture;rigorous architectural reasoning;self-adaptive software systems;software architecture design;product-lines;self-adaptive systems;extended architectural reasoning framework;rigorous reasoning;domain quality attribute scenarios;client-server system;Cognition;Servers;Computer architecture;Analytical models;Time factors;Automata;Multimedia communication;architectural reasoning;self-adaptive software systems;formal methods},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84978284867&doi=10.1109%2fQRASA.2016.9&partnerID=40&md5=467e03f6e9add142f38f69be4243e529},
}

@Article{Abbas2020,
  author        = {Abbas, N. and Andersson, J. and Weyns, D.},
  journal       = {Journal of Systems and Software},
  title         = {ASPLe: A methodology to develop self-adaptive software systems with systematic reuse},
  year          = {2020},
  issn          = {0164-1212},
  note          = {cited By 0},
  pages         = {110626},
  volume        = {167},
  abstract      = {More than two decades of research have demonstrated an increasing need for software systems to be self-adaptive. Self-adaptation manages runtime dynamics, which are difficult to predict before deployment. A vast body of knowledge to develop Self-Adaptive Software Systems (SASS) has been established. However, we discovered a lack of process support to develop self-adaptive systems with reuse. The lack of process support may hinder knowledge transfer and quality design. To that end, we propose a domain-engineering based methodology, Autonomic Software Product Lines engineering (ASPLe), which provides step-by-step guidelines for developing families of SASS with systematic reuse. The evaluation results from a case study show positive effects on quality and reuse for self-adaptive systems designed using the ASPLe compared to state-of-the-art engineering practices. © 2020 The Author(s)},
  art_number    = {110626},
  document_type = {Article},
  doi           = {10.1016/j.jss.2020.110626},
  file          = {:download_papers/Abbas-2020-ASPLe A methodology to develop self-adaptive software systems.pdf:PDF},
  groups        = {scopus, wiley, systematic_search},
  keywords      = {Software reuse, Domain engineering, Self-Adaptation, Uncertainty, Variability, Software design},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85084955201&doi=10.1016%2fj.jss.2020.110626&partnerID=40&md5=26781baf75679b07712b33cfab41a69e},
}

@InProceedings{Abeywickrama2012a,
  author    = {D. B. {Abeywickrama} and N. {Bicocchi} and F. {Zambonelli}},
  booktitle = {2012 IEEE 21st International Workshop on Enabling Technologies: Infrastructure for Collaborative Enterprises},
  title     = {SOTA: Towards a General Model for Self-Adaptive Systems},
  year      = {2012},
  month     = {June},
  pages     = {48-53},
  abstract  = {The increasing complexity and dynamics in which software systems are deployed call for solutions to make such systems autonomic, i.e., capable of dynamically self-adapting their behavior in response to changing situations. To this end, proper models and software engineering tools are required to be available to support the design and development of autonomic systems. In this paper, we introduce a new general model, SOTA, for modeling the adaptation requirements. SOTA, by bringing together the lessons of goal-oriented modeling and of context-aware system modeling, has the potentials for tackling some key issues in the design and development of complex self-adaptive software systems. In particular, SOTA enables: early verification of requirements, identification of knowledge requirements for self-adaptation, and identification of the most suitable self-adaptive patterns.},
  doi       = {10.1109/WETICE.2012.48},
  file      = {:download_papers/Abeywickrama-2012-SOTA Towards a General Model for Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1524-4547},
  keywords  = {formal verification;mathematical programming;self-adjusting systems;SOTA;general model;complexity;dynamics;software engineering tools;autonomic systems;goal oriented modeling;context aware system modeling;complex self-adaptive software system;self-adaptation;self-adaptive pattern;Adaptation models;Sensors;Trajectory;Silicon;Adaptive systems;System recovery;Measurement;self-adaptive systems;goal-oriented requirements engineering;architectural patterns;model checking},
}

@InProceedings{Abeywickrama2012b,
  author    = {D. B. {Abeywickrama} and F. {Zambonelli}},
  booktitle = {2012 IEEE 19th International Conference and Workshops on Engineering of Computer-Based Systems},
  title     = {Model Checking Goal-Oriented Requirements for Self-Adaptive Systems},
  year      = {2012},
  month     = {April},
  pages     = {33-42},
  abstract  = {To deal with the increasing complexity and uncertainty of software systems, novel software engineering models and tools are required to make such systems self-adaptive. As part of ongoing research, we investigate various models, schemes and mechanisms to model and engineer self-adaptation in complex software systems. To this end, we have defined SOTA (State of the Affairs) as a general goal-oriented modeling framework for the analysis and design of self-adaptive systems. In this paper, by transforming the conceptual SOTA model into an operational one, we show how SOTA can be an effective tool to perform an early, goal-level, model checking analysis for adaptive systems. This allows the developers of complex self-adaptive systems to validate the actual correctness of the self-adaptive requirements at an early stage in the software life-cycle. The approach is explored and validated using a case study in the area of e-mobility.},
  doi       = {10.1109/ECBS.2012.30},
  file      = {:download_papers/Abeywickrama-2012-Model Checking Goal-Oriented Requirements.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {Vehicles;Adaptation models;Analytical models;Trajectory;Context;Availability;self-adaptive systems;model checking;goal-oriented requirements engineering;software architecture},
}

@InProceedings{Aderaldo2019,
  author    = {Aderaldo, Carlos M. and Mendon\c{c}a, Nabor C. and Schmerl, Bradley and Garlan, David},
  booktitle = {Proceedings of the 13th European Conference on Software Architecture - Volume 2},
  title     = {Kubow: An Architecture-Based Self-Adaptation Service for Cloud Native Applications},
  year      = {2019},
  address   = {New York, NY, USA},
  pages     = {42–45},
  publisher = {Association for Computing Machinery},
  series    = {ECSA ’19},
  abstract  = {This paper presents Kubow, an extensible architecture-based self-adaptation service for cloud native applications. Kubow itself was implemented by customizing and extending the Rainbow self-adaptation framework with support for Docker containers and Kubernetes. The paper highlights Kubow's architecture and main design decisions, and illustrates its use and configuration through a simple example. An accompanying demo video is available at the project's web site: https://ppgia-unifor.github.io/kubow/.},
  doi       = {10.1145/3344948.3344963},
  file      = {:download_papers/Aderaldo-2019-Kubow An Architecture-Based Self-Adaptation Service for.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450371421},
  keywords  = {rainbow, Kubernetes, self-adaptation},
  location  = {Paris, France},
  numpages  = {4},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3344948.3344963},
}

@InProceedings{Afanasov2014,
  author    = {M. {Afanasov} and L. {Mottola} and C. {Ghezzi}},
  booktitle = {2014 IEEE 38th International Computer Software and Applications Conference Workshops},
  title     = {Towards Context-Oriented Self-Adaptation in Resource-Constrained Cyberphysical Systems},
  year      = {2014},
  month     = {July},
  pages     = {372-377},
  abstract  = {We present a context-oriented approach to design and implement self-adaptive component-based software in resource-constrained Cyber physical Systems (CPSs). Because of unpredictable environment dynamics, developers must design and implement CPS software to dynamically adapt to widely different situations. Our approach provides design concepts and language support to meet this requirement against severe resource constraints. To this end, we bring a notion of context-oriented design and programming down to platforms that-because of extreme resource constraints-currently leverage fairly undisciplined design techniques and rather rudimentary component-based frameworks. Early results demonstrate that our approach improves the quality of the resulting implementations facilitating testing, maintenance, and evolution at the price of a negligible system overhead.},
  doi       = {10.1109/COMPSACW.2014.64},
  file      = {:download_papers/Afanasov-2014-Towards Context-Oriented Self-Adaptation in Resource-Constraint.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {object-oriented programming;ubiquitous computing;context-oriented self-adaptation;resource-constrained cyberphysical system;self-adaptive component-based software;context-oriented design;context-oriented programming;component-based framework;Context;Software;Global Positioning System;Programming;Wildlife;Monitoring;Batteries;resource-constrained;cyberphysical;self-adaptivity;context;programming;languages},
}

@InProceedings{Affonso2013,
  author        = {F. J. {Affonso} and E. Y. {Nakagawa}},
  booktitle     = {2013 VII Brazilian Symposium on Software Components, Architectures and Reuse},
  title         = {A Reference Architecture Based on Reflection for Self-Adaptive Software},
  year          = {2013},
  month         = {Sep.},
  note          = {cited By 9},
  pages         = {129-138},
  abstract      = {Self-adaptive Software (SaS) presents specific characteristics compared to traditional ones, as it makes possible adaptations to be incorporated at runtime. These adaptations, when manually performed, normally become an onerous, error-prone activity. In this scenario, automated approaches have been proposed to support such adaptations; however, the development of SaS is not a trivial task. In parallel, reference architectures are reusable artifacts that aggregate the knowledge of architectures of software systems in specific domains. They have facilitated the development, standardization, and evolution of systems of those domains. In spite of their relevance, in the SaS domain, reference architectures that could support a more systematic development of SaS are not found yet. Considering this context, the main contribution of this paper is to present a reference architecture based on reflection for SaS, named RA4SaS (Reference Architecture for SaS). Its main purpose is to support the development of SaS that presents adaptations at runtime. To show the viability of this reference architecture, a case study is presented. As result, it has been observed that RA4SaS has presented good perspective to efficiently contribute to the area of SaS.},
  art_number    = {6685798},
  document_type = {Conference Paper},
  doi           = {10.1109/SBCARS.2013.24},
  file          = {:download_papers/Affonso-2013-A Reference Architecture Based on Reflection for Self-Adaptive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 7th Brazilian Symposium on Software Components, Architectures and Reuse, SBCARs 2013 - In Conjunction with CBSoft 2013 - 4th Brazilian Conference on Software: Theory and Practice},
  keywords      = {software architecture;software reusability;self-adaptive software;error-prone activity;reusable artifacts;software systems architectures;RA4SaS;reference architecture for SaS;Computer architecture;Unified modeling language;Software systems;Runtime;Computational modeling;Guidelines;Self-adaptive Software;Reference Architecture;Reflection;Java},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84893224163&doi=10.1109%2fSBCARS.2013.24&partnerID=40&md5=1c5e39802820440b00dfcfb02d273f01},
}

@Conference{Affonso2015,
  author        = {Affonso, F.J. and Leite, G. and Oliveira, R.A.P. and Nakagawa, E.Y.},
  title         = {A framework based on learning techniques for decision-making in self-adaptive software},
  year          = {2015},
  note          = {cited By 5},
  pages         = {24-29},
  volume        = {2015-January},
  abstract      = {The development of Self-adaptive Software (SaS) presents specific innovative features compared to traditional ones since this type of software constantly deals with structural and/or behavioral changes at runtime. Capabilities of human administration are showing a decrease in relative effectiveness, since some tasks have been difficult to manage introducing potential problems, such as change management and simple human error. Self-healing systems, a system class of SaS, have emerged as a feasible solution in contrast to management complexity, since such system often combines machine learning techniques with control loops to reduce the number of situations requiring human intervention. This paper presents a framework based on learning techniques and the control loop (MAPE-K) to support the decision-making activity for SaS. In addition, it is noteworthy that this framework is part of a wider project developed by the authors of this paper in previous work (i.e., reference architecture for SaS [1]). Aiming to present the viability of our framework, we have conducted a case study using a flight plan module for Unmanned Aerial Vehicles. The results have shown an environment accuracy of about 80%, enabling us to project good perspectives of contribution to the SaS area and other domains of software systems, and enabling knowledge sharing and technology transfer from academia to industry. Copyright © 2015 by KSI Research Inc. and Knowledge Systems Institute Graduate School.},
  document_type = {Conference Paper},
  doi           = {10.18293/SEKE2015-125},
  file          = {:download_papers/Affonso-2015-A Framework Based on Learning Techniques for Decision-making.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84969800064&doi=10.18293%2fSEKE2015-125&partnerID=40&md5=7e3750db56a53843887590e56e3d6767},
}

@InProceedings{Ahn2017,
  author    = {J. {Ahn} and Y. B. {Park}},
  booktitle = {2017 4th International Conference on Computer Applications and Information Processing Technology (CAIPT)},
  title     = {AiTES: The self-adaptive framework for environment change of IoT},
  year      = {2017},
  month     = {Aug},
  pages     = {1-4},
  abstract  = {As the network and hardware technology development, IoT devices that have sensors and communication functions on various objects are increasing rapidly. As result IoT management software that manages various IoT devices in system is becoming important. However, most management systems are designed to perform only limited functions for the registered devices. In this paper, we propose a framework of Adaptive Internet Things EcoSystem that control behavior by changing software module adaptively to environment change of IoT devices. This system is composed two parts. One is the software adaption part defined to adapt IoT environmental change for each Internet things. And the conducting part is defined to construct IT Ecosystem, so that each software adaption part interact others. We show the functions and execution behavior of the Framework to achieve controlling device behavior adaptively upon environmental changes of IoT.},
  doi       = {10.1109/CAIPT.2017.8320726},
  file      = {:download_papers/Ahn-2017-AiTES The self-adaptive framework for environment change of IoT.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {Internet;Internet of Things;sensors;communication functions;result IoT management software;IoT devices;management systems;registered devices;Adaptive Internet Things EcoSystem;software module;IoT environmental change;controlling device behavior;self-adaptive framework;hardware technology development;software adaption part;conducting part;AiTES;Ecosystems;Software;Databases;Adaptation models;Internet of Things;Adaptive systems;Setf-Adaptive Systems;Internet of Things;IT Ecosystem},
}

@InProceedings{Alda2004a,
  author    = {S. {Alda}},
  booktitle = {Proceedings. 26th International Conference on Software Engineering},
  title     = {Component-based self-adaptability in peer-to-peer architectures},
  year      = {2004},
  month     = {May},
  pages     = {33-35},
  abstract  = {Current peer-to-peer architectures are hardly resistant against unanticipated exceptions such as the failure of single peers. This can be justified by the absence of sophisticated models for detecting and handling exception in peer-to-peer architectures. On the other hand, existing models for such self-adaptable architectures are rather generic and less practical for end-users. In this work, a component-based self-adaptability model for peer-to-peer architectures is presented that supports end-users in the handling of exceptions during use time. Support is also provided to handle exceptions during deployment and adaptation of an application. All these approaches are integral parts of DeEvolve, a peer-to-peer runtime environment for component-based peer services.},
  doi       = {10.1109/ICSE.2004.1317413},
  file      = {:download_papers/Alda-2004-Component-based self-adaptability in peer-to-peer architectures.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0270-5257},
  keywords  = {object-oriented programming;exception handling;distributed programming;software architecture;distributed processing;component-based self-adaptability;peer-to-peer architectures;DeEvolve;component-based peer services;component technology;composition languages;HCI;human computer interaction;Peer to peer computing;Computer architecture;Application software;Runtime environment;Software architecture;Concrete;Computer science;Human computer interaction;Web and internet services;Personal communication networks},
}

@InProceedings{Ancona2015,
  author    = {Ancona, Davide and Briola, Daniela and Ferrando, Angelo and Mascardi, Viviana},
  booktitle = {Proceedings of the 2015 International Conference on Autonomous Agents and Multiagent Systems},
  title     = {Global Protocols as First Class Entities for Self-Adaptive Agents},
  year      = {2015},
  address   = {Richland, SC},
  pages     = {1019–1029},
  publisher = {International Foundation for Autonomous Agents and Multiagent Systems},
  series    = {AAMAS ’15},
  abstract  = {We describe a framework for top-down centralized self-adaptive MASs where adaptive agents are "protocol-driven" and adaptation consists in runtime protocol switch. Protocol specifications take a global, rather than a local, perspective and each agent, before starting to follow a new (global) protocol, projects it for obtaining a local version. If all the agents in the MAS are driven by the same global protocol, the compliance of the MAS execution to the protocol is obtained by construction.},
  file      = {:download_papers/Ancona-2015-Global Protocols as First Class Entities for Self-Adaptive A.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450334136},
  keywords  = {interaction protocols, self-adaptiveness},
  location  = {Istanbul, Turkey},
  numpages  = {11},
}

@InProceedings{Andersson2009,
  author        = {J. {Andersson} and R. {de Lemos} and S. {Malek} and D. {Weyns}},
  booktitle     = {2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems},
  title         = {Reflecting on self-adaptive software systems},
  year          = {2009},
  month         = {May},
  note          = {cited By 41},
  pages         = {38-47},
  abstract      = {Self-adaptability has been proposed as an effective approach to automate the complexity associated with the management of modern-day software systems. While over the past decade we have witnessed significant progress in the manner in which such systems are designed, constructed, and deployed, there is still a lack of consensus among the engineers on some of the fundamental underlying concepts. In this paper, we attempt to alleviate this issue by exploring the crucial role of computational reflection in the context of self-adaptive software systems. We show that computational reflection forms the foundation of a self-adaptive system, and an understanding of its properties is a prerequisite to intelligent and predictable construction of such systems. Examining several systems in light of computational reflection has helped us to identify a number of key challenges, which we report on and propose as avenues of future research.},
  art_number    = {5069072},
  document_type = {Conference Paper},
  doi           = {10.1109/SEAMS.2009.5069072},
  file          = {:download_papers/Andersson-2009-Reflecting on self-adaptive software systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2157-2321},
  journal       = {Proceedings of the 2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2009},
  keywords      = {software engineering;self-adaptive software systems;computational reflection;intelligent system construction;Software systems;Optical reflection;Computer science;Computational intelligence;Guidelines;Informatics;Design engineering;Adaptive systems;Logic programming;Computer languages},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-70349916403&doi=10.1109%2fSEAMS.2009.5069072&partnerID=40&md5=9150f3b4dd88220678fd7eb8be41d770},
}

@InProceedings{Andrade2013a,
  author    = {S. S. {Andrade} and R. J. d. A. {Mac��do}},
  booktitle = {2013 IEEE 7th International Conference on Self-Adaptive and Self-Organizing Systems},
  title     = {A Search-Based Approach for Architectural Design of Feedback Control Concerns in Self-Adaptive Systems},
  year      = {2013},
  month     = {Sep.},
  pages     = {61-70},
  abstract  = {A number of approaches for endowing systems with self-adaptive behavior have been proposed over the past years. Among such efforts, architecture-centric solutions with explicit representation of feedback loops have currently been advocated as a promising research landscape. Although noteworthy results have been achieved on some fronts, the lack of systematic representations of architectural knowledge and effective support for well-informed trade-off decisions still poses significant challenges when designing modern self-adaptive systems. In this paper, we present a systematic and flexible representation of design dimensions related to feedback control concerns, a set of metrics which estimate quality attributes of resulting automated designs, and a search-based approach to find out a set of Pareto-optimal candidate architectures. The proposed approach has been fully implemented in a supporting tool and a case study with a self-adaptive cloud computing environment has been undertaken. The results indicate that our approach effectively captures the most prominent degrees of freedom when designing self-adaptive systems, helps to elicit effective subtle designs, and provides useful support for early analysis of trade-off decisions.},
  doi       = {10.1109/SASO.2013.42},
  file      = {:download_papers/Andrade-2013-A Search-Based Approach for Architectural Design of Feedback.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1949-3681},
  keywords  = {control system synthesis;feedback;Pareto optimisation;search problems;self-adjusting systems;search-based approach;architectural design;feedback control concerns;self-adaptive systems;self-adaptive behavior;architecture-centric solutions;architectural knowledge;design dimensions;quality attributes;Pareto-optimal candidate architectures;self-adaptive cloud computing environment;Computer architecture;Aerospace electronics;Feedback control;Measurement;Unified modeling language;Tuning;Encoding;self-adaptive systems;feedback control;automated software architecture design;design knowledge management},
}

@Article{Angelopoulos2018,
  author     = {Angelopoulos, Konstantinos and Papadopoulos, Alessandro V. and Souza, V\'{\i}tor E. Silva and Mylopoulos, John},
  journal    = {ACM Trans. Auton. Adapt. Syst.},
  title      = {Engineering Self-Adaptive Software Systems: From Requirements to Model Predictive Control},
  year       = {2018},
  issn       = {1556-4665},
  month      = apr,
  number     = {1},
  volume     = {13},
  abstract   = {Self-adaptive software systems monitor their operation and adapt when their requirements fail due to unexpected phenomena in their environment. This article examines the case where the environment changes dynamically over time and the chosen adaptation has to take into account such changes. In control theory, this type of adaptation is known as Model Predictive Control and comes with a well-developed theory and myriad successful applications. The article focuses on modeling the dynamic relationship between requirements and possible adaptations. It then proposes a controller that exploits this relationship to optimize the satisfaction of requirements relative to a cost function. This is accomplished through a model-based framework for designing self-adaptive software systems that can guarantee a certain level of requirements satisfaction over time by dynamically composing adaptation strategies when necessary. The proposed framework is illustrated and evaluated through two simulated systems, namely, the Meeting-Scheduling exemplar and an E-Shop.},
  address    = {New York, NY, USA},
  articleno  = {1},
  doi        = {10.1145/3105748},
  file       = {:download_papers/Angelopoulos-2013-Engineering Self-Adaptive Software Systems From.pdf:PDF},
  groups     = {acm, systematic_search},
  issue_date = {May 2018},
  keywords   = {awareness requirements, Self-adaptive systems, model predictive control},
  numpages   = {27},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/3105748},
}

@Article{Aradea2018,
  author        = {Aradea and Supriana, I. and Surendro, K.},
  journal       = {Telkomnika (Telecommunication Computing Electronics and Control)},
  title         = {Self-adaptive software modeling based on contextual requirements},
  year          = {2018},
  note          = {cited By 3},
  number        = {3},
  pages         = {1276-1288},
  volume        = {16},
  abstract      = {The ability of self-adaptive software in responding to change is determined by contextual requirements, i.e. a requirement in capturing relevant context-atributes and modeling behavior for system adaptation. However, in most cases, modeling for self-adaptive software is does not take into consider the requirements evolution based on contextual requirements. This paper introduces an approach through requirements modeling languages directed to adaptation patterns to support requirements evolution. The model is prepared through contextual requirements approach that is integrated into MAPE-K (monitor, anayze, plan, execute - knowledge) patterns in goal-oriented requirements engineering. As an evaluation, the adaptation process is modeled for cleaner robot. The experimental results show that the requirements modeling process has been able to direct software into self-adaptive capability and meet the requirements evolution. © 2018 Universitas Ahmad Dahlan.},
  document_type = {Article},
  doi           = {10.12928/TELKOMNIKA.v16i3.7032},
  file          = {:download_papers/Aradea-2018-Self-adaptive Software Modeling Based on Contextual Requirements.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85048793620&doi=10.12928%2fTELKOMNIKA.v16i3.7032&partnerID=40&md5=2266853cf21bc8cee6c77e308d100ffd},
}

@InProceedings{Arboleda2015,
  author    = {H. {Arboleda} and A. {Paz} and M. {Jim��nez} and G. {Tamura}},
  booktitle = {2015 10th Computing Colombian Conference (10CCC)},
  title     = {A framework for the generation and management of self-adaptive enterprise applications},
  year      = {2015},
  month     = {Sep.},
  pages     = {55-62},
  abstract  = {Demand for self-adaptive enterprise applications has been on the rise over the last years. Such applications are expected to satisfy context-dependent quality requirements in varying execution conditions. Their dynamic nature constitutes challenges with respect to their architectural design and development, and the guarantee of the agreed quality scenarios at runtime. In this paper we present the constituting elements of Shift, a framework that integrates (i) facilities and mechanisms for managing self-adaptive enterprise applications, (ii) automated derivation of self-adaptive enterprise applications and their respective monitoring infrastructure, and (iii) decision support for the assisted recomposition of self-adaptive applications.},
  doi       = {10.1109/ColumbianCC.2015.7333412},
  file      = {:download_papers/Arboleda-2015-A framework for the generation and management.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {business data processing;decision support systems;software architecture;self-adaptive enterprise applications generation;self-adaptive enterprise applications management;context-dependent quality requirements;architectural design;architectural development;quality scenarios;Shift framework;automated derivation;monitoring infrastructure;decision support;Monitoring;Adaptation models;Runtime;Unified modeling language;Context modeling;Concrete;Analytical models;Self-adaptive enterprise applications;software product lines;component configurations},
}

@InProceedings{Arcaini2019,
  author        = {P. {Arcaini} and R. {Mirandola} and E. {Riccobene} and P. {Scandurra}},
  booktitle     = {2019 IEEE International Conference on Software Architecture Companion (ICSA-C)},
  title         = {A Pattern-Oriented Design Framework for Self-Adaptive Software Systems},
  year          = {2019},
  month         = {March},
  note          = {cited By 3},
  pages         = {166-169},
  abstract      = {Multiple interacting MAPE-K loops, structured according to specific interaction patterns, have been introduced to design the adaptation logic in case of decentralized self-adaptive software systems. Designing such complex systems requires the availability of tools where MAPE patterns can be easily instantiated to provide fast architectural solutions, and the encoding towards specific domains is facilitated by automatic mapping of such pattern instantiations in domain-specific languages; validation and verification must be also supported to assure correct development of reliable systems. In this paper, we present a pattern-oriented framework, based on the MSL (MAPE Specification Language) modeling language, for the design of self-adaptive systems. The framework supports: (i) explicit modeling of the adaptation logic in terms of patterns of interactive MAPE-K loops; (ii) ability to tailor MSL models for a specific application domain and synthesize from them other modeling artifacts/code according to a target implementation context and scope (e.g., OpenHAB); (iii) ability to perform validation and verification of MSL models by means of the ASMETA formal framework.},
  art_number    = {8712366},
  document_type = {Conference Paper},
  doi           = {10.1109/ICSA-C.2019.00037},
  file          = {:download_papers/Arcaini-2019-A Pattern-Oriented Design Framework for Self-Adaptive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2019 IEEE International Conference on Software Architecture - Companion, ICSA-C 2019},
  keywords      = {object-oriented programming;program verification;software architecture;software reliability;specification languages;pattern-oriented design framework;adaptation logic;decentralized self-adaptive software systems;complex systems;MAPE patterns;automatic mapping;domain-specific languages;validation;verification;reliable systems;pattern-oriented framework;MSL modeling language;self-adaptive systems;MSL models;ASMETA formal framework;interactive MAPE-K loops;MAPE specification language;interaction patterns;Adaptation models;Unified modeling language;Analytical models;Context modeling;Heating systems;Smart homes;Temperature sensors;Pattern-oriented design;self-adaptation;MAPE-K loops;MAPE patterns;ASMETA;OpenHAB},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85066466944&doi=10.1109%2fICSA-C.2019.00037&partnerID=40&md5=0ace2d7bdfc7bb741b1170512919fcdc},
}

@Conference{Arcelli2020,
  author        = {Arcelli, D.},
  title         = {Towards a generalized queuing network model for self-adaptive software systems},
  year          = {2020},
  note          = {cited By 0},
  pages         = {457-464},
  abstract      = {A Self-adaptive Software Systems (SASSs) is composed by a managing and a managed subsystem. The former comprises system's adaptation logic and controls the latter, which provides system's functionalities by perceiving and affecting the environment through its sensors and actuators, respectively. Such control often conforms to a MAPE-K feedback loop, i.e. a Knowledge-based architecture model that divides the adaptation process into four activities, namely Monitor, Analyze, Plan and Execute. Performance modeling notations, analysis methods and tools, have been coupled to other kinds of techniques (e.g. control theory, machine learning) for modeling and assessing the performance of managing subsystems, possibly aimed at supporting the identification of more convenient architectural alternatives. The contribution of this paper is a generalized Queuing Network model for SASSs, where the managed subsystem is explicitly modelled, thus widening performance modeling and analysis scope to the whole system. Job classes flowing through the QN represent activities of a global feedback control loop, which is based on the system's mode profile and implemented by class-switches operating in conformance to proper predefined class-switching and routing probabilities. Results obtained by means of a proof-of-concept addressing a realistic case study show that the generalized QN model can usefully support performance-driven architectural decision-making. Copyright © 2020 by SCITEPRESS - Science and Technology Publications, Lda. All rights reserved.},
  document_type = {Conference Paper},
  file          = {:download_papers/Arcelli-2020-Towards a Generalized Queuing Network Model for Self-adaptive.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {MODELSWARD 2020 - Proceedings of the 8th International Conference on Model-Driven Engineering and Software Development},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85082982480&partnerID=40&md5=db922d79c47ce466a65bac6c84bb4a5e},
}

@InProceedings{Bailey2012,
  author    = {C. {Bailey}},
  booktitle = {2012 34th International Conference on Software Engineering (ICSE)},
  title     = {Application of Self-Adaptive techniques to federated authorization models},
  year      = {2012},
  month     = {June},
  pages     = {1495-1498},
  abstract  = {Authorization infrastructures are an integral part of any network where resources need to be protected. As organisations start to federate access to their resources, authorization infrastructures become increasingly difficult to manage, to a point where relying only on human resources becomes unfeasible. In our work, we propose a Self-Adaptive Authorization Framework (SAAF) that is capable of monitoring the usage of resources, and controlling access to resources through the manipulation of authorization assets (e.g., authorization policies, access rights and sessions), due to the identification of abnormal usage. As part of this work, we explore the use of models for facilitating the autonomic management of federated authorization infrastructures by 1) classifying access behaviour exhibited by users, 2) modelling authorization assets, including usage, for identifying abnormal behaviour, and 3) managing authorization through the adaptation and reflection of modelled authorization assets. SAAF will be evaluated by integrating it into an existing authorization infrastructure that would allow the simulation of abnormal usage scenarios.},
  doi       = {10.1109/ICSE.2012.6227053},
  file      = {:download_papers/Bailey-2012-Application of Self-Adaptive techniques to federated.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1558-1225},
  keywords  = {authorisation;self-adaptive technique application;authorization infrastructures;self-adaptive authorization framework;SAAF;resource usage monitoring;resource access control;authorization asset manipulation;abnormal usage identification;federated authorization infrastructure autonomic management;access behaviour classification;authorization asset modelling;authorization asset adaptation;authorization asset reflection;Authorization;Adaptation models;Unified modeling language;Permission;Computational modeling;Monitoring;self-adaptation;model driven engineering;model transformation;authorization;computing security},
}

@InProceedings{Barros2005,
  author    = {F. J. {Barros}},
  booktitle = {16th International Workshop on Database and Expert Systems Applications (DEXA'05)},
  title     = {Requirements for Modeling and Simulation of Self-Adaptive Systems: A Hierarchical and Modular Approach},
  year      = {2005},
  month     = {Aug},
  pages     = {186-190},
  abstract  = {Complex systems exhibiting structural changes should be represented by models that mimic these transformations. This direct representation of the reconfigurations occurring in real systems produces more intuitive models that are easier to build and test. The heterogeneous flow system specification (HFSS) is a comprehensive formalism that can describe a large variety of models using a unifying representation for both continuous and discrete event systems. The HFSS formalism represents models in a hierarchical and modular form. This explicit representation of structure makes possible to describe self-adaptive systems. As an application of the HFSS formalism, we introduce a representation of a self-adaptive communication network based on fluid queues},
  doi       = {10.1109/DEXA.2005.164},
  file      = {:download_papers/Barros-2005-Requirements for Modeling and Simulation of SAS.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2378-3915},
  keywords  = {discrete event systems;distributed processing;formal specification;modelling;self-adjusting systems;simulation;modeling requirements;simulation requirements;self-adaptive systems;heterogeneous flow system specification;discrete event systems;self-adaptive communication network;fluid queues;Biological systems;System testing;Discrete event systems;Application software;Communication networks;Adaptive systems;Computer architecture;Manufacturing systems;Software architecture;Production},
}

@InProceedings{Bastide2008,
  author        = {Bastide, Gautier and Seriai, Abdelhak and Oussalah, Mourad},
  booktitle     = {Proceedings of the 5th International Conference on Pervasive Services},
  title         = {A Self-Adaptation of Software Component Structures in Ubiquitous Environments},
  year          = {2008},
  address       = {New York, NY, USA},
  note          = {cited By 6},
  pages         = {173–176},
  publisher     = {Association for Computing Machinery},
  series        = {ICPS ’08},
  abstract      = {The creation of applications able to be executed in ubiquitous environments, involves a better consideration of the execution context in order to ensure service continuity. In component-based software engineering, applications are built by assembling existing components. For deploying such applications in ubiquitous environments, its components must be able to adapt themselves to the current context. To deal with this issue, we propose in this paper an approach aiming at reconfiguring the component structure to allow a flexible deployment of its services according to its use context. This adaptation focusing on the service continuity, consists of determining a structure adapted to the execution context. Then, the current structure is automatically reconfigured and the generated components are redeployed. Copyright 2008 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/1387269.1387299},
  file          = {:download_papers/Bastide-2008-A self-adaptation of software component structures.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781605581354},
  journal       = {Proceedings of the 5th International Conference on Pervasive Services, ICPS 2008},
  keywords      = {software component, ubiquitous systems, restructuring, clustering, self-adaptation, deployment, context-awareness},
  location      = {Sorrento, Italy},
  numpages      = {4},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/1387269.1387299},
}

@InProceedings{Beckmann2009,
  author        = {B. E. {Beckmann} and L. M. {Grabowski} and P. K. {McKinley} and C. {Ofria}},
  booktitle     = {2009 IEEE Symposium on Artificial Life},
  title         = {Applying digital evolution to the design of self-adaptive software},
  year          = {2009},
  month         = {March},
  note          = {cited By 2},
  pages         = {100-107},
  abstract      = {As software developers, we strive to create computational systems that are as robust and versatile as biological organisms have evolved to be in nature. We propose a software development methodology capable of producing self-adaptive software, using digital evolution to discover behaviors and optimize solutions. Employing this methodology we present an example behavioral concept from inception to fruition on physical hardware, as a proof of concept of the approach. We evolve environmentally-aware motility behaviors through digital evolution, automatically translate the evolved programs into C code, and compile and load the programs onto mobile robots.},
  art_number    = {4937700},
  document_type = {Conference Paper},
  doi           = {10.1109/ALIFE.2009.4937700},
  file          = {:download_papers/Beckmann-2009-Applying digital evolution to the design of self-adaptive software.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2160-6382},
  journal       = {2009 IEEE Symposium on Artificial Life, ALIFE 2009 - Proceedings},
  keywords      = {mobile robots;robot programming;software engineering;self-adaptive software design;software development methodology;biological organisms;digital evolution;environmentally-aware motility behaviors;C code;mobile robots;Software design;Evolution (biology);Organisms;Programming;Optimization methods;Mobile robots;Biology computing;Robustness;Evolutionary computation;Computer science;digital evolution;evolutionary computation;autonomic computing;software development;self-*;cooperation;microrobot.},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-67650522874&doi=10.1109%2fALIFE.2009.4937700&partnerID=40&md5=1bbef827c284ec2070b108ca92bfbe0b},
}

@InProceedings{Belhaj2018,
  author    = {N. {Belhaj} and D. {Bela?d} and H. {Mukhtar}},
  booktitle = {2018 IEEE International Conference on Services Computing (SCC)},
  title     = {Framework for Building Self-Adaptive Component Applications Based on Reinforcement Learning},
  year      = {2018},
  month     = {July},
  pages     = {17-24},
  abstract  = {Component-based applications entail a composition of heterogeneous components often running in different contexts. The complexity and dynamic nature of their contexts result in an increasing maintenance efforts. Autonomic computing came to provide systems with an autonomic behavior based on predefined policies. However, in addition to being knowledge-intensive, the constructed policies may easily become obsolete due to context changes. Decision policies should be dynamically learned to self-adapt to context dynamics. However, currently built autonomic systems are tailored to specific management needs, neither reusable for other management concerns nor endowed with learning abilities. In this paper, we introduce a generic framework that facilitates building self-adaptive component-based applications. Unlike the existing initiatives, our framework provides means to transform an existing application by equipping it with a self-adaptive behavior to dynamically learn an optimal policy at runtime. To validate our approach, we have developed a realistic application and used the framework to render it self-adaptive. The experimental results have shown a negligible overhead and a dynamic adjustment of the transformed application to its changing context. They have also shown less frequent time spent in SLA (Service Level Agreement) violations during the learning phase and a better performing application after convergence.},
  doi       = {10.1109/SCC.2018.00010},
  file      = {:download_papers/Belhaj-2018-Framework for Building Self-Adaptive Component Applications.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2474-2473},
  keywords  = {learning (artificial intelligence);object-oriented programming;self-adjusting systems;software fault tolerance;software maintenance;reinforcement learning;heterogeneous components;autonomic computing;knowledge-intensive;self-adaptive behavior;maintenance efforts;autonomic systems;self-adaptive component applications;SLA;service level agreement;Containers;Monitoring;Planning;Learning (artificial intelligence);Task analysis;Measurement;Autonomic Computing;Self-Adaptive Decision Making;Component-based Applications;Reinforcement Learning},
}

@Conference{Benato2017,
  author        = {Benato, G.S. and Affonso, F.J. and Nakagawa, E.Y.},
  title         = {Infrastructure based on template engines for automatic generation of source code for self-Adaptive software domain},
  year          = {2017},
  note          = {cited By 1},
  pages         = {30-35},
  abstract      = {Self-Adaptive Software (SaS), a special class of software system, constantly deals with some type of changes (i.e., structural and/or behavioral) to meet the user's new needs or autonomously react to modifications in its execution environment. Software adaptation, when manually performed, becomes an onerous and error-prone activity. Automated approaches have been adopted as a feasible alternative to overcome such adversities because they reduce the human involvement to a minimum. Based on this scenario, a Reference Architecture for SaS (RA4SaS) [1], [2] was designed in previous work. This architecture enables the adaptation of SaS at runtime by means of a controlled adaptation approach. In this sense, an automated process and a complete infrastructure to allow the phases of such process were also developed. This paper presents the design and implementation of a new module for automatic generation of source code for our architecture based on template engines [3]. In short, the main benefits of this module can be summarized in three items: (i) higher design flexibility, maintenance and evolution of SaS; (ii) introduction of new capabilities for automatic generation of source code; and (iii) performance improvement. To present the operation of this new module, a case study was conducted. As result, we have observed that our architecture has good perspective to efficiently contribute to the SaS area.},
  document_type = {Conference Paper},
  doi           = {10.18293/SEKE2017-147},
  file          = {:download_papers/Benato-2017-Infrastructure based on template engines for automatic generation.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85029517926&doi=10.18293%2fSEKE2017-147&partnerID=40&md5=d533d958e88e16394cc9143495052f88},
}

@InProceedings{Bershadsky2019,
  author        = {A. {Bershadsky} and A. {Bozhday} and Y. {Evseeva} and A. {Gudkov}},
  booktitle     = {2019 Actual Problems of Systems and Software Engineering (APSSE)},
  title         = {Integrated Approach to the Self Adaptive Software Development Based on Reflection and Observation of the Information Environment},
  year          = {2019},
  month         = {Nov},
  note          = {cited By 0},
  pages         = {109-115},
  abstract      = {The approach proposed by the authors for building self-adaptive software systems is based on the joint use of two concepts: reflexive self-adaptation and observation of the information environment. The first concept involves the analysis of information circulating within the system and the identification of patterns in it. The restructuring of the program will be carried out in the process of implementation on the basis of the found patterns. The central idea of the second concept is the analysis of information entering the system from outside (for example, in the form of user reviews), and the subsequent restructuring of the system. The implementation of both concepts is based on the application of two technologies: technology of dynamic lines of software products used to build a universal behavioral structure of an adaptive software application, and data mining technology, which is used to implement the process of self-adaptation. The study was carried out with the financial support of the Russian Foundation for Basic Research in the framework of the research project No. 18-07-00408.},
  art_number    = {8943813},
  document_type = {Conference Paper},
  doi           = {10.1109/APSSE47353.2019.00021},
  file          = {:download_papers/Bershadsky-2019-Integrated approach to the self adaptive software.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2019 Actual Problems of Systems and Software Engineering, APSSE 2019},
  keywords      = {data mining;software engineering;universal behavioral structure;Russian Foundation for Basic Research;dynamic lines;data mining technology;adaptive software application;software products;self-adaptive software systems;information environment;reflection;self adaptive software development;integrated approach;software self-adaptation, feature model, latent semantic analysis},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85078200742&doi=10.1109%2fAPSSE47353.2019.00021&partnerID=40&md5=079b49193c2345423c2f81c00a5e7a59},
}

@Article{Bershadsky2019c,
  author        = {Bershadsky, A. and Bozhday, A. and Evseeva, Y. and Gudkov, A.},
  journal       = {Communications in Computer and Information Science},
  title         = {Methods of Software Self-adaptation Based on Monitoring the Information Environment},
  year          = {2019},
  note          = {cited By 1},
  pages         = {122-131},
  volume        = {1084},
  abstract      = {The paper is devoted to the problem of developing a universal self-adaptation method of software systems. The main difference of proposed method is that a system extracts information about preferred structural and behavioral changes from a user feedback received in the form of reports and reviews. A semantic network of program characteristics will be built on the basis of this feedback information. This network will determine a new system configuration. For the synthesis of a semantic network, it is proposed to use methods of latent-semantic and distributive-statistical analysis. The feature diagram (the graphical representation of a feature model) will be used as a variability model of self-adaptive software. The developed method will allow a software system to independently identify and correct its own objective shortcomings directly in the process of functioning, as well as to adjust itself to different categories of users. The study was carried out with the financial support of the Russian Foundation for Basic Research in the framework of the research project No. 18-07-00408. © 2019, Springer Nature Switzerland AG.},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-030-29750-3_10},
  file          = {:download_papers/Bershadsky-2019-Methods Of Software Self-adaptation.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85072864418&doi=10.1007%2f978-3-030-29750-3_10&partnerID=40&md5=215266c94d9728a814bc43b06b75c0a4},
}

@InProceedings{Bosloper2005,
  author    = {I. {Bosloper} and J. {Siljee} and J. {Nijhuis} and D. {Hammer}},
  booktitle = {Third European Conference on Web Services (ECOWS'05)},
  title     = {Creating self-adaptive service systems with Dysoa},
  year      = {2005},
  month     = {Nov},
  pages     = {10 pp.-},
  abstract  = {Service-centric systems exist in a very dynamic environment, which requires these systems to adapt at runtime in order to keep fulfilling its QoS requirements to its users. In order to create self-adaptive service-centric systems, developers not only design the service architecture, but need to design the self-adaptability aspects in a structured way. Current service standards and technologies do not provide a general architecture in which all aspects for self-adaptability can be designed. In this paper we propose DySOA (dynamic service-oriented architecture), an architecture that extends service-centric applications to make them self-adaptive. DySOA allows developers to explicitly model the process and components that deal with determining the QoS of the running system, with evaluating the QoS, and with reconfiguring the system when necessary. Having the DySOA elements explicit enables separation of concerns, making the DySOA elements adaptable at runtime and reusable in next versions. We demonstrate how to use DySOA with an example.},
  doi       = {10.1109/ECOWS.2005.10},
  file      = {:download_papers/Bosloper-2005-Creating self-adaptive service systems with Dysoa.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {formal specification;adaptive systems;quality of service;object-oriented programming;software architecture;self-adaptive service systems;Dysoa;service-centric systems;QoS requirements;service architecture;dynamic service-oriented architecture;process modeling;component modeling;Quality of service;Runtime;Control systems;Delay;Security;Simple object access protocol;Web services;Context-aware services},
}

@InProceedings{BoxueWang2014,
  author    = {{Boxue Wang} and {Xinhuai Tang}},
  booktitle = {2014 IEEE Computers, Communications and IT Applications Conference},
  title     = {Designing a self-adaptive and context-aware service composition system},
  year      = {2014},
  month     = {Oct},
  pages     = {155-160},
  abstract  = {Web service compositions run in changing environment where different context events can arise to affect the execution of services. In order not to make service execution affected by context events, context-aware service composition becomes one of the major research trends. Service providers can develop context-aware services which can adapt their behaviors dynamically to execution contexts. However, it burdens service providers because they have to keep in mind different execution contexts where their services could be used. In this paper, we design and implement a self-adaptive and context-aware service composition system which can adapt to changing execution contexts and make adjustments according to context events and user-defined personalized policies. It frees service providers from context handling which in turn becomes a task of our system. We use OWL to model context ontologies and extend the OWL-S service model to support context information. Policy is a user-defined adjustment strategy to guide the dynamic adaptation. Service consumers can submit their requests and get context-aware services. Our system can composite services according to service consumers' requests, execute services, monitor execution contexts and adjust its action when contexts change.},
  doi       = {10.1109/ComComAp.2014.7017188},
  file      = {:download_papers/Wang-2014-Designing a Self-adaptive and Context-aware Service Composition.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {ontologies (artificial intelligence);Web services;self-adaptive context-aware service composition system;Web service composition;service execution;execution context;service providers;user-defined personalized policy;Web ontology language;context ontologies;OWL-S service model;context information;service consumers;Context;Motion pictures;Ontologies;Context-aware services;Engines;Databases;Middleware;self-adaptive;context-aware;service composition;policy},
}

@InProceedings{Braberman2015,
  author    = {Braberman, Victor and D’Ippolito, Nicolas and Kramer, Jeff and Sykes, Daniel and Uchitel, Sebastian},
  booktitle = {Proceedings of the 1st International Workshop on Control Theory for Software Engineering},
  title     = {MORPH: A Reference Architecture for Configuration and Behaviour Self-Adaptation},
  year      = {2015},
  address   = {New York, NY, USA},
  pages     = {9–16},
  publisher = {Association for Computing Machinery},
  series    = {CTSE 2015},
  abstract  = {An architectural approach to self-adaptive systems involves runtime change of system configuration (i.e., the system's components, their bindings and operational parameters) and behaviour update (i.e., component orchestration). Thus, dynamic reconfiguration and discrete event control theory are at the heart of architectural adaptation. Although controlling configuration and behaviour at runtime has been discussed and applied to architectural adaptation, architectures for self-adaptive systems often compound these two aspects reducing the potential for adaptability. In this paper we propose a reference architecture that allows for coordinated yet transparent and independent adaptation of system configuration and behaviour.},
  doi       = {10.1145/2804337.2804339},
  file      = {:download_papers/Braberman-2015-MORPH a reference architecture for configuration.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450338141},
  keywords  = {Software Architecture, Self-adaptive Systems},
  location  = {Bergamo, Italy},
  numpages  = {8},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2804337.2804339},
}

@InProceedings{Burstein2010,
  author    = {M. {Burstein} and R. {Bobrow} and W. {Ferguson} and R. {Laddaga} and P. {Robertson}},
  booktitle = {2010 Fourth IEEE International Conference on Self-Adaptive and Self-Organizing Systems Workshop},
  title     = {Learning from Observing: Vision and POIROT - Using Metareasoning for Self Adaptation},
  year      = {2010},
  month     = {Sep.},
  pages     = {300-307},
  abstract  = {We present a cognitive architecture that heavily utilizes metareasoning for self adaptation. The architecture is derived in part from neuroscience data and theories about the operation of the human vision system. We also discuss how this architecture is applied in the POIROT system, which learns web services workflow from ��observing�� a small number of expert examples.},
  doi       = {10.1109/SASOW.2010.61},
  file      = {:download_papers/Burstein-2010-Learning from Observing Vision and POIROT.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {inference mechanisms;learning by example;Web services;workflow management software;POIROT;metareasoning;self adaptation;cognitive architecture;neuroscience data;human vision system;POIROT system;Web services workflow;plan order induction by reasoning from one trial;learning from observing;Computer architecture;Web services;Humans;Semantics;Planning;Feature extraction;Cognition;metreasoning;self adaptive;learning;vision;cogntive architecture;neuroscience;active vision},
}

@InProceedings{Buzura2020,
  author    = {S. {Buzura} and V. {Dadarlat} and B. {Iancu} and A. {Peculea} and E. {Cebuc} and R. {Kovacs}},
  booktitle = {2020 IEEE International Conference on Automation, Quality and Testing, Robotics (AQTR)},
  title     = {Self-adaptive Fuzzy QoS Algorithm for a Distributed Control Plane with Application in SDWSN},
  year      = {2020},
  month     = {May},
  pages     = {1-6},
  abstract  = {This paper proposes a self-adaptive algorithm for improving the quality of service (QoS) rules in the distributed control plane of a software defined network (SDN). The algorithm is based on fuzzing techniques and requires that the Controllers collaborate in order to determine the best rules to use for packet forwarding. Several simulations were run with different network configurations to verify the algorithm's effectiveness by measuring the packet miss ratio on the data plane switches. The results show that a distributed and collaborative approach is generating the set of rules with the lowest miss ratio as well as it is the most efficient in decreasing the miss ratio with each algorithm iteration, compared to other approaches which are non distributed or non collaborative.},
  doi       = {10.1109/AQTR49680.2020.9129922},
  file      = {:download_papers/Buzura-2020-Self-adaptive Fuzzy QoS Algorithm for a Distributed Control.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {SDWSN;QoS;Distributed control plane;Algorithm;Fuzzing},
}

@InProceedings{Calinescu2013,
  author    = {R. {Calinescu} and Y. {Rafiq}},
  booktitle = {2013 International Symposium on Theoretical Aspects of Software Engineering},
  title     = {Using Intelligent Proxies to Develop Self-Adaptive Service-Based Systems},
  year      = {2013},
  month     = {July},
  pages     = {131-134},
  abstract  = {We present the theory underpinning the operation of a new tool-supported approach to engineering self-adaptive service-based systems (SBSs), and preliminary results from its evaluation in a telehealth case study. SBSs developed using our approach select their services dynamically, in order to maintain compliance with reliability requirements in the presence of changes in service behaviour. This adaptation is enabled by a new type of web service proxy called an intelligent proxy.},
  doi       = {10.1109/TASE.2013.41},
  file      = {:download_papers/Calinescu-2013-Using Intelligent Proxies to Develop Self-Adaptive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {bioinformatics;health care;software maintenance;software reliability;telemedicine;Web services;intelligent proxies;self-adaptive service-based systems;SBS;telehealth case study;compliance maintenance;reliability requirements;Web service proxy;Internet;e-commerce;bioinformatics;Scattering;Web services;Standards;Reliability;Probabilistic logic;Unified modeling language;Java},
}

@InProceedings{Camara2015,
  author    = {C\'{a}mara, Javier and Garlan, David and Schmerl, Bradley and Pandey, Ashutosh},
  booktitle = {Proceedings of the 30th Annual ACM Symposium on Applied Computing},
  title     = {Optimal Planning for Architecture-Based Self-Adaptation via Model Checking of Stochastic Games},
  year      = {2015},
  address   = {New York, NY, USA},
  pages     = {428–435},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’15},
  abstract  = {Architecture-based approaches to self-adaptation rely on architectural descriptions to reason about the best way of adapting the structure and behavior of software-intensive systems at runtime, either by choosing among a set of predefined adaptation strategies, or by automatically generating adaptation plans. Predefined strategy selection has a low computational overhead and facilitates dealing with uncertainty (e.g., by accounting explicitly for contingencies derived from unexpected outcomes of actions), but requires additional designer effort regarding the specification of strategies and is unable to guarantee optimal solutions. In contrast, runtime plan generation is able to explore a richer solution space and provide optimal solutions in some cases, but is more limited when dealing with uncertainty, and in-curs higher computational overheads. In this paper, we propose an approach to optimal adaptation plan generation for architecture-based self-adaptation via model checking of stochastic multiplayer games (SMGs). Our approach enables: (i) trade-off analysis among different qualities by means of utility functions and preferences, and (ii) explicit modeling of uncertainty in the outcome of adaptation actions and the behavior of the environment. Basing on the concepts embodied in the Rainbow framework for self-adaptation, we illustrate our approach in Znn.com, a case study that reproduces the infrastructure for a news website.},
  doi       = {10.1145/2695664.2695680},
  file      = {:download_papers/Camara-2015-Optimal planning for architecture-based self-adaptation.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450331968},
  keywords  = {planning, probabilistic model checking, self-adaptation},
  location  = {Salamanca, Spain},
  numpages  = {8},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2695664.2695680},
}

@Article{Camara2016,
  author        = {Cámara, J. and Correia, P. and de Lemos, R. and Garlan, D. and Gomes, P. and Schmerl, B. and Ventura, R.},
  journal       = {Journal of Systems and Software},
  title         = {Incorporating architecture-based self-adaptation into an adaptive industrial software system},
  year          = {2016},
  issn          = {0164-1212},
  note          = {cited By 10},
  pages         = {507-523},
  volume        = {122},
  abstract      = {Complex software-intensive systems are increasingly relied upon for all kinds of activities in society, leading to the requirement that these systems should be resilient to changes that may occur to the system, its environment, or its goals. Traditionally, resilience has been achieved either through: (i) low-level mechanisms embedded in the implementation (e.g., exception handling, timeouts, redundancies), which are unable to detect subtle but important anomalies (e.g., progressive performance degradation); or (ii) human oversight, which is costly and unreliable. Architecture-based self-adaptation (ABSA) is regarded as a promising approach to improve the resilience and reduce the development/operation costs of such systems. Although researchers have illustrated the benefits of ABSA through a number of small-scale case studies, it remains to be seen whether ABSA is truly effective in handling changes at run-time in industrial-scale systems. In this paper, we report on our experience applying an ABSA framework (Rainbow) to a large-scale commercial software system, called Data Acquisition and Control Service (DCAS), which is used to monitor and manage highly populated networks of devices in renewable energy production plants. In the approach followed, we have replaced some of the existing adaptive mechanisms embedded in DCAS by those advocated by ABSA proponents. This has allowed us to assess the development costs associated with the reengineering of adaptive mechanisms when using an ABSA solution, and to make effective comparisons, in terms of operational performance, between a baseline industrial system and one that uses ABSA. Our results show that using the ABSA concepts as embodied in Rainbow enabled an independent team of developers to: (i) effectively implement the adaptation behavior required from such industrial systems; and (ii) obtain important benefits in terms of maintainability and extensibility of adaptation mechanisms. © 2015 Elsevier Inc.},
  document_type = {Article},
  doi           = {10.1016/j.jss.2015.09.021},
  file          = {:download_papers/Camara-2016-Incorporating architecture-based self-adaptation into an adaptive.pdf:PDF},
  groups        = {scopus, wiley, systematic_search},
  keywords      = {Architecture-based self-adaptation, Evolution, Rainbow},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84992679340&doi=10.1016%2fj.jss.2015.09.021&partnerID=40&md5=286495d9c74007ccff1b50de1e2f6a7d},
}

@InProceedings{Cambier2002,
  author    = {C. {Cambier} and M. {Piron} and A. {Cardon}},
  booktitle = {Proceedings of the 2002 Congress on Evolutionary Computation. CEC'02 (Cat. No.02TH8600)},
  title     = {Self-adaptive systems using a massive multi-agent system},
  year      = {2002},
  month     = {May},
  pages     = {345-350 vol.1},
  volume    = {1},
  abstract  = {We deal with systems using massive multi-agent organizations and expressing complex problems like the representation of the world sub-system managing the behavior of a robot. We propose an analysis and an operating representation of multi-agent organization in a geometric way, using specific multi-agent organization in a morphologic agent space. We propose also an architecture expressing the behavior of the massive multi-agent organization. So we open the way to the implementation of self-adaptive systems. We present an application for the behavior of an autonomous robot.},
  doi       = {10.1109/CEC.2002.1006258},
  file      = {:download_papers/Cambier-2002-Self-adaptive systems using a massive multi-agent system.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {multi-agent systems;self-adjusting systems;robots;multi-agent organizations;massive multi-agents systems;behavior;morphology;self-adaptive systems;autonomous robot;morphologic agent space;Multiagent systems;Control systems;Orbital robotics;Real time systems;Legged locomotion;Communication system control;Bonding;Application software;Morphology;Software architecture},
}

@InProceedings{Cha2016,
  author        = {J. {Cha} and J. {Kim} and Y. {Jeong}},
  booktitle     = {2016 International Conference on Computational Science and Computational Intelligence (CSCI)},
  title         = {Architecture Based Approaches Supporting Flexible Design of Self-Adaptive Software},
  year          = {2016},
  month         = {Dec},
  note          = {cited By 0},
  pages         = {1424-1425},
  abstract      = {It is difficult to solve an optimization problem in smart devices software due to a trade-off relation between quality conditions and performance properties. Furthermore, development cost of complicated software is on the increase by fragmentation of devices into the small size. In this paper, we propose the design processes and methods reflecting diverse of flexible elements including physical features such as low-power and high-performance, co-design of hardware and software, and restricted resources usage. Our methods can establish the optimized self-adaptive design by reflecting the quality properties and performance requirements for applications working on systems, monitoring system's states in real-time, and customizing with the most proper design properties.},
  art_number    = {7881573},
  document_type = {Conference Paper},
  doi           = {10.1109/CSCI.2016.0280},
  file          = {:download_papers/Cha-2016-Architecture Based Approaches Supporting Flexible Design.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2016 International Conference on Computational Science and Computational Intelligence, CSCI 2016},
  keywords      = {software architecture;architecture based approach;self-adaptive software design;flexible design;smart devices;Software;Metadata;Smart devices;Computer architecture;Hardware;Performance evaluation;Adaptive systems;Self-Adaptive Software;Flexible Design;Architecture Based Approaches},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85017303440&doi=10.1109%2fCSCI.2016.0280&partnerID=40&md5=2402f371dd7a234816d85567794ff58d},
}

@InProceedings{Champrasert2006,
  author    = {P. {Champrasert} and J. {Suzuki}},
  booktitle = {2006 International Symposium on a World of Wireless, Mobile and Multimedia Networks(WoWMoM'06)},
  title     = {SymbioticSphere: a biologically-inspired autonomic architecture for self-adaptive and self-healing server farms},
  year      = {2006},
  month     = {June},
  pages     = {6 pp.-474},
  abstract  = {This paper describes a biologically-inspired architecture, called SymbioticSphere, which allows large-scale server farms to autonomously adapt to dynamic environmental changes and survive partial system failures. SymbioticSphere follows biological principles such as decentralization, autonomy, natural selection, emergence and symbiosis to design server farms (application services and middleware platforms). Each application service and middleware platform is designed as a biological entity, analogous to an individual bee in a bee colony. Simulation results show that, like in biological systems, SymbioticSphere exhibits emergence of desirable system characteristics such as adaptability and survivability},
  doi       = {10.1109/WOWMOM.2006.105},
  file      = {:download_papers/Champrasert-2006-SymbioticSphere a biologically-inspired autonomic.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {Internet;middleware;network servers;SymbioticSphere;biologically-inspired autonomic architecture;self-healing server farms;survive partial system failures;middleware platform;Symbiosis;Middleware;Biological system modeling;Application software;Biology;Computer architecture;Biological systems;Web server;Web and internet services;Surges},
}

@InProceedings{Chen2013,
  author    = {T. {Chen} and R. {Bahsoon}},
  booktitle = {2013 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Self-adaptive and sensitivity-aware QoS modeling for the cloud},
  year      = {2013},
  month     = {May},
  pages     = {43-52},
  abstract  = {Given the elasticity, dynamicity and on-demand nature of the cloud, cloud-based applications require dynamic models for Quality of Service (QoS), especially when the sensitivity of QoS tends to fluctuate at runtime. These models can be autonomically used by the cloud-based application to correctly self-adapt its QoS provision. We present a novel dynamic and self-adaptive sensitivity-aware QoS modeling approach, which is fine-grained and grounded on sound machine learning techniques. In particular, we combine symmetric uncertainty with two training techniques: Auto-Regressive Moving Average with eXogenous inputs model (ARMAX) and Artificial Neural Network (ANN) to reach two formulations of the model. We describe a middleware for implementing the approach. We experimentally evaluate the effectiveness of our models using the RUBiS benchmark and the FIFA 1998 workload trends. The results show that our modeling approach is effective and the resulting models produce better accuracy when compared with conventional models.},
  doi       = {10.1109/SEAMS.2013.6595491},
  file      = {:download_papers/Chen-2013-Self-adaptive and sensitivity-aware QoS modeling for the cloud.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2321},
  keywords  = {autoregressive moving average processes;cloud computing;learning (artificial intelligence);neural nets;quality of service;sensitivity-aware QoS modeling;self-adaptive QoS modeling;cloud computing;cloud-based application;quality of service;QoS provision;machine learning technique;autoregressive moving average with exogenous inputs model;ARMAX model;artificial neural network;ANN;RUBiS benchmark;FIFA 1998 workload trend;Quality of service;Adaptation models;Sensitivity;Accuracy;Uncertainty;Software;Data models;QoS modeling;machine learning;sensitivity;interference;prediction;cloud computing},
}

@InProceedings{Chen2014,
  author    = {Chen, Bihuan and Peng, Xin and Yu, Yijun and Nuseibeh, Bashar and Zhao, Wenyun},
  booktitle = {Proceedings of the 36th International Conference on Software Engineering},
  title     = {Self-Adaptation through Incremental Generative Model Transformations at Runtime},
  year      = {2014},
  address   = {New York, NY, USA},
  pages     = {676–687},
  publisher = {Association for Computing Machinery},
  series    = {ICSE 2014},
  abstract  = {A self-adaptive system uses runtime models to adapt its architecture to the changing requirements and contexts. However, there is no one-to-one mapping between the requirements in the problem space and the architectural elements in the solution space. Instead, one refined requirement may crosscut multiple architectural elements, and its realization involves complex behavioral or structural interactions manifested as architectural design decisions. In this paper we propose to combine two kinds of self-adaptations: requirements-driven self-adaptation, which captures requirements as goal models to reason about the best plan within the problem space, and architecture-based self-adaptation, which captures architectural design decisions as decision trees to search for the best design for the desired requirements within the contextualized solution space. Following these adaptations, component-based architecture models are reconfigured using incremental and generative model transformations. Compared with requirements-driven or architecture-based approaches, the case study using an online shopping benchmark shows promise that our approach can further improve the effectiveness of adaptation (e.g. system throughput in this case study) and offer more adaptation flexibility.},
  doi       = {10.1145/2568225.2568310},
  file      = {:download_papers/Chen-2014-Self-adaptation through incremental generative model.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450327565},
  keywords  = {requirements, model transformation, architecture, Self-adaptive system, runtime model, design decisions},
  location  = {Hyderabad, India},
  numpages  = {12},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2568225.2568310},
}

@InProceedings{Cheng2006,
  author    = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
  booktitle = {Proceedings of the 2006 International Workshop on Self-Adaptation and Self-Managing Systems},
  title     = {Architecture-Based Self-Adaptation in the Presence of Multiple Objectives},
  year      = {2006},
  address   = {New York, NY, USA},
  pages     = {2–8},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’06},
  abstract  = {In the world of autonomic computing, the ultimate aim is to automate human tasks in system management to achieve high-level stakeholder objectives. One common approach is to capture and represent human expertise in a form executable by a computer. Techniques to capture such expertise in programs, scripts, or rule sets are effective to an extent. However, they are often incapable of expressing the necessary adaptation expertise and emulating the subtleties of trade-offs in high-level decision making. In this paper, we propose a new language of adaptation that is sufficiently expressive to capture the subtleties of choice, deriving its ontology from system administration tasks and its underlying formalism from utility theory.},
  doi       = {10.1145/1137677.1137679},
  file      = {:download_papers/Cheng-2006-Architecture-based self-adaptation in the presence of multiple.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {1595934030},
  keywords  = {repair language, tactic, preference, strategy, utility, choice, self-adaptation, trade-off},
  location  = {Shanghai, China},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1137677.1137679},
}

@InProceedings{Cheng2018,
  author    = {W. {Cheng} and Q. {Li} and L. {Wang} and L. {He}},
  booktitle = {2018 5th International Conference on Soft Computing Machine Intelligence (ISCMI)},
  title     = {Handling Uncertainty Online for Self-Adaptive Systems},
  year      = {2018},
  month     = {Nov},
  pages     = {135-139},
  abstract  = {Self-Adaptive Systems (SASs) are required to adapt to the frequent changes from external environments, user requirements and their own. However, the potential uncertainties challenge the SASs. In which, the uncertainties in Monitor is mainly that the monitoring data is inaccurate, and the uncertainties in Analyze is mainly that the abnormal state is difficult to match accurately. These uncertainties lead to identify changes inaccurately and directly affect the reliability of SASs. So they are particularly critical. To deal with them, current adaptive methods, which either consider only uncertainties at design or rely on specific scenarios without versatility. This paper deal with both two uncertainties of Monitor and Analyze at runtime, and introduces Fuzzy Theory and Semantic Distance Technology to handle them online to ensure the reliability of SASs, and our methods are common to all SASs. Finally, we exemplify these methods with the Bookstore System, which proves the effectiveness of the methods.},
  doi       = {10.1109/ISCMI.2018.8703227},
  file      = {:download_papers/Cheng-2018-Handling Uncertainty Online for Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2640-0146},
  keywords  = {fuzzy set theory;ontologies (artificial intelligence);self-adjusting systems;semantic networks;software reliability;uncertainty handling;external environments;user requirements;SASs;Bookstore system;data monitoring;semantic distance technology;fuzzy theory;uncertainty online handling;self-adaptive systems;Monitoring;Uncertainty;Semantics;Ontologies;Runtime;Time factors;Filtering theory;uncertainty;Self-Adaptive Systems;Monitor and Analyze;Fuzzy Theory;Semantic Distance},
}

@InProceedings{Chollet2015,
  author    = {S. {Chollet}},
  booktitle = {2015 IEEE International Conference on Autonomic Computing},
  title     = {Self-Adaptation of Service Bindings Based on Formal Concept Analysis},
  year      = {2015},
  month     = {July},
  pages     = {211-214},
  abstract  = {Service-oriented computing has been successfully adopted by the industry. This raises however new challenges, especially with respect to service selection and ranking in dynamic environments. Current solutions for service selection and ranking lack flexibility to handle dynamic environments. This paper proposes to integrate algorithms based on the Formal Concept Analysis theory to extend service-oriented component models. This solution improves the self-adaptation of service-oriented component models. The resulting framework externalizes service selection and ranking. Results are integrated in the Apache Felix iPOJO component model.},
  doi       = {10.1109/ICAC.2015.26},
  file      = {:download_papers/Chollet-2015-Self-Adaptation of Service Bindings Based on Formal Concept.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {formal concept analysis;object-oriented programming;service-oriented architecture;self-adaptative service bindings;service-oriented computing;service selection;service ranking;dynamic environments;formal concept analysis theory;service-oriented component models;Apache Felix iPOJO component model;Lattices;Context;Formal concept analysis;Computational modeling;Adaptation models;Complexity theory;Software;Service-Oriented Computing;Service Selection;Formal Concept Analysis},
}

@InProceedings{Chu2018,
  author        = {N. {Chu} and H. {Liu} and B. {Ding} and W. {Li}},
  booktitle     = {2018 IEEE International Conference on Computer and Communication Engineering Technology (CCET)},
  title         = {Constructing Self-Adaptive Software in Ubiquitous Computing Space},
  year          = {2018},
  month         = {Aug},
  note          = {cited By 1},
  pages         = {254-259},
  abstract      = {Self-adaptation endows software with the ability to adjust its behavior according to the changes in its environment. It is an effective approach to deal with dynamic environments, such as ubiquitous computing spaces. However, adaptability will significantly complicate software implementation and bring great challenges to software engineering practices. This paper presents an engineering approach for self-adaptive software, which systematically enables the reuse of software adaptation on both software architecture and development process. We propose a novel conceptual model as the foundation of our work at first, in which each software entity can imitate the reacting/joining behavior pattern of the individuals in natural adaptive systems. And then, mainly based on the enhancement of component technology, we map this conceptual model into a practical and reusable software architecture. A software factory with a model-driven process is presented as well. Several applications have been developed to validate the effectiveness and generality of our approach.},
  art_number    = {8542198},
  document_type = {Conference Paper},
  doi           = {10.1109/CCET.2018.8542198},
  file          = {:download_papers/Chu-2018-Constructing Self-Adaptive Software in Ubiquitous.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {2018 IEEE International Conference on Computer and Communication Engineering Technology, CCET 2018},
  keywords      = {software architecture;software engineering;software reusability;ubiquitous computing;self-adaptive software;ubiquitous computing space;software implementation;software engineering practices;engineering approach;software adaptation;development process;software entity;natural adaptive systems;software factory;software architecture;software self-adaptation;Software;Adaptation models;Computational modeling;Ubiquitous computing;Adaptive systems;Computer architecture;Production facilities;ubiquitous computing;adaptability;software architecture;software factory},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85059772495&doi=10.1109%2fCCET.2018.8542198&partnerID=40&md5=6619af99be593d567aa1669529c6eb2f},
}

@InProceedings{Chun2014,
  author    = {I. {Chun} and J. {Park} and W. {Kim}},
  booktitle = {16th International Conference on Advanced Communication Technology},
  title     = {Self-adaptive system development method for smart control systems in CPS},
  year      = {2014},
  month     = {Feb},
  pages     = {635-639},
  abstract  = {The human desire to develop high reactive, safety, precise and convenient control system makes smart machinery equipped with computing elements appear on the scene. Especially in order to get free of household affairs, the necessity of home service robot - that is a good example of control systems - has been increased. Home service robot is a robot used for household chores on behalf of human. We expect that every home will at least possess and use more than one home service robot in the near future. However the operating environment of home service robots - like house, yard, garage, and so on - has much uncertainty and uncontrollable conditions, so that it is impossible to make robots suitable to all situations. In this paper, to achieve user satisfaction and overcome abnormal situation, we propose a self-adaptive system development method that make home service robots dependable, secure, safe, and efficient, and operating in real-time. To apply this approach, home service robots could be more intelligent in the adaptation.},
  doi       = {10.1109/ICACT.2014.6779039},
  file      = {:download_papers/Chun-2014-Self-adaptive system development method for smart control.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1738-9445},
  keywords  = {adaptive control;intelligent control;service robots;self-adaptive system development method;smart control systems;CPS;smart machinery;computing elements;household affairs;home service robot;household chores;user satisfaction;Software;Adaptation models;Service robots;Computational modeling;Control systems;Runtime;Autonomie Computing;Home Service Robot;Intelligent system;Self-Adaptive System;Smart Control System},
}

@InProceedings{Coker2015,
  author    = {Z. {Coker} and D. {Garlan} and C. L. {Goues}},
  booktitle = {2015 IEEE/ACM 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {SASS: Self-Adaptation Using Stochastic Search},
  year      = {2015},
  month     = {May},
  pages     = {168-174},
  abstract  = {Future-generation self-adaptive systems will need to be able to optimize for multiple interrelated, difficult-to-measure, and evolving quality properties. To navigate this complex search space, current self-adaptive planning techniques need to be improved. In this position paper, we argue that the research community should more directly pursue the application of stochastic search techniques -- search techniques, such as hill climbing or genetic algorithms, that incorporate an element of randomness -- to self-adaptive systems research. These techniques are well-suited to handling multi-dimensional search spaces and complex problems, situations which arise often for self-adaptive systems. We believe that recent advances in both fields make this a particularly promising research trajectory. We demonstrate one way to apply some of these advances in a search-based planning prototype technique to illustrate both the feasibility and the potential of the proposed research. This strategy informs a number of potentially interesting research directions and problems. In the long term, this general technique could enable sophisticated plan generation techniques that improve domain specific knowledge, decrease human effort, and increase the application of self-adaptive systems.},
  doi       = {10.1109/SEAMS.2015.16},
  file      = {:download_papers/Coker-2015-SASS Self-Adaptation Using Stochastic Search.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2321},
  keywords  = {genetic algorithms;search problems;software engineering;stochastic programming;SASS;self-adaptation-using-stochastic search;complex search space;self-adaptive planning techniques;research community;hill climbing;genetic algorithms;randomness;multidimensional search spaces;search-based planning prototype technique;plan generation techniques;domain specific knowledge improvement;Servers;Time factors;Search problems;Measurement;Databases;Genetic algorithms;Planning;planning;stochastic search;genetic algorithm;position paper},
}

@Article{Cooray2013,
  author        = {D. {Cooray} and E. {Kouroshfar} and S. {Malek} and R. {Roshandel}},
  journal       = {IEEE Transactions on Software Engineering},
  title         = {Proactive Self-Adaptation for Improving the Reliability of Mission-Critical, Embedded, and Mobile Software},
  year          = {2013},
  issn          = {1939-3520},
  month         = {Dec},
  note          = {cited By 14},
  number        = {12},
  pages         = {1714-1735},
  volume        = {39},
  abstract      = {Embedded and mobile software systems are marked with a high degree of unpredictability and dynamism in the execution context. At the same time, such systems are often mission-critical, meaning that they need to satisfy strict reliability requirements. Most current software reliability analysis approaches are not suitable for these types of software systems, as they do not take the changes in the execution context of the system into account. We propose an approach geared to such systems which continuously furnishes refined reliability predictions at runtime by incorporating various sources of information, including the execution context of the system. The reliability predictions are leveraged to proactively place the software in the (near-)optimal configuration with respect to changing conditions. Our approach considers two representative architectural reconfiguration decisions that impact the system's reliability: reallocation of components to processes and changing the number of component replicas. We have realized the approach as part of a framework intended for mission-critical settings, called REsilient SItuated SofTware system (RESIST), and evaluated it using a mobile emergency response system.},
  art_number    = {6574866},
  document_type = {Article},
  doi           = {10.1109/TSE.2013.36},
  file          = {:download_papers/Cooray-2013-Proactive Self-Adaptation for Improving the Reliability.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {embedded systems;mobile computing;software architecture;software reliability;proactive self-adaptation;mission-critical software;embedded software;mobile software;unpredictability degree;dynamism degree;execution context;reliability requirements;software reliability analysis approach;architectural reconfiguration decisions;component reallocation;component replicas;RESIST approach;resilient situated software system;mobile emergency response system;Mobile communication;Software reliability;Context awareness;Reliability engineering;Software architecture;Computer architecture;Context awareness;software architecture;self-adaptive systems;reliability;mobility},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84890048535&doi=10.1109%2fTSE.2013.36&partnerID=40&md5=abdfa6ad56115494e088af382ae37c8b},
}

@InProceedings{Cui2013,
  author    = {Y. {Cui} and R. M. {Voyles} and M. H. {Mahoor}},
  booktitle = {2013 IEEE International Conference on Automation Science and Engineering (CASE)},
  title     = {ReFrESH: A self-adaptive architecture for autonomous embedded systems},
  year      = {2013},
  month     = {Aug},
  pages     = {850-855},
  abstract  = {This paper presents an architecture for automating the reconfiguration of system deal with unforeseen situations, named ReFrESH, for distributed autonomous embedded systems which 1) supports both hardware and software reconfiguration based on task-related functional requirements without disturbing system at runtime; 2) provides a type of Embedded Virtual Machine to facilitate components distribution across node boundaries; 3) generates optimal configurations dynamically based on non-functional requirements. The feasibility of ReFrESH and its management algorithms are evaluated for ��visual servoing�� of three miniature robot scenario. Moreover, one self-adaptive application is implemented to show the realistic performance of ReFrESH. The results demonstrate that ReFrESH can enable the system to handle various situations dynamically and decrease the complexity of self-adaptation.},
  doi       = {10.1109/CoASE.2013.6654042},
  file      = {:download_papers/Cui-2013-ReFrESH A self-adaptive architecture for autonomous embedded.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2161-8089},
  keywords  = {distributed processing;embedded systems;robot vision;virtual machines;visual servoing;self-adaptive architecture;ReFrESH;distributed autonomous embedded systems;software reconfiguration;hardware reconfiguration;task-related functional requirements;embedded virtual machine;components distribution;node boundaries;nonfunctional requirements;visual servoing;miniature robot scenario;self-adaptation complexity;reconfiguration framework for distributed embedded systems for software and hardware;Hardware;Software;Ports (Computers);Computer architecture;Visual servoing;Cameras},
}

@InProceedings{Cui2014,
  author    = {Y. {Cui} and R. M. {Voyles} and J. T. {Lane} and M. H. {Mahoor}},
  booktitle = {2014 IEEE/RSJ International Conference on Intelligent Robots and Systems},
  title     = {ReFrESH: A self-adaptation framework to support fault tolerance in field mobile robots},
  year      = {2014},
  month     = {Sep.},
  pages     = {1576-1582},
  abstract  = {Mobile robots are being employed far more often in extreme environments, such as urban search and rescue, with greater levels of autonomy; yet recent studies on field robotics show that numerous failure modes affect the reliability of the robot in meeting mission objectives. Therefore, fault tolerance is increasingly important for field robots operating in unpredictable environments to ensure safety and effectiveness of the system. This paper demonstrates a self-adaptation framework, ReFrESH, that contains mechanisms for fault detection and fault mitigation. The goal of ReFrESH is to provide diagnosable and maintainable infrastructure support, built into a real-time operating system, to manage task performance in the presence of unexpected uncertainties. ReFrESH augments the port-based object framework by attaching evaluation and estimation mechanisms to each functional component so that the robot can easily detect and locate faults. In conjunction, a task level decision mechanism interacts with the fault detection elements in order to generate and choose an optimal approach to mitigating faults. Moreover, to increase flexibility of the fault tolerance, ReFrESH provides self-adaptation support for both software and hardware functionality. To our knowledge, this is the first framework to support both software and hardware self-adaptation. A demonstrative application of ReFrESH illustrates its applicability through a target tracking task deployed on a mobile robot system.},
  doi       = {10.1109/IROS.2014.6942765},
  file      = {:download_papers/Cui-2014-ReFrESH A self-adaptation framework to support fault tolerance.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2153-0866},
  keywords  = {control engineering computing;fault tolerant computing;mobile robots;operating systems (computers);real-time systems;self-adjusting systems;self-adaptation framework;field mobile robot system;urban search and rescue;failure modes;robot reliability;mission objectives;fault tolerance;unpredictable environments;system safety;system effectiveness;ReFrESH;fault detection;fault mitigation;diagnosable infrastructure support;maintainable infrastructure support;real-time operating system;task performance;port-based object framework;estimation mechanisms;functional component;faults location;task level decision mechanism;faults mitigation;software functionality;hardware functionality;software self-adaptation;hardware self-adaptation;target tracking task;Robots;Fault tolerance;Fault tolerant systems;Software;Runtime;Hardware;Computer architecture},
}

@InProceedings{Cui2015a,
  author        = {Y. {Cui} and J. T. {Lane} and R. M. {Voyles}},
  booktitle     = {2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
  title         = {Real-time software module design framework for building self-adaptive robotic systems},
  year          = {2015},
  month         = {Sep.},
  note          = {cited By 1},
  pages         = {2597-2602},
  volume        = {2015-December},
  abstract      = {We proposed ReFrESH in our previous publication. It is a self-adaptive infrastructure aimed at managing the performance of multi-robot systems through dynamically diagnosing and maintaining unexpected issues of modules. To integrate ReFrESH and robotic application-level software more conveniently, it is necessary to develop a module design framework to support implementation of self-adaptive real-time software. To this end, based on the port-based object abstraction and port-automation theory, we propose the Extended Port-Based Object (E-PBO). E-PBO has two main advantages: (1) it builds the basis of a programming model to provide specific, yet flexible, guidelines to robotics application engineers for creating and integrating software modules; (2) it forms the basis of a self-adaption model to provide specific methods for evaluating the running task configuration and estimating the new but non-running task configuration (if required) without interfering with the running configuration. E-PBO has been incorporated into the Port-Based Object Real-Time Operating System (PBO/RT) and applied to a visual servoing robotic application, which is demonstrated here.},
  art_number    = {7353731},
  document_type = {Conference Paper},
  doi           = {10.1109/IROS.2015.7353731},
  file          = {:download_papers/Cui-2015-Real-time software module design framework for building.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {IEEE International Conference on Intelligent Robots and Systems},
  keywords      = {control engineering computing;multi-robot systems;object-oriented programming;operating systems (computers);real-time systems;robot programming;robot vision;self-adjusting systems;visual servoing;real-time software module design framework;self-adaptive robotic systems;ReFrESH;self-adaptive infrastructure;multirobot systems;robotic application-level software;port-based object abstraction;port-automation theory;extended port-based object;E-PBO;running task configuration;port-based object real-time operating system;PBO-RT;visual servoing robotic application;Ports (Computers);Real-time systems;Operating systems;Visual servoing},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84958159183&doi=10.1109%2fIROS.2015.7353731&partnerID=40&md5=1175fb78ed38a116c2eaabcb2d3ee6b9},
}

@InProceedings{Dafflon2018,
  author        = {B. {Dafflon} and N. {Moalla} and Y. {Ouzrout}},
  booktitle     = {2018 12th International Conference on Software, Knowledge, Information Management Applications (SKIMA)},
  title         = {Cyber-Physical Systems network to support decision making for self-adaptive production system},
  year          = {2018},
  month         = {Dec},
  note          = {cited By 0},
  pages         = {1-8},
  volume        = {2018-December},
  abstract      = {Nowadays, recent trends and challenges around industry focus on new enablers for distributed control of manufacturing products and processes. They aim to cope with transition from full parts quality control to continue manufacturing operations control on the part and the resources as well. The objective in this paper is to propose a new self-adaptive Cyber-Physical System enabling control on manufacturing operations. The research problem is to face the gap between the need to support production data changeability and the evolution of manufacturing resources properties and performances.The proposed contribution promotes the Cyber-Physical Systems as a collective decision making support for self-adaptive production systems. Multi Agent Systems are deployed as new layer to take advantage of the decentralized CPSs physical abilities to monitor their environment. This solution makes it possible to integrate real-time workshop status information into the decision-making process. The originality of the contribution consists in involving servitized Cyber-Physical Systems in the decision making process.},
  art_number    = {8631512},
  document_type = {Conference Paper},
  doi           = {10.1109/SKIMA.2018.8631512},
  file          = {:download_papers/Dafflon-2018-Cyber-Physical Systems network to support decision making.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2573-3214},
  journal       = {International Conference on Software, Knowledge Information, Industrial Management and Applications, SKIMA},
  keywords      = {cyber-physical systems;decision making;distributed control;multi-agent systems;process control;production control;production engineering computing;quality control;production data changeability;collective decision making support;self-adaptive production system;decentralized CPSs physical abilities;distributed control;manufacturing products;quality control;multiagent systems;cyber-physical systems;Internet of Things;Dynamic scheduling;Decision making;Manufacturing;Process control;Monitoring;Cyber-physical systems},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85062725733&doi=10.1109%2fSKIMA.2018.8631512&partnerID=40&md5=484720fbd660c3e1bcd56434dfed8a4e},
}

@Conference{DAngelo2018,
  author        = {D'Angelo, M. and Napolitano, A. and Caporuscio, M.},
  title         = {CyPhEF: A model-driven engineering framework for self-Adaptive cyber-physical systems},
  year          = {2018},
  note          = {cited By 7},
  pages         = {101-104},
  abstract      = {Self-Adaptation is nowadays recognized as an effective approach to deal with the uncertainty inherent to cyber-physical systems, which are composed of dynamic and deeply intertwined physical and software components interacting with each other. Engineering a self-Adaptive cyber-physical system is challenging, as concerns about both the physical and the control system should be jointly considered. To this end, we present CyPhEF, a Model-Driven Engineering framework supporting the development and validation of self-Adaptive cyber-physical systems. Demo video: https://youtu.be/nmg-w2kfKEA. © 2018 Authors.},
  document_type = {Conference Paper},
  doi           = {10.1145/3183440.3183483},
  file          = {:download_papers/DAngelo-2018-CyPhEF a model-driven engineering framework for self-adaptive.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings - International Conference on Software Engineering},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85049692631&doi=10.1145%2f3183440.3183483&partnerID=40&md5=60c227525343d737bad1dd92e5d76995},
}

@Article{DaSilva2011b,
  author        = {Da Silva, C.E. and De Lemos, R.},
  journal       = {Informatica (Ljubljana)},
  title         = {A Framework for automatic generation of processes for self-adaptive software systems},
  year          = {2011},
  note          = {cited By 7},
  number        = {1},
  pages         = {3-13},
  volume        = {35},
  abstract      = {The self-adaptation of software systems is a complex process that depends on several factors that can change during the system operational lifetime. Hence, it is necessary to define mechanisms for providing a self-adaptive system the capability of generating during run-time the process that controls its adaptation. This paper presents a framework for the automatic generation of processes for self-adaptive software systems based on the use of workflows, model-based and artificial intelligence planning techniques. Our approach can be applied to different application domains, improves the scalability associated with the generation of adaptation plans, and enables the usage of different planning techniques. For evaluating the approach, we have developed a prototype for generating during run-time the workflows that coordinate the architectural reconfiguration of a web-based application.},
  document_type = {Article},
  file          = {:download_papers/DeSilva-2011-A Framework for automatic generation of processes for.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-79953330809&partnerID=40&md5=5d751569579f3f6aaa181ec0ccc6846d},
}

@Conference{DeLemos2002,
  author        = {De Lemos, R. and Fiadeiro, J.L.},
  title         = {An Architectural Support for Self-Adaptive Software for Treating Faults},
  year          = {2002},
  note          = {cited By 21},
  pages         = {39-42},
  abstract      = {Considering the current trend of building systems from existing components that allow neither code inspection nor change, the solution for enabling dynamic adaptation of software systems should not be intrusive in the way that components should be designed. The architectural approach for treating faults described in this paper, instead of providing mechanisms and techniques at the component level, it relies on the interactions between components for obtaining flexible software structures that are nevertheless robust to the occurrence of undesirable events.},
  document_type = {Conference Paper},
  doi           = {10.1145/582128.582136},
  file          = {:download_papers/Lemos-2002-An architectural support for self-adaptive software for treating.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings of the first ACM SIGSOFT Workshop on Self-Healing Systems (WOSS'02)},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0141649402&doi=10.1145%2f582128.582136&partnerID=40&md5=3090005fe519f76468576a7ea7329cee},
}

@InProceedings{Derakhshanmanesh2011,
  author    = {Derakhshanmanesh, Mahdi and Amoui, Mehdi and O’Grady, Greg and Ebert, J\"{u}rgen and Tahvildari, Ladan},
  booktitle = {Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {GRAF: Graph-Based Runtime Adaptation Framework},
  year      = {2011},
  address   = {New York, NY, USA},
  pages     = {128–137},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’11},
  abstract  = {One approach for achieving runtime adaptability in software is to use application frameworks that are tailored for the development of self-adaptive systems. In this paper, we present the Graph-based Runtime Adaptation Framework (GRAF), which enables adaptivity by creating, managing, and interpreting graph-based models of software at runtime. Having a generic graph representation in our approach allows for flexible adaptation via query and transformation operations. The framework is especially suited for the migration of legacy applications towards adaptive software and attempts to reduce necessary changes to the original software. As a proof of concept, we conduct a comprehensive case study of migrating the legacy game Jake2 to achieve runtime adaptivity using GRAF.},
  doi       = {10.1145/1988008.1988026},
  file      = {:download_papers/Mahdi-2011-GRAF graph-based Runtime Adaptation Framework.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450305754},
  keywords  = {model transformation, runtime adaptivity, adaptation framework, models at runtime, self-adaptive software},
  location  = {Waikiki, Honolulu, HI, USA},
  numpages  = {10},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1988008.1988026},
}

@Article{Derin2009,
  author     = {Derin, Onur and Ferrante, Alberto},
  journal    = {SIGBED Rev.},
  title      = {Enabling Self-Adaptivity in Component-Based Streaming Applications},
  year       = {2009},
  month      = oct,
  number     = {3},
  volume     = {6},
  abstract   = {Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. By means of this mechanism the system is able to autonomously modify its behavior or the way in which applications are run and implemented to achieve the goals set. In this paper we propose a framework that uses a componentbased approach to implement self-adaptivity at application level. By using this mechanism, the framework provides the ability to perform both adaptation on the structure of the application (i.e., how the components are connected together) and on internal parameters of each component. At application level, there is a mechanism to monitor different parameters and to check whether the system is meeting the assigned goals or not. A controller drives adaptations when goals are not met.},
  address    = {New York, NY, USA},
  articleno  = {14},
  doi        = {10.1145/1851340.1851356},
  file       = {:download_papers/Derin-2009-Enabling self-adaptivity in component-based streaming applications.pdf:PDF},
  groups     = {acm, systematic_search},
  issue_date = {October 2009},
  keywords   = {self-adaptive systems, component-based design},
  numpages   = {4},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/1851340.1851356},
}

@Article{Ding2016,
  author        = {Z. {Ding} and Y. {Zhou} and M. {Zhou}},
  journal       = {IEEE Transactions on Systems, Man, and Cybernetics: Systems},
  title         = {Modeling Self-Adaptive Software Systems With Learning Petri Nets},
  year          = {2016},
  issn          = {2168-2232},
  month         = {April},
  note          = {cited By 39},
  number        = {4},
  pages         = {483-498},
  volume        = {46},
  abstract      = {Traditional models unable to model adaptive software systems since they deal with fixed requirements only, but cannot handle the behaviors that change at runtime in response to environmental changes. In this paper, an adaptive Petri net (APN) is proposed to model a self-adaptive software system. It is an extension of hybrid Petri nets by embedding a neural network algorithm into them at some special transitions. The proposed net has the following advantages: 1) it can model a runtime environment; 2) the components in the model can collaborate to make adaption decisions while the system is running; and 3) the computation is done at the local component, while the adaption is for the whole system. We illustrate the proposed APN by modeling a manufacturing system.},
  art_number    = {7115165},
  document_type = {Conference Paper},
  doi           = {10.1109/TSMC.2015.2433892},
  file          = {:download_papers/Ding-2016-Modeling Self-Adaptive Software Systems With Learning Petri Nets.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {learning (artificial intelligence);neural nets;Petri nets;software engineering;self-adaptive software systems modeling;Petri nets learning;adaptive Petri net;APN;neural network algorithm;adaption decision;manufacturing system;Adaptation models;Petri nets;Biological neural networks;Neurons;Software systems;Runtime;Production facilities;Adaptive Petri net (APN);adaptive software system;neural network;requirement modeling;Adaptive Petri net (APN);adaptive software system;neural network;requirement modeling},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84963853253&doi=10.1109%2fTSMC.2015.2433892&partnerID=40&md5=3ea9cd1a638ae963a2372c915c3168ad},
}

@Article{Ding2018,
  author        = {Z. {Ding} and Y. {Zhou} and M. {Zhou}},
  journal       = {IEEE Transactions on Fuzzy Systems},
  title         = {Modeling Self-Adaptive Software Systems by Fuzzy Rules and Petri Nets},
  year          = {2018},
  issn          = {1941-0034},
  month         = apr,
  note          = {cited By 14},
  number        = {2},
  pages         = {967-984},
  volume        = {26},
  abstract      = {A self-adaptive software system is one that can autonomously modify its behavior at runtime in response to changes in the system and its environment. It is a challenge to model such a kind of systems since it is hard to predict runtime environmental changes at the design phase. In this paper, a formal model called intelligent Petri net (I-PN) is proposed to model a self-adaptive software system. I-PN is formed by incorporating fuzzy rules to a regular Petri net. The proposed net has the following advantages. 1) Since fuzzy rules can express the behavior of a system in an interpretable way and their variables can be reconfigured by the runtime data, the proposed model can model runtime environment and system behavior. 2) Since a fuzzy inference system with well-defined semantics can be used in a complementary way with other model languages for the analysis, thus the proposed model can be analyzed, even though it is described in two different languages: component behaviors in Petri nets while logic control in fuzzy rules. 3) The proposed model has self-adaption ability and can make adaptive decisions at runtime with the help of fuzzy inference reasoning. We adopt a manufacturing system to show the feasibility of the proposed model.},
  document_type = {Article},
  doi           = {10.1109/TFUZZ.2017.2700286},
  file          = {:download_papers/Ding-2018-Modeling Self-Adaptive Software Systems by Fuzzy Rules and Petri Nets.pdf:PDF},
  groups        = {ieee, wiley, expert_search, systematic_search},
  keywords      = {fuzzy reasoning;Petri nets;self-adjusting systems;software engineering;fuzzy rules;formal model;intelligent Petri net;regular Petri net;fuzzy inference system;component behaviors;fuzzy inference reasoning;manufacturing system;self-adaptive software systems;logic control;Adaptation models;Petri nets;Production facilities;Data models;Computational modeling;Raw materials;Software systems;Adaptive software system;fuzzy rule;Petri net (PN);requirement modeling},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85044996980&doi=10.1109%2fTFUZZ.2017.2700286&partnerID=40&md5=951f9762969dae9ece4b463c84d93c2b},
}

@InProceedings{Esfahani2011a,
  author        = {N. {Esfahani}},
  booktitle     = {2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011)},
  title         = {A framework for managing uncertainty in self-adaptive software systems},
  year          = {2011},
  month         = {Nov},
  note          = {cited By 5},
  pages         = {646-650},
  abstract      = {Self-adaptation endows a software system with the ability to satisfy certain objectives by automatically modifying its behavior. While many promising approaches for the construction of self-adaptive software systems have been developed, the majority of them ignore the uncertainty underlying the adaptation decisions. This has been one of the key inhibitors to widespread adoption of self-adaption techniques in risk-averse real-world settings. In this research abstract I outline my ongoing effort in the development of a framework for managing uncertainty in self-adaptation. This framework employs state-of-the-art mathematical approaches to model and assess uncertainty in adaptation decisions. Preliminary results show that knowledge about uncertainty allows self-adaptive software systems to make better decisions.},
  art_number    = {6100147},
  document_type = {Conference Paper},
  doi           = {10.1109/ASE.2011.6100147},
  file          = {:download_papers/Esfahani-2011-A framework for managing uncertainty in self-adaptive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1938-4300},
  journal       = {2011 26th IEEE/ACM International Conference on Automated Software Engineering, ASE 2011, Proceedings},
  keywords      = {software engineering;self-adaptive software systems;uncertainty management framework;self-adaption techniques;software engineering;Uncertainty;Software systems;Robots;Analytical models;Runtime;uncertainty;self-adaptation;software architecture},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84855426468&doi=10.1109%2fASE.2011.6100147&partnerID=40&md5=533885e28768537181405e23010b4a6c},
}

@Article{Esfahani2013,
  author        = {N. {Esfahani} and A. {Elkhodary} and S. {Malek}},
  journal       = {IEEE Transactions on Software Engineering},
  title         = {A Learning-Based Framework for Engineering Feature-Oriented Self-Adaptive Software Systems},
  year          = {2013},
  issn          = {1939-3520},
  month         = {Nov},
  note          = {cited By 51},
  number        = {11},
  pages         = {1467-1493},
  volume        = {39},
  abstract      = {Self-adaptive software systems are capable of adjusting their behavior at runtime to achieve certain functional or quality-of-service goals. Often a representation that reflects the internal structure of the managed system is used to reason about its characteristics and make the appropriate adaptation decisions. However, runtime conditions can radically change the internal structure in ways that were not accounted for during their design. As a result, unanticipated changes at runtime that violate the assumptions made about the internal structure of the system could degrade the accuracy of the adaptation decisions. We present an approach for engineering self-adaptive software systems that brings about two innovations: 1) a feature-oriented approach for representing engineers' knowledge of adaptation choices that are deemed practical, and 2) an online learning-based approach for assessing and reasoning about adaptation decisions that does not require an explicit representation of the internal structure of the managed software system. Engineers' knowledge, represented in feature-models, adds structure to learning, which in turn makes online learning feasible. We present an empirical evaluation of the framework using a real-world self-adaptive software system. Results demonstrate the framework's ability to accurately learn the changing dynamics of the system while achieving efficient analysis and adaptation.},
  art_number    = {6574860},
  document_type = {Article},
  doi           = {10.1109/TSE.2013.37},
  file          = {:download_papers/Esfahani-2013-A Learning-Based Framework for Engineering Feature-Oriented.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {inference mechanisms;learning (artificial intelligence);quality of service;software engineering;feature-models;adaptation decision reasoning;adaptation decision assessment;online learning-based approach;runtime conditions;quality-of-service goals;engineering feature-oriented self-adaptive software systems;learning-based framework;Software systems;Runtime;Adaptation models;Quality of service;Authentication;Measurement;Self-adaptive software;autonomic computing;feature-orientation;machine learning},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84887877241&doi=10.1109%2fTSE.2013.37&partnerID=40&md5=4db6d5240b9aba7f072c906e69a1473f},
}

@Article{Fan2016,
  author        = {Fan, R. and Peng, Y.Q. and Chen, Y.F. and Liu, X.H.},
  journal       = {Journal of Software Engineering},
  title         = {Dynamic modeling self-adaptive software by intelligent service components},
  year          = {2016},
  note          = {cited By 0},
  number        = {1},
  pages         = {147-154},
  volume        = {10},
  abstract      = {In order to construct independent autonomous, dynamic evolved, flexible software entity and dynamically assemble them under the internet for self-adaptive software, novel intelligent component model is critical. This paper propose to fusion agent, service and component for building autonomy, dynamic evolved, intelligent accumulated, great granularity Intelligent Service Component (ISC), provide the good software entity for self-adaptive software. We try to expand all functions into services, on command dynamic integrate relative services to Intelligent Service System (ISS). A case shows that the Intelligent Service Component (ISC) is able to dynamic rebuild and intelligent interact each other for software system adaptability. A novel self-adaptive software system is constructed by intelligent service components. © 2016 Academic Journals Inc.},
  document_type = {Article},
  doi           = {10.3923/jse.2016.147.154},
  file          = {:download_papers/Fan-2016-Dynamic Modeling Self-Adaptive Software by Intelligent Service.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84960865902&doi=10.3923%2fjse.2016.147.154&partnerID=40&md5=188af4ab7ee080506f42beadeacec66d},
}

@Conference{Filieri2015,
  author        = {Filieri, A. and Hoffmann, H. and Maggio, M.},
  title         = {Automated multi-objective control for self-adaptive software design},
  year          = {2015},
  note          = {cited By 48},
  pages         = {13-24},
  abstract      = {While software is becoming more complex everyday, the requirements on its behavior are not getting any easier to satisfy. An application should offer a certain quality of service, adapt to the current environmental conditions and withstand runtime variations that were simply unpredictable during the design phase. To tackle this complexity, control theory has been proposed as a technique for managing software's dynamic behavior, obviating the need for human intervention. Control-theoretical solutions, however, are either tailored for the specific application or do not handle the complexity of multiple interacting components and multiple goals. In this paper, we develop an automated control synthesis methodology that takes, as input, the configurable software components (or knobs) and the goals to be achieved. Our approach automatically constructs a control system that manages the specified knobs and guarantees the goals are met. These claims are backed up by experimental studies on three different software applications, where we show how the proposed automated approach handles the complexity of multiple knobs and objectives. © 2015 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/2786805.2786833},
  file          = {:download_papers/Filieri-2015-Automated multi-objective control for self-adaptive software design.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {2015 10th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering, ESEC/FSE 2015 - Proceedings},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84960379897&doi=10.1145%2f2786805.2786833&partnerID=40&md5=8db4ade1c630439103b5e529d250bead},
}

@Article{Filieri2017,
  author        = {Filieri, Antonio and Maggio, Martina and Angelopoulos, Konstantinos and D’ippolito, Nicol\'{a}s and Gerostathopoulos, Ilias and Hempel, Andreas Berndt and Hoffmann, Henry and Jamshidi, Pooyan and Kalyvianaki, Evangelia and Klein, Cristian and Krikava, Filip and Misailovic, Sasa and Papadopoulos, Alessandro V. and Ray, Suprio and Sharifloo, Amir M. and Shevtsov, Stepan and Ujma, Mateusz and Vogel, Thomas},
  journal       = {ACM Trans. Auton. Adapt. Syst.},
  title         = {Control Strategies for Self-Adaptive Software Systems},
  year          = {2017},
  issn          = {1556-4665},
  month         = feb,
  note          = {cited By 16},
  number        = {4},
  volume        = {11},
  abstract      = {The pervasiveness and growing complexity of software systems are challenging software engineering to design systems that can adapt their behavior to withstand unpredictable, uncertain, and continuously changing execution environments. Control theoretical adaptation mechanisms have received growing interest from the software engineering community in the last few years for their mathematical grounding, allowing formal guarantees on the behavior of the controlled systems. However, most of these mechanisms are tailored to specific applications and can hardly be generalized into broadly applicable software design and development processes. This article discusses a reference control design process, from goal identification to the verification and validation of the controlled system. A taxonomy of the main control strategies is introduced, analyzing their applicability to software adaptation for both functional and nonfunctional goals. A brief extract on how to deal with uncertainty complements the discussion. Finally, the article highlights a set of open challenges, both for the software engineering and the control theory research communities. © 2017 ACM.},
  address       = {New York, NY, USA},
  art_number    = {24},
  articleno     = {24},
  document_type = {Review},
  doi           = {10.1145/3024188},
  file          = {:download_papers/Filieri-2017-Control Strategies for Self-Adaptive Software Systems.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  issue_date    = {February 2017},
  keywords      = {Self-adaptive software, control theory, formal methods, non-functional properties},
  numpages      = {31},
  publisher     = {Association for Computing Machinery},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/3024188},
}

@InProceedings{Garlan2004,
  author    = {Garlan, David and Poladian, Vahe and Schmerl, Bradley and Sousa, Jo\~{a}o Pedro},
  booktitle = {Proceedings of the 1st ACM SIGSOFT Workshop on Self-Managed Systems},
  title     = {Task-Based Self-Adaptation},
  year      = {2004},
  address   = {New York, NY, USA},
  pages     = {54–57},
  publisher = {Association for Computing Machinery},
  series    = {WOSS ’04},
  abstract  = {Recently there has been increasing interest in developing systems that can adapt dynamically to cope with changing environmental conditions and unexpected system errors. Most efforts for achieving self-adaptation have focused on the mechanisms for detecting opportunities for improvement and then taking appropriate action. However, such mechanisms beg the question: what is the system trying to achieve? In a given situation there may be many possible adaptations, and knowing which one to pick is a difficult question. In this paper we advocate the use of explicit representation of user task as a critical element in addressing this missing link.},
  doi       = {10.1145/1075405.1075416},
  file      = {:download_papers/Garlan-2004-Task-based self-adaptation.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {1581139896},
  keywords  = {self-adaptation, software architecture, self-management, utility-based optimization, task-aware computing},
  location  = {Newport Beach, California},
  numpages  = {4},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1075405.1075416},
}

@Book{Garlan2009,
  author        = {Garlan, D. and Schmerl, B. and Cheng, S.-W.},
  title         = {Software architecture-based self-adaptation},
  year          = {2009},
  note          = {cited By 58},
  abstract      = {Increasingly, systems must have the ability to self-adapt to meet changes in their execution environment. Unfortunately, existing solutions require human oversight, or are limited in the kinds of systems and the set of quality-of-service concerns they address. Our approach, embodied in a system called Rainbow, uses software architecture models and architectural styles to overcome existing limitations. It provides an engineering approach and a framework of mechanisms to monitor a target system and its environment, reflect observations into a system's architecture model, detect opportunities for improvement, select a course of action, and effect changes in a closed loop. The framework provides general and reusable infrastructures with well-defined customization points, allowing engineers to systematically customize Rainbow to particular systems and concerns. © 2009 Springer Science+Business Media, LLC.},
  document_type = {Book Chapter},
  doi           = {10.1007/978-0-387-89828-5_2},
  file          = {:download_papers/Garlan-2009-Software Architecture-Based Self-Adaptation.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Autonomic Computing and Networking},
  pages         = {31-55},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-79960016261&doi=10.1007%2f978-0-387-89828-5_2&partnerID=40&md5=40138e319d9f87c51395672b7ba36dae},
}

@InProceedings{Gauvrit2010,
  author    = {G. {Gauvrit} and E. {Daubert} and F. {Andre}},
  booktitle = {2010 36th EUROMICRO Conference on Software Engineering and Advanced Applications},
  title     = {SAFDIS: A Framework to Bring Self-Adaptability to Service-Based Distributed Applications},
  year      = {2010},
  month     = {Sep.},
  pages     = {211-218},
  abstract  = {Service Based Applications (SBA) running in distributed and heterogeneous environments are subject to varying constraints that can lead to fluctuations in the quality of the application. We propose a solution in the form of a distributed framework for adaptation to improve in a autonomous way the quality delivered by those applications and to maintain it above a minimum level. This framework, named SAFDIS for Self-Adaptation For DIstributed Services, enables the dynamic evolution of service-based architectures by providing all the functionalities of the MAPE model. Among these functionalities, particular emphasis is put on the analysis phase which permits to use several reasoners able to take decisions with multiple temporal scopes, at short term as well as at long term. Specific attention is also paid to the planning phase, which enables to schedule parallel actions while taking into account different constraints.},
  doi       = {10.1109/SEAA.2010.25},
  file      = {:download_papers/Gauvrit-2010-SAFDIS A Framework to Bring Self-Adaptability to Service-Based.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2376-9505},
  keywords  = {distributed processing;software architecture;SAFDIS;service-based distributed applications;MAPE model;self-adaptation for distributed services;service-based architectures;Engines;Servers;Streaming media;Monitoring;Probes;Schedules;Self-adaptation;Distributed Applications;SOA;Distributed Adaptation Framework},
}

@InProceedings{Ge2010,
  author    = {L. {Ge} and B. {Zhang}},
  booktitle = {2010 International Conference on Multimedia Information Networking and Security},
  title     = {A Modeling Approach on Self-Adaptive Composite Services},
  year      = {2010},
  month     = {Nov},
  pages     = {240-244},
  abstract  = {Self-Adaptation has gained wide attention in SOA (Service Oriented Architecture). Composite services adjust dynamically to the change of environment during execution through adaptation. Most existing performance analyzing methods on composite service neglect the distinguished feature of environment, which impedes their application in self-adaptive composite services. This paper proposes a stochastic Petri net based method on modeling an environment-aware self-adaptive strategy which is also suggested in this paper. Our method builds separate models for both service and environment, which would contribute to model the environment checking procedure in EaSA. As we discussed in the paper, the idea of separate model for service and environment would play a significant role in modeling self-adaptive composite services.},
  doi       = {10.1109/MINES.2010.60},
  file      = {:download_papers/Liang-2010-A Modeling Approach on Self-Adaptive Composite Services.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2162-8998},
  keywords  = {Petri nets;service-oriented architecture;software performance evaluation;stochastic processes;self-adaptive composite services;SOA;service oriented architecture;execution;performance analysis;stochastic Petri net;EaSA;Adaptation model;Reliability;Stochastic processes;Analytical models;Service oriented architecture;Predictive models;Environment-aware Self-adaption;EaSA;Performace Model;Stochastic Petri Net},
}

@InProceedings{Georgas2005a,
  author    = {Georgas, John C. and van der Hoek, Andr\'{e} and Taylor, Richard N.},
  booktitle = {Proceedings of the 2005 Workshop on Architecting Dependable Systems},
  title     = {Architectural Runtime Configuration Management in Support of Dependable Self-Adaptive Software},
  year      = {2005},
  address   = {New York, NY, USA},
  pages     = {1–6},
  publisher = {Association for Computing Machinery},
  series    = {WADS ’05},
  abstract  = {The dynamic nature of some self-adaptive software systems can result in potentially unpredictable adaptations, which may be detrimental to overall system dependability by diminishing trust in the adaptation process. This paper describes our initial work with architectural runtime configuration management in order to improve dependability and overall system usefulness by maintaining a record of reconfigurations and providing support for architectural recovery operations. Our approach---fully decoupled from self-adaptive systems themselves and the adaptation management processes governing their changes---provides for better adaptation visibility and self-adaptive process dependability. We elaborate on the vision for our overall approach, present early implementation and testing results from prototyping efforts, and discuss our future plans.},
  doi       = {10.1145/1083217.1083225},
  file      = {:download_papers/Georgas-2005-Architectural runtime configuration management in support.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {1595931244},
  keywords  = {self-adaptive software, dependability, architectural runtime configuration management},
  location  = {St. Louis, Missouri},
  numpages  = {6},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1083217.1083225},
}

@Article{Gerostathopoulos2016,
  author        = {Gerostathopoulos, I. and Bures, T. and Hnetynka, P. and Keznikl, J. and Kit, M. and Plasil, F. and Plouzeau, N.},
  journal       = {Journal of Systems and Software},
  title         = {Self-adaptation in software-intensive cyber–physical systems: From system goals to architecture configurations},
  year          = {2016},
  note          = {cited By 25},
  pages         = {378-397},
  volume        = {122},
  abstract      = {Design of self-adaptive software-intensive cyber–physical systems (siCPS) operating in dynamic environments is a significant challenge when a sufficient level of dependability is required. This stems partly from the fact that the concerns of self-adaptivity and dependability are to an extent contradictory. In this paper, we introduce IRM-SA (Invariant Refinement Method for Self-Adaptation)—a design method and associated formally grounded model targeting siCPS—that addresses self-adaptivity and supports dependability by providing traceability between system requirements, distinct situations in the environment, and predefined configurations of system architecture. Additionally, IRM-SA allows for architecture self-adaptation at runtime and integrates the mechanism of predictive monitoring that deals with operational uncertainty. As a proof of concept, it was implemented in DEECo, a component framework that is based on dynamic ensembles of components. Furthermore, its feasibility was evaluated in experimental settings assuming decentralized system operation. © 2016},
  document_type = {Article},
  doi           = {10.1016/j.jss.2016.02.028},
  file          = {:download_papers/Gerostathopoulos-2016-Self-adaptation in software-intensive CPSs.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84960976259&doi=10.1016%2fj.jss.2016.02.028&partnerID=40&md5=17808c5482bbf8923bd5b5b46a557049},
}

@Article{Gerostathopoulos2019b,
  author        = {Gerostathopoulos, I. and Skoda, D. and Plasil, F. and Bures, T. and Knauss, A.},
  journal       = {Journal of Systems and Software},
  title         = {Tuning self-adaptation in cyber-physical systems through architectural homeostasis},
  year          = {2019},
  note          = {cited By 3},
  pages         = {37-55},
  volume        = {148},
  abstract      = {Self-adaptive software-intensive cyber-physical systems (sasiCPS) encounter a high level of run-time uncertainty. State-of-the-art architecture-based self-adaptation approaches assume designing against a fixed set of situations that warrant self-adaptation. As a result, failures may appear when sasiCPS operate in environment conditions they are not specifically designed for. In response, we propose to increase the homeostasis of sasiCPS, i.e., the capacity to maintain an operational state despite run-time uncertainty, by introducing run-time changes to the architecture-based self-adaptation strategies according to environment stimuli. In addition to articulating the main idea of architectural homeostasis, we introduce four mechanisms that reify the idea: (i) collaborative sensing, (ii) faulty component isolation from adaptation, (iii) enhancing mode switching, and (iv) adjusting guards in mode switching. Moreover, our experimental evaluation of the four mechanisms in two different case studies confirms that allowing a complex system to change its self-adaptation strategies helps the system recover from run-time errors and abnormalities and keep it in an operational state. © 2018 Elsevier Inc.},
  document_type = {Article},
  doi           = {10.1016/j.jss.2018.10.051},
  file          = {:download_papers/Gerostathopoulos-2018-Tuning self-adaptation in CPSs.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85056237002&doi=10.1016%2fj.jss.2018.10.051&partnerID=40&md5=25d686eab674f7e84f8a9f5908967d7b},
}

@InProceedings{Gil2015,
  author    = {R. {Gil}},
  booktitle = {2015 IEEE/ACM 37th IEEE International Conference on Software Engineering},
  title     = {Automated Planning for Self-Adaptive Systems},
  year      = {2015},
  month     = {May},
  pages     = {839-842},
  volume    = {2},
  abstract  = {Self-adaptation has been proposed as a viable solution to alleviate the management burden that is induced by the dynamic nature and increasing complexity of computer systems. In this context, architectural-based self-adaptation has emerged as one of the most promising approaches to automatically manage such systems, resorting to a control loop that includes monitoring, analyzing, planning, and executing adequate actions. This work addresses the challenges of adaptation planning -the decision-making process for selecting an appropriate course of action- with a focus on the problem of provisioning automated mechanisms for assembling adaptation plans, as a means to enhance adaptive capabilities under uncertainty. To this purpose, adaptations are modeled in a hierarchical manner, defining primitive actions, guarded actions, and deliberate plans, which may guide the system towards a desired state.},
  doi       = {10.1109/ICSE.2015.273},
  file      = {:download_papers/Gil-2015-Automated Planning for Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1558-1225},
  keywords  = {decision making;fault tolerant computing;planning;automated planning;self-adaptive systems;computer systems;architectural-based self-adaptation;system management;control loop;adaptation planning;decision-making process;Planning;Adaptation models;Measurement;Uncertainty;Software;Adaptive systems;Medical services;automated planning;PDDL;self-adaptive;self-management;planning},
}

@Article{Gummalla2020,
  author        = {Gummalla, S. and Rao, G.V. and Swamy, G.V.},
  journal       = {Advances in Intelligent Systems and Computing},
  title         = {Esadsa: Enhanced self-adaptive dynamic software architecture},
  year          = {2020},
  note          = {cited By 0},
  pages         = {601-617},
  volume        = {1090},
  abstract      = {With the advent of new technologies and the trend in integration of related business, the software development has become very complex. However, complex systems are realized due to distributed computing technologies like Web services. With machine-to-machine (M2 M) interaction, human intervention is greatly reduced in distributed applications. Nevertheless, there is need for continuous changes in complex software systems. Manual incorporation of changes is both time consuming and tedious task. The self-adaptive features of software can cater to the needs of ad hoc demands pertaining to changes. Therefore, it is desirable to have a self-adaptive software architecture for distributed systems to adapt to changes automatically without traditional reengineering process involved in software update. The existing solutions do have limitations in self-adaptation and need human intervention. Rainbow is one of the examples for self-adaptive dynamic software architecture. However, it does not have knowledge mining and quality of software analysis for further improvements. It is essential to have such enhancements in the wake of self-adaptive systems of enterprises producing huge amount of data related to operations, service quality and other information required for analysing the architecture. We proposed a self-adaptive dynamic software architecture named enhanced self-adaptive dynamic software architecture (ESADSA) which is influenced by Rainbow. It incorporates modules such as QoS analyser and knowledge miner with two data mining algorithms for enhancing capabilities of the architecture. ESADSA decouples self-adaptation from target system by preserving cohesion of target system with loosely coupled interaction. A real-time case study is considered for proof of the concept. The experimental results revealed significant improvements in dynamic self-adaptation of the proposed architecture. © Springer Nature Singapore Pte Ltd. 2020.},
  document_type = {Conference Paper},
  doi           = {10.1007/978-981-15-1480-7_51},
  file          = {:download_papers/Gummalla-2020-Esadsa.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85083970964&doi=10.1007%2f978-981-15-1480-7_51&partnerID=40&md5=e7c34299b9ae05158cac18dbaddecfc2},
}

@InProceedings{Hachicha2016,
  author    = {M. {Hachicha} and E. {Dammak} and R. B. {Halima} and A. H. {Kacem}},
  booktitle = {2016 17th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD)},
  title     = {A correct by construction approach for modeling and formalizing self-adaptive systems},
  year      = {2016},
  month     = {May},
  pages     = {379-384},
  abstract  = {Self-adaptive systems adapt their own behavior autonomously in order to control the satisfaction of their requirements under changing environmental conditions. MAPE (Monitor, Analyze, Plan and Execute) control loops have been used as important models for realizing self-adaptation. Adaptive systems are generally more difficult to design, specify and verify due to their high complexity. In this paper, we propose a formal refinement approach that aims first to model self-adaptive systems based on MAPE control loop. Second, our approach aims to formally specify self-adaptive systems at a high level of abstraction using the Event-B method providing correct by construction software. This formal specification provides a way to verify correctness of self-adaptive systems regarding a number of criteria. We provide a software tool (as an Eclipse plug-in) that supports designers in their architectural choices by defining a set of patterns describing the different ways of organizing MAPE loops, such as Master/Slave, coordinated control and hierarchical control. We illustrate our approach within a marine monitoring environment case study for validation purpose.},
  doi       = {10.1109/SNPD.2016.7515928},
  file      = {:download_papers/Hachicha-2016-A correct by construction approach for modeling and.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {formal specification;self-adjusting systems;software architecture;software tools;architectural choice;marine monitoring environment;hierarchical control;coordinated control;master-slave;software tool;formal specification;abstraction;Event-B method;monitor-analyze-plan-and-execute control loops;MAPE control loop;formal refinement approach;self-adaptive systems;Unified modeling language;Monitoring;Adaptation models;Temperature sensors;Context;Probes;Temperature measurement;Self-adaptive systems;MAPE control loop;Design patterns;Event-B method;UML profile},
}

@InProceedings{Hachicha2018,
  author    = {M. {Hachicha} and R. B. {Halima} and A. H. {Kacem}},
  booktitle = {2018 12th International Conference on Research Challenges in Information Science (RCIS)},
  title     = {Formalizing compound MAPE patterns for decentralized control in self-adaptive systems},
  year      = {2018},
  month     = {May},
  pages     = {1-10},
  abstract  = {Self-adaptive systems are able to adjust au-tonomously their behavior when the software or hardware is not accomplishing what it is intended to do. The MAPE control loop, based on the following components: Monitor, Analyze, Plan and Execute, is a prominent approach for realizing adaptation. Engineering complex self-adaptive systems needs the use of several architectural patterns in a composed form in their designs. In this paper, we focus on modeling compound MAPE patterns for decentralized control in self-adaptive systems and defining formally the composition process using the Event-B method. The composition of design patterns is illustrated by the composition of the master/slave and the coordinated control patterns.},
  doi       = {10.1109/RCIS.2018.8406680},
  file      = {:download_papers/Hachicha-2018-Formalizing compound MAPE patterns for decentralized control.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2151-1357},
  keywords  = {adaptive systems;decentralised control;large-scale systems;multi-agent systems;object-oriented methods;self-adjusting systems;software architecture;compound MAPE patterns;decentralized control;MAPE control loop;engineering complex self-adaptive systems;architectural patterns;design patterns;coordinated control patterns;composition process;Event-B method;Compounds;Merging;Monitoring;Unified modeling language;Decentralized control;Software;Process control},
}

@InProceedings{Han2006,
  author    = {S. {Han} and S. {Zhang} and Y. {Zhang}},
  booktitle = {2006 2nd IEEE International Symposium on Dependable, Autonomic and Secure Computing},
  title     = {Self-Adaptive Pervasive Computing Application Based on Code Mobility},
  year      = {2006},
  month     = {Sep.},
  pages     = {145-154},
  abstract  = {A traditional application with only one design paradigm can not well adapt to the constant variations of contexts and user preferences in pervasive computing. In this paper, we argue that a pervasive computing application should support multiple design paradigms and present an approach to dynamically selecting the most appropriate paradigm at runtime according to environmental changes. Based on analyzing the characteristics of adaptive software architecture, this paper presents the general paradigm selection rules which can be combined with the specific context to automatically or semi-automatically create the applicable software (re)configuration strategies. For mobile components paradigm, a novel heuristic software partitioning algorithm is proposed to reasonably allocate a pervasive computing application among machines for resource conservation. Finally, we discuss a case study that demonstrates the flexibility and effectiveness of our approach},
  doi       = {10.1109/DASC.2006.43},
  file      = {:download_papers/Han-2006-Self-Adaptive Pervasive Computing Application Based on Code Mobility.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {self-adjusting systems;software architecture;ubiquitous computing;selfadaptive pervasive computing;code mobility;adaptive software architecture;software reconfiguration;software partitioning algorithm;Pervasive computing;Application software;Software architecture;Java;Mobile computing;Runtime environment;Partitioning algorithms;Distributed computing;Mobile agents;Computer networks;Design Paradigm;Dynamic Selection;Pervasive Computing;Software Architecture},
}

@InProceedings{Han2016,
  author        = {D. {Han} and J. {Xing} and Q. {Yang} and J. {Li} and H. {Wang}},
  booktitle     = {2016 IEEE 40th Annual Computer Software and Applications Conference (COMPSAC)},
  title         = {Handling Uncertainty in Self-Adaptive Software Using Self-Learning Fuzzy Neural Network},
  year          = {2016},
  month         = {June},
  note          = {cited By 2},
  pages         = {540-545},
  volume        = {2},
  abstract      = {Uncertainty has posed great challenges to the development and application of self-adaptive software (SAS). To handle uncertainty underneath SAS, the technique of fuzzy control method has been employed to model and develop SASs. Practices prove that fuzzy logic is powerful to handle uncertainty, especially fuzzy uncertainty, within SAS. However, fuzzy control based SAS needs software developers to set fuzzy rules of the system, which is rather experience-dependent and heavily increases development burden of software engineers. To some extent, the effect of handling uncertainty depends on experiences of software engineers. Besides, fuzzy control based SAS realizes self-adaptation logic using fixed fuzzy rules, lacking the ability to adapt to large changes (e.g., scenario switches). In order to make up the above shortages of fuzzy control based SAS, we present the Fuzzy-Learning SAS, attempting to construct self-adaptation logic using self-learning fuzzy neural network. By incorporating the model of fuzzy neural network, Fuzzy-Learning models SAS with two feedback loops, i.e., the self-adaptation loop and the self-learning loop, enabling SASs with the ability of adapting to dynamic changes and the ability of automatically constructing self-adaptation logic. We have experimentally evaluated effectiveness and efficiency of Fuzzy-Learning SAS with a motivating example. The experiment results confirmed that Fuzzy-Learning SAS can improve the effect of handling uncertainty and alleviate the development burden of software engineers with ill knowledge of fuzzy control. Besides, Fuzzy-Learning SAS can adapt to large changes (e.g., scenario switches) with the self-learning ability.},
  art_number    = {7552269},
  document_type = {Conference Paper},
  doi           = {10.1109/COMPSAC.2016.125},
  file          = {:download_papers/Han-2016-Handling Uncertainty in Self-Adaptive Software Using Self-Learning.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {0730-3157},
  journal       = {Proceedings - International Computer Software and Applications Conference},
  keywords      = {feedback;fuzzy control;fuzzy neural nets;learning (artificial intelligence);software engineering;uncertainty handling;uncertainty handling;self-adaptive software;self-learning fuzzy neural network;fuzzy control method;fixed fuzzy rules;feedback loops;self-adaptation loop;self-learning loop;fuzzy-learning SAS;Synthetic aperture sonar;Software;Uncertainty;Fuzzy control;Fuzzy neural networks;Fuzzy logic;Marine vehicles;Uncertainty;software self-adaptation;self-adaptive software;fuzzy neural network;self-learning},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84988035744&doi=10.1109%2fCOMPSAC.2016.125&partnerID=40&md5=5f4cc7a8cf787e0234568202fbf5b3a1},
}

@InProceedings{Hernandez-Sosa2005,
  author    = {D. {Hernandez-Sosa} and A. C. {Dominguez-Brito} and C. {Guerra-Artal} and J. {Cabrera-Gamez}},
  booktitle = {2005 IEEE/RSJ International Conference on Intelligent Robots and Systems},
  title     = {Runtime self-adaptation in a component-based robotic framework},
  year      = {2005},
  month     = {Aug},
  pages     = {2700-2705},
  abstract  = {The development and maintenance of software for robotic systems is a hard task due to the complexity inherent in these systems. Besides, the resulting applications have to deal with limited resources and variable execution conditions that must be considered in order to keep an acceptable system performance. To address both problems we have integrated a set of dynamic adaptation policies inside CoolBOT, a component oriented framework for programming robotic systems. CoolBOT contributes to reduce the programming effort, promoting robustness and code reuse, while the adaptation scheme provides a dynamic modulation of system performance to meet available computational resources at runtime. In this paper we also present two demonstrators that outline the benefits of using the proposed approach in the development of real robotic applications.},
  doi       = {10.1109/IROS.2005.1545578},
  file      = {:download_papers/Hernandez Sosa-2006-Runtime self-adaptation in a component-based robotic.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2153-0866},
  keywords  = {robot programming;software maintenance;object-oriented programming;robust control;adaptive control;software reusability;runtime self-adaptation;component-based robotics;software development;software maintenance;robotic system software;CoolBOT;component oriented software;robotic system programming;robustness;code reuse;self-adaptive software components;Runtime;Application software;Robot programming;Dynamic programming;Calibration;Software maintenance;Software systems;System performance;Robustness;Adaptive control;Robotic systems;self-adaptive software components},
}

@InProceedings{Hiba2017,
  author    = {H. {Hiba} and S. {Mahdavi} and S. {Rahnamayan}},
  booktitle = {2017 IEEE Symposium Series on Computational Intelligence (SSCI)},
  title     = {Differential evolution with self-adaptive mutation scaling factor},
  year      = {2017},
  month     = {Nov},
  pages     = {1-8},
  abstract  = {Throughout the past few decades, a variant of differential evolution (DE) algorithms have been introduced with a competitive performance on complex optimization problems. However, the DE superiority is highly dependent on its control parameters and the search operators (i.e., mutation and crossover schemes). Therefore, to obtain the optimal performance, tuning the parameters is essential. In this paper, the DE algorithm is proposed that uses a new designed mutation scaling factor to dynamically adapt the movement of the individuals in the search space toward the optimal value during the evolutionary process. The numerical experiments are conducted on thirty CEC 2014 benchmark functions on four different dimensions; 10, 30, 50, and 100. The obtained results demonstrate that the proposed algorithm is highly competitive and shows better performance than the classical DE algorithm.},
  doi       = {10.1109/SSCI.2017.8285170},
  file      = {:download_papers/Hiba-2017-Differential evolution with self-adaptive mutation scaling factor.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {evolutionary computation;optimisation;search problems;CEC 2014 benchmark functions;mutation scaling factor;optimal performance;crossover schemes;search operators;control parameters;complex optimization problems;competitive performance;self-adaptive mutation;differential evolution;optimal value;search space;DE algorithm;Sociology;Statistics;Noise measurement;Linear programming;Optimization;Algorithm design and analysis;Benchmark testing;Differential Evolution;A self adaptive Parameters;Evolutionary Optimization},
}

@InProceedings{Hissam2015,
  author    = {Hissam, Scott A. and Chaki, Sagar and Moreno, Gabriel A.},
  booktitle = {Proceedings of the 2015 European Conference on Software Architecture Workshops},
  title     = {High Assurance for Distributed Cyber Physical Systems},
  year      = {2015},
  address   = {New York, NY, USA},
  publisher = {Association for Computing Machinery},
  series    = {ECSAW ’15},
  abstract  = {Distributed Adaptive Real-Time (DART) systems are interconnected and collaborating systems that continuously must satisfy guaranteed and highly critical requirements (e.g., collision avoidance), while at the same time adapt, smartly, to achieve best-effort and low-critical application requirements (e.g., protection coverage) when operating in dynamic and uncertain environments. This short paper introduces our architecture and approach to engineering a DART system so that we achieve high assurance in its runtime behavior against a set of formally specified requirements. It describes our technique to: (i) ensure asymmetric timing protection between high- and low-critical threads on each node in the DART system, and (ii) verify that the self-adaptation within, and coordination between, the nodes and their interaction with the physical environment do not violate high and low criticality requirements. We present our ongoing research to integrate advances in model-based engineering with compositional analysis techniques to formally verify safety-critical properties demanded in safety-conscious domains such as aviation and automotive; and introduce our DART model problem to demonstrate of our engineering approach.},
  articleno = {6},
  doi       = {10.1145/2797433.2797439},
  file      = {:download_papers/Hissam-2015-High Assurance for Distributed Cyber Physical Systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450333931},
  keywords  = {self-adaptation, architecture, model-checking, Real-time},
  location  = {Dubrovnik, Cavtat, Croatia},
  numpages  = {4},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2797433.2797439},
}

@Conference{Ho2015,
  author        = {Ho, H.N. and Lee, E.},
  title         = {Model-based reinforcement learning approach for planning in self-adaptive software system},
  year          = {2015},
  note          = {cited By 8},
  abstract      = {Policy-based adaptation is one of interesting topics in selfadaptive software research community. Current works in the field proposed the term of policy evolution, which concentrate to tackle the impact of environmental uncertainty on adaptation decision. These works adopted the advances of Reinforcement Learning (RL) to continuously optimize system behavior in run-time. However, there are several issues remain very primitive in current researches, especially the arbitrary exploitation-exploration trade-off and random exploration, which could lead to slow learning, hence, frail decision in exceptional situations. With model-free approach, these works could not leverage the knowledge about underlying system, which is essential and plentiful in software engineering, to enhance their learning. In this paper, we introduce the advantages of model-based RL. By utilizing engineering knowledge, system maintains a model of interaction with its environment and predicts the consequence of its action, to improve and guarantee system performance. We also discuss the engineering issues and propose a procedure to adopt model-based RL to build a self-adaptive software and bring policy evolution closer to real-world applications.},
  art_number    = {a103},
  document_type = {Conference Paper},
  doi           = {10.1145/2701126.2701191},
  file          = {:download_papers/Ho-2015-Model-based reinforcement learning approach for planning.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {ACM IMCOM 2015 - Proceedings},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84926166573&doi=10.1145%2f2701126.2701191&partnerID=40&md5=a87b5b9970d23b5b981d533592568ea7},
}

@InProceedings{HonglongChen2010,
  author        = {{Honglong Chen} and {Renfa Li} and {Rui Li} and {Edwin Sha}},
  booktitle     = {2010 2nd International Conference on Computer Engineering and Technology},
  title         = {A component assignment method based on Self-Adaptive software architecture model},
  year          = {2010},
  month         = {April},
  note          = {cited By 0},
  pages         = {V4-682-V4-686},
  volume        = {4},
  abstract      = {The research on Self-Adaptive evolution software is one of the new focuses in the domain of software engineering and the mechanism that makes software adapt to the architecture Meta information catches more attention. It makes full use of architecture information as meta-information in running system to decouple the object's invocation, so as to make system dynamic evolution flexibly. This also introduces the problem of assignment between base-component and meta-component. We make some research on this problem of component assignment in this paper, and first propose the component assignment model and prove the problem is NP, and then find a heuristic algorithm to solve it. Finally, the experiments show that compared with Greedy and ILP, the proposed algorithm has some advantages.},
  art_number    = {5485311},
  document_type = {Conference Paper},
  doi           = {10.1109/ICCET.2010.5485311},
  file          = {:download_papers/Chen-2010-A component assignment method based on Self-Adaptive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {ICCET 2010 - 2010 International Conference on Computer Engineering and Technology, Proceedings},
  keywords      = {computational complexity;object-oriented programming;software architecture;component assignment method;self-adaptive software architecture;self-adaptive evolution software;base-component;meta-component;component assignment problem;heuristic algorithm;Software architecture;Computer architecture;Pervasive computing;Computer networks;Distributed computing;Embedded computing;Runtime;Heuristic algorithms;Embedded software;IP networks;self-Adaptive software;online evolution;software architecture model;component assignment},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-77958073971&doi=10.1109%2fICCET.2010.5485311&partnerID=40&md5=ee34c06e042732690c909a6f92dbd5c4},
}

@InProceedings{Horikoshi2012,
  author    = {Horikoshi, Hisayuki and Nakagawa, Hiroyuki and Tahara, Yasuyuki and Ohsuga, Akihiko},
  booktitle = {Proceedings of the 27th Annual ACM Symposium on Applied Computing},
  title     = {Dynamic Reconfiguration in Self-Adaptive Systems Considering Non-Functional Properties},
  year      = {2012},
  address   = {New York, NY, USA},
  pages     = {1144–1150},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’12},
  abstract  = {Self-adaptive systems have recently been receiving much attention because of their ability to cope with the changes of environment, failures, and unanticipated events. These systems need an adaptation mechanism, which automatically computes the possible configurations, and decides the most appropriate configuration to fit the environment. In particular, the satisfaction of non-functional requirements must be considered when selecting the best reconfiguration. However, there are trade-off problems among non-functional requirements. Moreover, the adaptation mechanisms are typically developed separately from the components to be implemented, and it complicates the construction of such systems. We propose (1) a feature-oriented analysis technique, which can identify adaptation points, and calculate the contribution to non-functional goals of the configuration; (2) a component specification model, which extends an architectural description language for self-adaptation; (3) a reconfiguration framework aimed to reduce the complexity of the reconfiguration and generate the best configuration at run-time. We evaluate the feasibility of our framework by four different scenarios, and show that our framework reduces the complexity of the reconfiguration, and solves the trade-off problem among non-functional requirements.},
  doi       = {10.1145/2245276.2231956},
  file      = {:download_papers/Horikoshi-2012-Dynamic reconfiguration in self-adaptive systems considering.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450308571},
  keywords  = {feature-oriented analysis, dynamic reconfiguration, self-adaptive systems, software architecture, architecture description language},
  location  = {Trento, Italy},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2245276.2231956},
}

@InProceedings{Hrabia2019,
  author    = {C. {Hrabia} and P. M. {Lehmann} and S. {Albayrak}},
  booktitle = {2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC)},
  title     = {Increasing Self-Adaptation in a Hybrid Decision-Making and Planning System with Reinforcement Learning},
  year      = {2019},
  month     = {Jul},
  pages     = {469-478},
  volume    = {1},
  abstract  = {Task-level decision-making and AI planning are used to control autonomous robots from a high-level, mission-oriented perspective. The dynamic selection of most suitable actions allows the system to adapt to changes in the environment as well as its own state. Nevertheless, decision-making and AI planning often require a priori definitions of capabilities, rules, decision models, or world knowledge. Due to the challenge of handling the uncertainty of robot applications in dynamic and uncontrolled environments such definitions or descriptions are always incomplete, hence the possible adaptation capabilities are limited. In this paper, we present how the self-adaptation of a robot planning and decision-making system can be improved by incorporating reinforcement learning. Particularly, we show our approach of integrating deep reinforcement learning into the ROS Hybrid Behaviour Planner (RHBP).},
  doi       = {10.1109/COMPSAC.2019.00073},
  file      = {:download_papers/Hrabia-2019-Increasing Self-Adaptation in a Hybrid Decision-Making and Planning.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {control engineering computing;decision making;learning (artificial intelligence);mobile robots;operating systems (computers);planning (artificial intelligence);robot programming;planning system;task-level decision-making;AI planning;autonomous robots;mission-oriented perspective;dynamic selection;decision models;robot applications;robot planning;deep reinforcement learning;hybrid decision-making;adaptation capabilities;reinforcement learning;self-adaptation;ROS hybrid behaviour planner;Robots;Planning;Decision making;Sensors;Reinforcement learning;Gradient methods;decision-making, planning, reinforcement learning, self-adaptation, autonomous robots},
}

@Article{Iber2017a,
  author        = {Iber, J. and Rauter, T. and Krisper, M. and Kreiner, C.},
  journal       = {Communications in Computer and Information Science},
  title         = {The potential of self-adaptive software systems in industrial control systems},
  year          = {2017},
  note          = {cited By 6},
  pages         = {150-161},
  volume        = {748},
  abstract      = {New generations of industrial control systems offer higher performance, are networked and can be controlled remotely. Following this progress, the complexity of such systems increases through heterogeneous systems, hardware and more capable software. This may lead to an increase of unreliability and insecurity. Self-adaptive software systems offer a mean of dealing with complexity by monitoring a control system, detecting anomalies and adapting the control system to problems. Regarding such methods, industrial control systems have the advantage of being less dynamic. The network topology is fixed, devices rarely change, and the functionality of all the resources is known in principle. In this work, we examine this advantage and present the potential of self-adaptive software systems. The context of the presented work is control systems for hydropower units. © 2017, Springer International Publishing AG.},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-319-64218-5_12},
  file          = {:download_papers/Iber-2017-The potential of self-adaptive software systems in industrial.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85030635378&doi=10.1007%2f978-3-319-64218-5_12&partnerID=40&md5=285850d20ec854dd30c886ef753cb5fd},
}

@InProceedings{Ibrahim2006,
  author    = {M. T. {Ibrahim} and R. J. {Anthony} and T. {Eymann} and A. {Taleb-Bendiab} and L. {Gruenwald}},
  booktitle = {17th International Workshop on Database and Expert Systems Applications (DEXA'06)},
  title     = {Exploring Adaptation Self-Adaptation in Autonomic Computing Systems},
  year      = {2006},
  month     = {Sep.},
  pages     = {129-138},
  abstract  = {This panel paper sets out to discuss what self-adaptation means, and to explore the extent to which current autonomic systems exhibit truly self-adaptive behaviour. Many of the currently cited examples are clearly adaptive, but debate remains as to what extent they are simply following prescribed adaptation rules within preset bounds, and to what extent they have the ability to truly learn new behaviour. Is there a standard test that can be applied to differentiate? Is adaptive behaviour sufficient anyway? Other autonomic computing issues are also discussed.},
  doi       = {10.1109/DEXA.2006.57},
  file      = {:download_papers/Ibrahim-2006-Exploring Adaptation & Self-Adaptation in Autonomic.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2378-3915},
  keywords  = {Application software;Ontologies;Testing;Terminology;Computer science;Communication standards;Adaptive systems;Databases;Expert systems},
}

@Article{Iglesia2015,
  author     = {Iglesia, Didac Gil De La and Weyns, Danny},
  journal    = {ACM Trans. Auton. Adapt. Syst.},
  title      = {MAPE-K Formal Templates to Rigorously Design Behaviors for Self-Adaptive Systems},
  year       = {2015},
  issn       = {1556-4665},
  month      = sep,
  number     = {3},
  volume     = {10},
  abstract   = {Designing software systems that have to deal with dynamic operating conditions, such as changing availability of resources and faults that are difficult to predict, is complex. A promising approach to handle such dynamics is self-adaptation that can be realized by a MAPE-K feedback loop (Monitor-Analyze-Plan-Execute plus Knowledge). To provide evidence that the system goals are satisfied, given the changing conditions, the state of the art advocates the use of formal methods. However, little research has been done on consolidating design knowledge of self-adaptive systems. To support designers, this paper contributes with a set of formally specified MAPE-K templates that encode design expertise for a family of self-adaptive systems. The templates comprise: (1) behavior specification templates for modeling the different components of a MAPE-K feedback loop (based on networks of timed automata), and (2) property specification templates that support verification of the correctness of the adaptation behaviors (based on timed computation tree logic). To demonstrate the reusability of the formal templates, we performed four case studies in which final-year Masters students used the templates to design different self-adaptive systems.},
  address    = {New York, NY, USA},
  articleno  = {15},
  doi        = {10.1145/2724719},
  file       = {:download_papers/Iglesia-2015-MAPE-K Formal Templates to Rigorously Design Behaviors for.pdf:PDF},
  groups     = {acm, systematic_search},
  issue_date = {October 2015},
  keywords   = {Formal templates, self-adaptation, MAPE-K},
  numpages   = {31},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/2724719},
}

@InProceedings{Itmi2010,
  author    = {M. {Itmi} and A. {Cardon}},
  booktitle = {2010 5th International Conference on System of Systems Engineering},
  title     = {Model for self-adaptive SoS and the control problem},
  year      = {2010},
  month     = {June},
  pages     = {1-6},
  abstract  = {In this paper, we propose methods to deal with self-adaptive information systems where one has to control in real time a complex substratum organized with numerous proactive elements continuously producing active links and generating multiple informational exchanges. Such exchanges arise when linking concurrent distributed complex systems. More generally, the growing complexity of today's grand challenges suits such situations and needs solutions that are of a system of systems (SoS) nature. The paper concentrates on the representation of the controlled state of the substratum for a complex adaptive SoS and highlights the control aspect.},
  doi       = {10.1109/SYSOSE.2010.5544101},
  file      = {:download_papers/Itmi-2010-Model for self-adaptive SoS and the control problem.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {distributed control;large-scale systems;self-adjusting systems;software architecture;telecommunication control;self-adaptive information system;information system;distributed complex system;SoS;system of system;informational exchange;Control systems;Real time systems;Information systems;Adaptive control;Design engineering;Centralized control;Intelligent robots;Humans;Systems engineering and theory;Control design;Adaptive control;self-adaptive systems;cooperative systems;real time systems},
}

@InProceedings{Itmi2011,
  author    = {Itmi, M. and Cardon, A.},
  booktitle = {Proceedings of the 2011 Grand Challenges on Modeling and Simulation Conference},
  title     = {A Basic Proactive System Model for the Self-Adaptive Systems of Systems Approach},
  year      = {2011},
  address   = {Vista, CA},
  pages     = {1–5},
  publisher = {Society for Modeling \& Simulation International},
  series    = {GCMS ’11},
  abstract  = {We describe systems basically composed of simply reactive elements in the intention of representing system's proactive components. Then we introduce the basic proactive system notion and unify those proactive components to organize an auto-adaptive meta-system. The proposed approach allows going up from proactive components to a self-adaptive system thanks to the basic proactive systems.},
  file      = {:download_papers/Itmi-2011-A Basic Proactive System Model for the Self-Adaptive.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781617829512},
  keywords  = {reactivity, proactivity, self-adaptive systems, basic proactive system, SoS},
  location  = {Hague, Netherlands},
  numpages  = {5},
}

@InProceedings{Jian-quanOuyang2008,
  author    = {{Jian-quan Ouyang} and {Dian-xi Shi} and {Bo Ding} and {Jin Feng} and {Huai-min Wang}},
  booktitle = {2008 11th IEEE Singapore International Conference on Communication Systems},
  title     = {A framework for self-adaptive scheme in pervasive computing},
  year      = {2008},
  month     = {Nov},
  pages     = {750-755},
  abstract  = {Nowadays, application systems in pervasive computing have to be self-adaptive, which means adapting themselves to dynamic environments. Our aim is to enable systematic development of self-adaptive component-based applications. The paper first introduces a novel policy based framework for self-adaptive scheme in pervasive computing. Then the proposed policy ontology and policy language are well expressive and easily extensible to support the design of policy which is based on the Separation of Concerns principle. Furthermore, the context-driven event channel decouples the communication between the suppliers and consumers for asynchronous communication.},
  doi       = {10.1109/ICCS.2008.4737285},
  file      = {:download_papers/Ouyang-2008-A framework for self-adaptive scheme in pervasive computing.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {ontologies (artificial intelligence);ubiquitous computing;pervasive computing;self-adaptive component-based applications;policy ontology;policy language;context-driven event channel;asynchronous communication;Pervasive computing;Ontologies;Computer architecture;Military computing;Application software;Middleware;Context-aware services;Logic programming;Educational institutions;Context;Policy ontology;self-adaptive;policy language;pervasive computing},
}

@InProceedings{Jiuxin2008,
  author    = {C. {Jiuxin} and M. {Bo} and L. {Junzhou}},
  booktitle = {2008 International Conference on Computer Science and Software Engineering},
  title     = {The Self-Adaptive Framework of Learning Object Based on Context},
  year      = {2008},
  month     = {Dec},
  pages     = {941-944},
  volume    = {5},
  abstract  = {U-learning is coming to us. However, it is impossible for the learning object designed for traditional e-learning to be viewed appropriately without modification. In this paper, based on the existing research, a self-adaptive learning object framework is proposed for u-learning. This framework supplies different version of learning object to users according to their learning context which related to access device, network condition, and personal information. We design five versions for the learning object, original, HTML, Simple-HTML, WML, Simple-WML, which are corresponding to different learning context. Meanwhile, a self-adaptive learning object generation method is given based on the metadata K-node, and the conversion between versions of learning object is discussed.},
  doi       = {10.1109/CSSE.2008.153},
  file      = {:download_papers/Cao-2008-The Self-Adaptive Framework of Learning Object Based on Context.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {computer aided instruction;ubiquitous computing;self-adaptive learning object framework;u-learning context;simple-HTML;metadata K-node;access device;network condition;personal information;simple wireless markup language;Electronic learning;Computer science;Laboratories;Computer networks;Courseware;Cellular phones;Software engineering;Information security;Computer science education;HTML;U-learning;Self-adaptive learning object;Learning context},
}

@Article{Karsai1999,
  author        = {G. {Karsai} and J. {Sztipanovits}},
  journal       = {IEEE Intelligent Systems and their Applications},
  title         = {A model-based approach to self-adaptive software},
  year          = {1999},
  issn          = {2374-9423},
  month         = {May},
  note          = {cited By 37},
  number        = {3},
  pages         = {46-53},
  volume        = {14},
  abstract      = {The authors' model based approach to self adaptive software systems uses domain specific models and components to restore flexibility and adaptability to software systems running in dynamic environments. The model-integrated approach to self adaptive software, decomposes the problem into two major issues: the issues of representation and that of the reconfiguration mechanism. The goal of the work is to facilitate a performance/spl rarr/evolution/spl rarr/architecture modification/spl rarr/modified performance cycle in which the application's performance is continuously monitored, with the results used to modify the architectural model. The modification is then followed by a partial or complete regeneration of the executable system. We have implemented and tested some aspects of our approach in applications; other aspects are part of our ongoing investigation in various research projects.},
  document_type = {Article},
  doi           = {10.1109/5254.769884},
  file          = {:download_papers/Karsai-1999-A model-based approach to self-adaptive software.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {adaptive systems;software fault tolerance;software architecture;self-adaptive software;model based approach;self adaptive software systems;domain specific models;adaptability;dynamic environments;model-integrated approach;reconfiguration mechanism;architecture modification;modified performance cycle;application performance monitoring;architectural model;executable system;research projects;Software systems;Information systems;Computer architecture;Real time systems;Embedded software;Process design;System testing;Costs;Impedance;Modems},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0032627874&doi=10.1109%2f5254.769884&partnerID=40&md5=08f30355c0cd556a57694cad9e10e0b1},
}

@InProceedings{Kebir2012,
  author        = {S. {Kebir}},
  booktitle     = {2012 6th International Conference on Sciences of Electronics, Technologies of Information and Telecommunications (SETIT)},
  title         = {JACAC: An aspect oriented framework for the development of self-adaptive software systems},
  year          = {2012},
  month         = {March},
  note          = {cited By 0},
  pages         = {74-80},
  abstract      = {Current software systems are increasingly difficult to maintain and adapt to new needs. The Autonomic Computing aims to provide solutions to this problem by allowing systems to self-adapt their self. Software components greatly increase the degree of reuse and ease of development. Aspect oriented programming provides a separation between business concerns and crosscutting concerns. In this paper we propose a combined approach called JACAC based on aspects and components to enable autonomic capabilities in legacy systems.},
  art_number    = {6481893},
  document_type = {Conference Paper},
  doi           = {10.1109/SETIT.2012.6481893},
  file          = {:download_papers/Kebir-2012-JACAC An aspect oriented framework for the development.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {2012 6th International Conference on Sciences of Electronics, Technologies of Information and Telecommunications, SETIT 2012},
  keywords      = {aspect-oriented programming;fault tolerant computing;software maintenance;JACAC;aspect oriented framework;self-adaptive software system development;autonomic computing;software components;aspect oriented programming;business concerns;crosscutting concerns;autonomic capabilities;legacy systems;Weaving;Indexes;Software systems;Monitoring;Runtime;Aging;Adaptation models},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84875695333&doi=10.1109%2fSETIT.2012.6481893&partnerID=40&md5=e5c48f1cced028f4369c562cc232da7f},
}

@Conference{Kim2005a,
  author        = {Kim, D. and Kim, J. and Park, S.},
  title         = {A framework for self-adaptive software},
  year          = {2005},
  note          = {cited By 0},
  pages         = {793},
  abstract      = {The major goal of self-adaptive software is to provide a mechanism that allows a software system to dynamically change its architectural configuration during runtime to cope with requirement changes and unexpected conditions. There are three main capabilities that are necessary to support self-adaptive software for robots: Recognition of environment, Decision making & learning, Dynamic reconfiguration. we describe a software framework to support such capabilities to realize self-adaptive software for intelligent robots.},
  document_type = {Conference Paper},
  file          = {:download_papers/Kim-2005-A framework for self-adaptive software.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {17th International Conference on Software Engineering and Knowledge Engineering, SEKE 2005},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84886871499&partnerID=40&md5=15181b3f7be9f2c16c3857a21921943d},
}

@Conference{Kim2008,
  author        = {Kim, D. and Park, S.},
  title         = {Software architecture-based approach to self-adaptive function for intelligent robots},
  year          = {2008},
  note          = {cited By 0},
  number        = {1 PART 1},
  volume        = {17},
  abstract      = {An intelligent service robot helps human users with providing various services such as bringing a newspaper, recommending TV programs, and preparing meals. Each service can be accomplished by coordinating various motion actuations that are activated based on sensory data. Due to the limitation of robot computingresources such as CPU time and memory, the software components that implement such motion actuations can not be loaded and executed at the same time as the complexity of the service increases. That is, those components may compete with each other for the limited computing-resources, and this may result an unexpected behavior of the robot. In this paper, we propose a software architecture-based approach for self-adaptive function that optimizes the use of computing resources by supporting dynamic re-deployment of software components. Organizations of motion actuations for providing services are modeled by software architecture that describes required components and their configurations. In our approach, when a resource problem is detected, components are re-deployed across single-board computers (SBCs) in the robot while maintaining the functional and quality requirements of the components and configuration among them represented in the software architecture. We designed the self-adaptive software framework and implemented a prototype of it. We also had an experiment of our approach on an infotainment robot, and successfully proved the effectiveness of the architecture-based self-adaptive function. Copyright © 2007 International Federation of Automatic Control All Rights Reserved.},
  document_type = {Conference Paper},
  doi           = {10.3182/20080706-5-KR-1001.4216},
  file          = {:download_papers/Kim-2008-Software architecture-based approach to self-adaptive.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {IFAC Proceedings Volumes (IFAC-PapersOnline)},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-79961018590&doi=10.3182%2f20080706-5-KR-1001.4216&partnerID=40&md5=89b9037e45c4d0e0a62e89e6d916cfad},
}

@InProceedings{Kit2015a,
  author        = {M. {Kit} and I. {Gerostathopoulos} and T. {Bures} and P. {Hnetynka} and F. {Plasil}},
  booktitle     = {2015 IEEE/ACM 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title         = {An Architecture Framework for Experimentations with Self-Adaptive Cyber-physical Systems},
  year          = {2015},
  month         = {May},
  note          = {cited By 17},
  pages         = {93-96},
  abstract      = {Recent advances in embedded devices capabilities and wireless networks paved the way for creating ubiquitous Cyber-Physical Systems (CPS) grafted with self-configuring and self-adaptive capabilities. As these systems need to strike a balance between dependability, open-endedness and adaptability, and operate in dynamic and opportunistic environments, their design and development is particularly challenging. We take an architecture-based approach to this problem and advocate the use of component-based abstractions and related machinery to engineer self-adaptive CPS. Our approach is structured around DEECo -- a component framework that introduces the concept of component ensembles to deal with the dynamicity of CPS at the middleware level. DEECo provides the architecture abstractions of autonomous components and component ensembles on top of which different adaptation techniques can be deployed. This makes DEECo a vehicle for seamless experiments with self-adaptive systems where the physical distribution and mobility of nodes, and the limited data availability play an important role.},
  art_number    = {7194662},
  document_type = {Conference Paper},
  doi           = {10.1109/SEAMS.2015.28},
  file          = {:download_papers/Kit-2015-An Architecture Framework for Experimentations with Self-Adaptive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2157-2321},
  journal       = {Proceedings - 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2015},
  keywords      = {middleware;object-oriented programming;software architecture;self-adaptive cyber-physical system;self-configuring;dependability;open endedness;adaptability;dynamic environments;opportunistic environments;architecture-based approach;component-based abstraction;DEECo;CPS;middleware;architecture abstractions;autonomous components;component ensembles;Vehicles;Computers;Software engineering;Adaptive systems;Indexes;Knowledge engineering;Vehicle dynamics;framework;self-adaptation;cyber-physical systems},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84953218659&doi=10.1109%2fSEAMS.2015.28&partnerID=40&md5=413c60f26d422f5eefa1d03d5d6e9200},
}

@InProceedings{Kl?s2015,
  author    = {V. {Kl?s} and T. {G?thel} and S. {Glesner}},
  booktitle = {2015 41st Euromicro Conference on Software Engineering and Advanced Applications},
  title     = {Adaptive Knowledge Bases in Self-Adaptive System Design},
  year      = {2015},
  month     = {Aug},
  pages     = {472-478},
  abstract  = {Self-adaptive systems allow for flexible solutions in changing environments. Usually, a fixed set of predefined rules is used to define the adaptation possibilities of a system. The main problem of such systems is to cope with environment behaviours that were not anticipated at design-time. In this case, no adaptation rule might be applicable or adaptations might not have the expected effect. In this paper, we propose an extended architecture of IBM's MAPE-K loop to cope with this problem. We impose a structure on the knowledge base consisting of an abstract system and environment model, a global goal model, and a set of (current) adaptation rules. Furthermore, we introduce an evaluation component that deletes failed adaptation rules, as well as a learning component that uses run-time models to autonomously generate new rules if the current ones are not applicable. With our approach, not only functional components can dynamically be adapted but also the adaptation logic itself.},
  doi       = {10.1109/SEAA.2015.48},
  file      = {:download_papers/Kloes-2015-Adaptive Knowledge Bases in Self-Adaptive System Design.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2376-9505},
  keywords  = {knowledge based systems;learning (artificial intelligence);adaptive knowledge base;self-adaptive system design;IBM MAPE-K loop;abstract system;environment model;global goal model;adaptation rules;evaluation component;learning component;adaptation logic;Adaptation models;Adaptive systems;Knowledge based systems;Analytical models;Topology;Data models;Temperature sensors;self-adaptive systems;modelling;feedback loop;knowledge base;adaptation rules;run-time models},
}

@InProceedings{Klarl2015,
  author    = {A. {Klarl}},
  booktitle = {2015 IEEE 24th International Conference on Enabling Technologies: Infrastructure for Collaborative Enterprises},
  title     = {Engineering Self-Adaptive Systems with the Role-Based Architecture of Helena},
  year      = {2015},
  month     = {June},
  pages     = {3-8},
  abstract  = {When engineering self-adaptive systems, separating adaptation and application logic was proven beneficial to avoid interdependencies between adaptation strategy and standard behaviour. Several engineering methods support this separation in different phases of the classical development process, but none addresses it consistently in all of them. We propose a holistic model-driven engineering process with systematic transitions between all phases to develop self-adaptive systems. Adaptation is achieved by changing the behavioral mode of a component in response to perceptions. We realize behavioral modes by roles which a component can dynamically adopt. For specification, we propose adaptation automata which allow to specify complex adaptation behaviour by hierarchical structure and history of states. Furthermore, we propose the HELENA Adaptation Manager pattern to derive a role-based model from a specification. Due to its formal foundation, the model can be analyzed with Spin and executed with the Java framework jHelena.},
  doi       = {10.1109/WETICE.2015.32},
  file      = {:download_papers/Klarl-2015-Engineering Self-Adaptive Systems with the Role-Based Architecture.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1524-4547},
  keywords  = {formal specification;software architecture;Spin;Java framework;HELENA Adaptation Manager;adaptation behaviour specification;hierarchical structure;adaptation automata;holistic model-driven engineering process;adaptation strategy;application logic;adaptation logic;HELENA architecture;role-based architecture;self-adaptive systems engineering;Automata;Adaptation models;Robot sensing systems;Switches;History;Batteries;self-adaptation;engineering;ensemble-based systems;roles;autonomic manager},
}

@InProceedings{Krikava2014,
  author        = {K\v{r}ikava, Filip and Collet, Philippe and France, Robert B.},
  booktitle     = {Proceedings of the 29th Annual ACM Symposium on Applied Computing},
  title         = {ACTRESS: Domain-Specific Modeling of Self-Adaptive Software Architectures},
  year          = {2014},
  address       = {New York, NY, USA},
  note          = {cited By 17},
  pages         = {391–398},
  publisher     = {Association for Computing Machinery},
  series        = {SAC ’14},
  abstract      = {A common approach for engineering self-adaptive software systems is to use Feedback Control Loops (FCLs). Advances have led to more explicit and safer design of some control architectures, however, there is a need for more integrated and systematic approaches that support end-to-end integration of FCLs into software systems. In this paper, we propose a tooled approach that enables researchers and engineers to design and integrate adaptation mechanisms into software systems through FCLs. It consists of a domain-specific modeling language that raises the level of abstraction on which FCLs are defined, making them amenable to automated analysis and implementation code synthesis. The language supports composition, distribution and reflection, thereby enabling coordination and composition of multiple distributed FCLs. Its use is facilitated by a modeling environment, ACTRESS, that provides support for modeling, verification and complete code generation. We report on its application to a concrete adaptation case study and also discuss resulting properties. Copyright 2014 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/2554850.2555020},
  file          = {:download_papers/Krikava-2014-ACTRESS domain-specific modeling of self-adaptive software.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450324694},
  journal       = {Proceedings of the ACM Symposium on Applied Computing},
  keywords      = {model-driven engineering, domain-specific languages, domain-specific modeling, self-adaptive software systems},
  location      = {Gyeongju, Republic of Korea},
  numpages      = {8},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2554850.2555020},
}

@InProceedings{Krupitzer2018,
  author    = {C. {Krupitzer} and G. {Drechsel} and D. {Mateja} and A. {Pollkl?sener} and F. {Schrage} and T. {Sturm} and A. {Tomasovic} and C. {Becker}},
  booktitle = {2018 IEEE International Conference on Pervasive Computing and Communications Workshops (PerCom Workshops)},
  title     = {Using Spreadsheet-defined Rules for Reasoning in Self-Adaptive Systems},
  year      = {2018},
  month     = {March},
  pages     = {289-294},
  abstract  = {Using rules to capture adaptation knowledge is a common approach for self-adaptive systems. Rule-based reasoning, i.e., using rules to analyze and plan adaptations, has several advantages: (i) it is easy to implement, (ii) it offers fast reasoning, and (iii) it works on resource-spare systems as historical knowledge is not required. Hence, the needed computational power is low and it perfectly suits systems in the pervasive IoT domain. However, the codification of rules poses a challenge to the system design. Existing approaches often require a specific syntax or programming language. Additionally, some approaches force the developer to customize the reasoning mechanism, hence, to reimplement parts of the reasoning. To address these shortcomings, we propose a reusable approach for rule-based reasoning in this paper. Rules can be defined in a spreadsheet without the need to neither learn a syntax nor implement a single line of code. We evaluate the benefits of our approach in two case studies conducted by Master students as well as a quantitative evaluation.},
  doi       = {10.1109/PERCOMW.2018.8480283},
  file      = {:download_papers/Krupitzer-2018-Using Spreadsheet-defined Rules for Reasoning in Self-Adaptive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {case-based reasoning;computer science education;inference mechanisms;Internet of Things;reverse engineering;software engineering;spreadsheet programs;spreadsheet-defined rules;self-adaptive systems;adaptation knowledge;rule-based reasoning;fast reasoning;resource-spare systems;historical knowledge;system design;reasoning mechanism;reusable approach;master students;programming language;Cognition;Engines;Adaptation models;Monitoring;Syntactics;Context modeling;Business},
}

@Conference{Kubat2018,
  author        = {Kubát, P. and Bulej, L. and Bureš, T. and Horký, V. and Tůma, P.},
  title         = {Adaptive dispatch: A pattern for performance-aware software self-adaptation},
  year          = {2018},
  note          = {cited By 0},
  pages         = {195-198},
  volume        = {2018-January},
  abstract      = {Modern software systems often employ dynamic adaptation to runtime conditions in some parts of their functionality ś well known examples range from autotuning of computing kernels through adaptive battery saving strategies of mobile applications to dynamic load balancing and failover functionality in computing clouds. Typically, the implementation of these features is problem-specific ś a particular autotuner, a particular load balancer, and so on ś and enjoys little support from the implementation environment beyond standard programming constructs. In this work, we propose Adaptive Dispatch as a generic coding pattern for implementing dynamic adaptation. We believe that such pattern can make the implementation of dynamic adaptation features better in multiple aspects ś an explicit adaptation construct makes the presence of adaptation easily visible to programmers, lends itself to manipulation with development tools, and facilitates coordination of adaptation behavior at runtime. We present an implementation of the Adaptive Dispatch pattern as an internal DSL in Scala. © 2018 Association for Computing Machinery.},
  document_type = {Conference Paper},
  doi           = {10.1145/3185768.3186406},
  file          = {:download_papers/Kubat-2019-Adaptive Dispatch A Pattern for Performance-Aware Software.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {ICPE 2018 - Companion of the 2018 ACM/SPEC International Conference on Performance Engineering},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85051840975&doi=10.1145%2f3185768.3186406&partnerID=40&md5=338568acf3893112339602f4deb25a38},
}

@Article{Laddaga1999a,
  author        = {Laddaga, Robert},
  journal       = {IEEE Intelligent Systems and Their Applications},
  title         = {Creating robust software through self-adaptation},
  year          = {1999},
  issn          = {2374-9423},
  month         = {May},
  note          = {cited By 43},
  number        = {3},
  pages         = {26-29},
  volume        = {14},
  abstract      = {The self-adaptive software is a new method developed for improving efficiency and predictability. The goal of this method is the creation of technology to enable programs to understand, monitor, and modify themselves. With its significant features, self-adaptive software will identify, promote, and evaluate new models of code design and run-time support.},
  document_type = {Article},
  doi           = {10.1109/MIS.1999.769879},
  file          = {:download_papers/Laddaga-1999-Creating robust software through self-adaptation.pdf:PDF},
  groups        = {scopus, wiley, systematic_search},
  keywords      = {Robustness;Software performance;Runtime;Software testing;Control systems;Communication system control;Software tools;Hardware;Shape control;Application software},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0032625886&partnerID=40&md5=80b7ab3559a14e3fe71f2d796c29489a},
}

@InProceedings{Leal2019,
  author    = {L. {Leal} and A. {Ceccarelli} and E. {Martins}},
  booktitle = {2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC)},
  title     = {The SAMBA Approach for Self-Adaptive Model-Based Online Testing of Services Orchestrations},
  year      = {2019},
  month     = {Jul},
  pages     = {495-500},
  volume    = {1},
  abstract  = {Service Oriented Architecture (SOA) is a popular design pattern that allows building applications composed of loosely-coupled and autonomous services. Such services may evolve and change at runtime, often outside the control of the owner of the application. Consequently, typical validation approaches, like offline testing performed before services deployment, are necessary but not sufficient: offline testing cannot assure the correct behavior of the SOA during its execution. To cope with the evolution of services and their orchestrations, in this paper we present a Self-Adaptive Model-BAsed online testing framework called SAMBA. SAMBA aims to assess the proper behavior of a SOA during its lifecycle executing model-based online testing at runtime, under the coordination of a MAPE-K control loop. SAMBA is assessed in a case study, where its detection capability are proved through functional, mutation and fault injection tests.},
  doi       = {10.1109/COMPSAC.2019.00076},
  file      = {:download_papers/Leal-2019-The SAMBA Approach for Self-Adaptive Model-Based Online Testing.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {object-oriented methods;object-oriented programming;program testing;service-oriented architecture;SAMBA approach;services orchestrations;SOA;Self-Adaptive Model-BAsed online testing framework;design pattern;service oriented architecture;MAPE-K control loop;Testing;Service-oriented architecture;Monitoring;Runtime;Business;Servers;Generators;self-adaptive;Service Oriented Architecture;model-based testing;online testing},
}

@InProceedings{Lee2015,
  author    = {K. {Lee} and S. {Lee}},
  booktitle = {2015 IEEE 39th Annual Computer Software and Applications Conference},
  title     = {Applying Game Theoretic Approach to Goal-Driven Requirements Trade-Off Analysis for Self-Adaptation},
  year      = {2015},
  month     = {July},
  pages     = {330-335},
  volume    = {3},
  abstract  = {A self-adaptive software aims at adjusting itself in response to changes at runtime while considering several important factors. To do this task, such a system should realize the adaptation process, which consists of four phases. Among those phases, we just focus on the deciding (planning) process, especially addressing adequate reflection of requirements to adaptation. In this paper, we represent the arising requirements trade-off problem in terms of goal oriented requirements engineering while adapting to the changes. In addition we apply a game theoretical approach which gives us an insight into analyzing conflicts among requirements. It could provide self-adaptive software with the rationale behind selecting adaptation behaviors.},
  doi       = {10.1109/COMPSAC.2015.158},
  file      = {:download_papers/Lee-2015-Applying Game Theoretic Approach to Goal-Driven Requirements.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {formal specification;formal verification;game theory;game theoretic approach;goal-driven requirement trade-off analysis;self-adaptive software;goal oriented requirements engineering;Games;Adaptation models;Software;Game theory;Analytical models;Servers;Context;requirements engineering;self-adaptive software;game theory},
}

@Conference{Lee2015a,
  author        = {Lee, H.-C. and Lee, S.-W.},
  title         = {Towards knowledge-intensive software engineering framework for self-adaptive software},
  year          = {2015},
  note          = {cited By 1},
  pages         = {30-35},
  volume        = {2015-January},
  abstract      = {A self-adaptive system reacts to the changing environment by modifying its functionality in relation to the encountered state of the environment. In order to adapt to a new situation, such system goes through many decision points during the adaptation process. Knowledge forms the basis of decision making within the adaptation process. There are already many existing self-adaptive system frameworks. However, these frameworks have limitation in the way they represent the rationale for adaptation and the semantics behind the knowledge they use. This paper takes a step forward by proposing a knowledge-intensive adaptation framework to both manage knowledge and support the analytical decision making process. The proposed approach represents the adaptation knowledge by using ontology which helps to organize, analyze and extend knowledge. Ontology is able to represent the semantics behind knowledge and provide the evidence for the adaptation. The proposed approach uses a special ontology named the Adaptation Problem Domain Ontology. It specifies the system goals, features, architectures, and the relationship between them. This ontology is used to answer the problem of adaptation at each decision point and determine the appropriate system structure by reasoning the semantics behind knowledge. Thus, the system can consider the semantics behind knowledge for adaptation, and then the stakeholders can understand the adaptation process. We apply the proposed framework to the smart grid domain and show how the system adapts to a new situation using rationale for adaptation and the semantics behind the knowledge. Copyright © 2015 by KSI Research Inc. and Knowledge Systems Institute Graduate School.},
  document_type = {Conference Paper},
  doi           = {10.18293/SEKE2015-222},
  file          = {:download_papers/Lee-2015-Towards knowledge-intensive software engineering framework.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84969792960&doi=10.18293%2fSEKE2015-222&partnerID=40&md5=47b61ab9ecb123b11508243477586e98},
}

@InProceedings{Lee2018,
  author    = {E. {Lee} and Y. {Kim} and Y. {Seo} and D. {Baik}},
  booktitle = {TENCON 2018 - 2018 IEEE Region 10 Conference},
  title     = {Self-Adaptive Framework with Game Theoretic Decision Making for Internet of Things},
  year      = {2018},
  month     = {Oct},
  pages     = {2092-2097},
  abstract  = {The Internet of Things (IoT) connects several objects within environments that dynamically change, and so requirements may be added and changed at runtime. Therefore, requirements may be satisfied at dynamic change. Self-adaptive software can alter their behavior to satisfy requirements in dynamic environments. In this perspective, the concept of self-adaptive software is suitable for IoT environments. In this study, a self-adaptive framework is proposed for decision making in IoT environments at runtime. The framework includes finite-state machine model designs and game theoretic decision-making methods to extract efficient strategies. The framework is implemented as a prototype, and experiments are performed to evaluate runtime performance. The results demonstrate that the proposed framework can be applied to IoT environments at runtime.},
  doi       = {10.1109/TENCON.2018.8650165},
  file      = {:download_papers/Lee-2018-Self-Adaptive Framework with Game Theoretic Decision Making.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2159-3450},
  keywords  = {decision making;finite state machines;game theory;Internet of Things;self-adaptive framework;self-adaptive software;dynamic environments;IoT environments;finite-state machine model designs;game theoretic decision-making;Internet of Things;Software;Adaptation models;Runtime;Nash equilibrium;Mathematical model;Monitoring;Games;Self-adaptive software;Game theory;Finite-state machine;Nash equilibrium;Internet of Things},
}

@InProceedings{Lei2015,
  author        = {Y. {Lei} and K. {Ben} and Z. {He}},
  booktitle     = {2015 7th International Conference on Intelligent Human-Machine Systems and Cybernetics},
  title         = {A Framework for Self-Adaptive Software Based on Extended Tropos Goal Model},
  year          = {2015},
  month         = {Aug},
  note          = {cited By 4},
  pages         = {533-536},
  volume        = {2},
  abstract      = {Software variation modeling is essential to the requirements modeling of self-adaptive software. However, traditional Tropos goal model cannot specify the software variations. In order to address this problem, we incorporate the context conditions and internal event conditions into the Tropos goal model. For the problem that adaption strategies are difficult to modify when adaptive software is compiled, we propose a framework for adaptive software based on the extended Tropos goal model. The adaption logic layer of the framework has a double control loop, which takes the goal model as a reference. The dual control loop is responsible for monitoring the running status and context variations of the business logic layer, and adapting to variations according to the goal model. Such a loose coupling of adaption logic and business logic facilitates the modification of adaption strategies. We also design several adaption algorithms relative to the framework to control and cope with the internal events and context variations.},
  art_number    = {7335029},
  document_type = {Conference Paper},
  doi           = {10.1109/IHMSC.2015.65},
  file          = {:download_papers/Lei-2015-A Framework for Self-Adaptive Software Based on Extended Tropos.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2015 7th International Conference on Intelligent Human-Machine Systems and Cybernetics, IHMSC 2015},
  keywords      = {formal specification;formal verification;software variation modeling;requirements modeling;self-adaptive software;extended Tropos goal model;adaption logic layer;double control loop;running status monitoring;context variations;business logic layer;internal events;context variations;Software;Context;Adaptation models;Fires;Context modeling;Unified modeling language;Object oriented modeling;goal model;self-adaptive software;goal oriented requirements engineering},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84954442083&doi=10.1109%2fIHMSC.2015.65&partnerID=40&md5=cdd66a0710347a61786aebc5a6b0952e},
}

@InProceedings{Li2017,
  author    = {Y. {Li} and Q. {Li} and L. {Wang} and W. {Cheng} and T. {Wu}},
  booktitle = {2017 IEEE Conference on Open Systems (ICOS)},
  title     = {ADAPT: An agent-based development toolkit and operation platform for self-adaptive systems},
  year      = {2017},
  month     = {Nov},
  pages     = {53-58},
  abstract  = {Self-adaptive software (SAS) needs to handle complex software changes at runtime which are multiple, interrelated and unpredictable. However, existing specialized toolkits or platforms for SAS cannot fully assist the software in handling the changes with all the characteristics mentioned above at the same time. Therefore, based on the theories on MultiAgent Systems (MASs) and Search-based Software Engineering (SBSE), this paper proposes a reference architecture of SAS to handle the changes, and provides an Agent-based. Development toolkit and operAtion PlaTform for self-adaptive systems, called ADAPT, to support the development and operation of SAS according to the reference architecture. ADAPT can effectively handle complex changes with Agent technology and search-based planning method. It can also achieve automation in a way to reduce the burden of developers. Moreover, it provides adaptive abilities to SAS from the design time to runtime, reflecting the used methods in the whole process of software engineering.},
  doi       = {10.1109/ICOS.2017.8280274},
  file      = {:download_papers/Li-2017-ADAPT An agent-based development toolkit and operation platform.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2473-3660},
  keywords  = {adaptive systems;multi-agent systems;software agents;software engineering;software engineering;development toolkit;operation platform;self-adaptive systems;self-adaptive software;specialized toolkits;reference architecture;software changes;multiagent systems;ADAPT platform;Conferences;Open systems;Erbium;Self-adaptive systems;Multi-agent systems;development toolkit;operation platform},
}

@InProceedings{Lin2007,
  author    = {X. {Lin} and H. {Wu} and D. {Jiang} and F. {Ren}},
  booktitle = {2007 Australasian Telecommunication Networks and Applications Conference},
  title     = {A self-adaptive architecture to control the performance of multi-host web servers},
  year      = {2007},
  month     = {Dec},
  pages     = {75-80},
  abstract  = {In modern web applications, several web sites often inhabit one single web server, asking for some software mechanisms to allocate server resources among those virtual hosts. This paper tries to study this issue from the perspective of control theory. First, solid proofs are shown to demonstrate that web servers could hardly be modeled with fixed parameters, which cast doubt on foundations of existing parametric web QoS schemes. Furthermore, we present the self-adaptive architecture for web servers, whose objective is to perform finer control over the performance while suiting varying run-time conditions of web servers. A series of tests validate the efficiency of our strategy, showing that comparing with QoS schemes based on fixed parameters, self-adaptive architecture tracks demanding request latency more closely, even when run-time environments change dramatically. In addition, our architecture requires no superfluous off-line identification of system parameters. We also point out that the self-adaptive architecture for web servers could be implemented with other various QoS facilities.},
  doi       = {10.1109/ATNAC.2007.4665265},
  file      = {:download_papers/Lin-2007-A self-adaptive architecture to control the performance of multi-host.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive control;file servers;Internet;quality of service;telecommunication congestion control;self-adaptive architecture;multihost web servers;modern web applications;software mechanisms;server resource allocation;virtual hosts;control theory;parametric web QoS schemes;off-line no identification;Service oriented architecture;Web server;Runtime;Computer architecture;Application software;Resource management;Control theory;Solid modeling;Automatic testing;Delay},
}

@InProceedings{Liu2012,
  author        = {C. {Liu} and W. {Zhang} and H. {Zhao} and Z. {Jin}},
  booktitle     = {2012 19th Asia-Pacific Software Engineering Conference},
  title         = {A Problem Oriented Approach to Modeling Feedback Loops for Self-Adaptive Software Systems},
  year          = {2012},
  month         = {Dec},
  note          = {cited By 4},
  pages         = {440-445},
  volume        = {1},
  abstract      = {Self-adaptive software systems can adjust their behaviors at runtime to respond to the context changes. To operationalize the adaptive mechanism, feedback loops have been advocated in many works. However, most of existing works focus on the architecture design to realize the feedback loops. How to model the required feedback loops remains an issue. In this paper, we propose a problem oriented approach for this issue. This approach models the system composed by the self-adaptive software and its context as an adaptive control system which is equipped with two kinds of feedback loops: context-aware feedback loops and requirements-aware feedback loops. To model the feedback loops, we identify five classes of software problems to address the different concerns of the adaptive requirements behind the feedback loops. We illustrate our idea by applying it to a cruise control system.},
  art_number    = {6462692},
  document_type = {Conference Paper},
  doi           = {10.1109/APSEC.2012.77},
  file          = {:download_papers/Liu-2012-A Problem Oriented Approach to Modeling Feedback Loops.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1530-1362},
  journal       = {Proceedings - Asia-Pacific Software Engineering Conference, APSEC},
  keywords      = {adaptive control;software architecture;systems analysis;ubiquitous computing;problem oriented approach;feedback loop modeling;self-adaptive software system;adaptive mechanism;architecture design;adaptive control system;context-aware feedback loop;requirements-aware feedback loop;adaptive requirement;cruise control system;Context;Vehicles;Monitoring;Feedback loop;Software;Control systems;Adaptation models;self-adaptive software;software requirements;feedback loop;context-aware;requirements-aware},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84874590074&doi=10.1109%2fAPSEC.2012.77&partnerID=40&md5=1e5071f077451123ea279612ac170d45},
}

@InProceedings{Lorenzoli2007,
  author    = {Lorenzoli, Davide and Tosi, Davide and Venticinque, Salvatore and Micillo, Rosa Anna},
  booktitle = {Fourth International Workshop on Software Quality Assurance: In Conjunction with the 6th ESEC/FSE Joint Meeting},
  title     = {Designing Multi-Layers Self-Adaptive Complex Applications},
  year      = {2007},
  address   = {New York, NY, USA},
  pages     = {70–77},
  publisher = {Association for Computing Machinery},
  series    = {SOQUA ’07},
  abstract  = {The impossibility of statically determining the behavior of complex systems that interact at runtime with heterogeneous devices and remote entities, may lead to unexpected system failures and performance degradation. Recently, self-adaptive applications have been recognized as viable solutions for dealing with systems where size and complexity increase beyond the ability of humans. However, self-adaptive solutions have been always studied in isolation, only involving single layers of the system (e.g. operative system, middleware, firmware, hardware). In this paper we discuss our novel idea of multi-layers deep adaptability of complex systems. We present an integrated approach for designing and coordinating applications with three-layers of self-adaptation. The solution proposed is based on specialized sense-plan-act control loops that interact each others to monitor both specific parts and also the global behavior of the system. These control loops sense unexpected behaviors that can compromise the system, then diagnose the system layer that needs an adaptation action, and finally act the proper adaptation strategy to overcome the revealed problems without user intervention. We validate the approach with a SOA-based application, the Virtual Tour Guide, designed with three-layers self-adaptive abilities in order to overcome functional/non-functional problems that can derive from the integration of heterogeneous and remote third-party services.},
  doi       = {10.1145/1295074.1295088},
  file      = {:download_papers/Lorenzoli-2007-Designing Multi-Layers Self-Adaptive Complex Applications.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781595937247},
  keywords  = {mobile devices, distributed systems, self-adaptive systems, service-oriented applications, context awareness},
  location  = {Dubrovnik, Croatia},
  numpages  = {8},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1295074.1295088},
}

@InProceedings{Mann2018b,
  author        = {Z. ��. {Mann} and A. {Metzger}},
  booktitle     = {2018 IEEE International Conference on Autonomic Computing (ICAC)},
  title         = {Auto-Adjusting Self-Adaptive Software Systems},
  year          = {2018},
  month         = {Sep.},
  note          = {cited By 3},
  pages         = {181-186},
  abstract      = {Self-adaptive systems can cope with changes in their operating environment by modifying their structure and behavior at run time. Different kinds of changes pose different requirements on how the software should adapt: some changes may require an immediate adaptation, whereas others do not, leaving more time to find the most suitable action. To address different kinds of changes, we introduce auto-adjustment, which works by quickly assessing changes in terms of the resulting requirements on the adaptation logic (e.g., their criticality or urgency), and adjusting the adaptation logic accordingly. Thereby, auto-adjustment allows dynamically considering the trade-off between adaptation speed and adaptation quality. Experiments with an autonomic cloud resource allocation system show that auto-adjustment leads to an improved trade-off between conflicting system goals: by allowing 0.3% higher energy consumption, the number of server overloads can be reduced by 68%.},
  art_number    = {8498141},
  document_type = {Conference Paper},
  doi           = {10.1109/ICAC.2018.00030},
  file          = {:download_papers/Mann-2018-Auto-Adjusting Self-Adaptive Software Systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2474-0756},
  journal       = {Proceedings - 15th IEEE International Conference on Autonomic Computing, ICAC 2018},
  keywords      = {adaptive systems;cloud computing;resource allocation;self-adjusting systems;software fault tolerance;auto-adjusting self-adaptive software systems;operating environment;adaptation logic;adaptation quality;autonomic cloud resource allocation system;adaptation speed;Servers;Monitoring;Software;Switches;Cloud computing;Optimization;Data centers;self-adaptive systems, on line reconfiguration of the adaptation logic, cloud resource management},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85061305591&doi=10.1109%2fICAC.2018.00030&partnerID=40&md5=4a94a1d5567c58f7c06337c272862fbe},
}

@Article{Mao2014,
  author        = {Mao, X. and Dong, M. and Liu, L. and Wang, H.},
  journal       = {Journal of Information Science and Engineering},
  title         = {An Integrated approach to developing self-adaptive software},
  year          = {2014},
  note          = {cited By 4},
  number        = {4},
  pages         = {1071-1085},
  volume        = {30},
  abstract      = {One of the main challenges of developing self-adaptive systems in open environment comes from uncertain self-adaptation requirements due to the unpredictability of environment changes and its co-existence with well-defined self-adaptation requirements in self-adaptive systems. This paper presents an integrated approach that combines offline and on-line self-adaptation together in a unified technical framework to support the development and running of such systems. We consider self-adaptive system as a multi-agent organization and propose a novel dynamic binding self-adaptation mechanism inspired from organization metaphors to specify and analyze self-adaptation. A description language, SADL, is designed to program well-defined self-adaptation logic at design-time and implement off-line self-adaptation. In order to deal with uncertain selfadaptation, a reinforcement learning method is incorporated with the dynamic binding mechanism, which enables software agents to make decisions on self-adaptation at runtime and implement on-line self-adaptation. Our approach provides a unified frame-work to accommodate off-line and on-line approaches and a general-purpose methodology to develop complex self-adaptive systems in a systematic way. A supported platform called SADE+ is developed and a case is studied to illustrate the proposed approach.},
  document_type = {Article},
  file          = {:download_papers/Mao-2014-An Integrated approach to developing self-adaptive software.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84940284935&partnerID=40&md5=780ed4ad736c387c0c2866f24761df33},
}

@InProceedings{Mirandola2019,
  author    = {Mirandola, Raffaela and Riccobene, Elvinia and Scandurra, Patrizia},
  booktitle = {Proceedings of the 13th European Conference on Software Architecture - Volume 2},
  title     = {Self-Accounting in Architecture-Based Self-Adaptation},
  year      = {2019},
  address   = {New York, NY, USA},
  pages     = {14–17},
  publisher = {Association for Computing Machinery},
  series    = {ECSA ’19},
  abstract  = {This paper proposes a work-in-progress approach regarding qualities of the managing layer in architecture-based self-adaptation. In particular, we establish the notion of self-accounting as self-* property and we present an inductive method, based on the structure of the MAPE pattern of the adaptation layer, to evaluate the cost of the adaptation logic in terms of latency time and availability of the managing system. We also show how the MSL (MAPE Specification Language), a language for modeling the adaptation layer in terms of MAPE patterns, has been extended to annotate MAPE components with values for these quality properties, so allowing the computation of the cost function and endowing an adaptation layer with a value for its self-accounting property.},
  doi       = {10.1145/3344948.3344957},
  file      = {:download_papers/Mirandola-2019-Self-accounting in architecture-based self-adaptation.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450371421},
  keywords  = {self-adapting architectures, self-accounting, MAPE patterns},
  location  = {Paris, France},
  numpages  = {4},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3344948.3344957},
}

@InProceedings{Moghaddam2017,
  author        = {Moghaddam, Fahimeh Alizadeh and Deckers, Robert and Procaccianti, Giuseppe and Grosso, Paola and Lago, Patricia},
  booktitle     = {Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings},
  title         = {A Domain Model for Self-Adaptive Software Systems},
  year          = {2017},
  address       = {New York, NY, USA},
  note          = {cited By 0},
  pages         = {16–22},
  publisher     = {Association for Computing Machinery},
  series        = {ECSA ’17},
  volume        = {Part F130530},
  abstract      = {Modern software systems operate in a continuously changing environment. To keep up with these changes, they can benefit from self-Adaptation mechanisms. A number of modeling frameworks have been introduced to realize self-Adaptive software systems. However, they usually focus either on runtime adaptation or on designing self-Adaptability. As a consequence, they do not provide a clear link between architecture-level and system-level concepts. Without this link, we cannot ensure that the realized system will deliver the designed-for self-Adaptability. In this paper, we address this problem by introducing a domain model for self-Adaptive software systems that encompasses both levels. Our model can be used to facilitate both architecture design (e.g. making better-informed design decisions) and system engineering (e.g. guiding self-Adaptation at runtime). We show the application of our model in a case example from the literature where self-Adaptation aims at energy efficiency. © 2017 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/3129790.3129824},
  file          = {:download_papers/Moghaddam-2017-A domain model for self-adaptive software systems.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450352178},
  journal       = {ACM International Conference Proceeding Series},
  keywords      = {self-adaptive software, domain model, software architecture, seamless adaptation},
  location      = {Canterbury, United Kingdom},
  numpages      = {7},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/3129790.3129824},
}

@InProceedings{Moreno2016,
  author    = {G. A. {Moreno} and J. {C��mara} and D. {Garlan} and B. {Schmerl}},
  booktitle = {2016 IEEE International Conference on Autonomic Computing (ICAC)},
  title     = {Efficient Decision-Making under Uncertainty for Proactive Self-Adaptation},
  year      = {2016},
  month     = {July},
  pages     = {147-156},
  abstract  = {Proactive latency-aware adaptation is an approach for self-adaptive systems that improves over reactive adaptation by considering both the current and anticipated adaptation needs of the system, and taking into account the latency of adaptation tactics so that they can be started with the necessary lead time. Making an adaptation decision with these characteristics requires solving an optimization problem to select the adaptation path that maximizes an objective function over a finite look-ahead horizon. Since this is a problem of selecting adaptation actions in the context of the probabilistic behavior of the environment, Markov decision processes (MDP) are a suitable approach. However, given all the possible interactions between the different and possibly concurrent adaptation tactics, the system, and the environment, constructing the MDP is a complex task. Probabilistic model checking can be used to deal with this problem since it takes as input a formal specification of the stochastic system, which is internally translated into an MDP, and solved. One drawback of this solution is that the MDP has to be constructed every time an adaptation decision has to be made to incorporate the latest predictions of the environment behavior. In this paper we present an approach that eliminates that run-time overhead by constructing most of the MDP offline, also using formal specification. At run time, the adaptation decision is made by solving the MDP through stochastic dynamic programming, weaving in the stochastic environment model as the solution is computed. Our experimental results show that this approach reduces the adaptation decision time by an order of magnitude compared to the probabilistic model checking approach, while producing the same results.},
  doi       = {10.1109/ICAC.2016.59},
  file      = {:download_papers/Moreno-2016-Efficient Decision-Making under Uncertainty for Proactive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {decision making;decision theory;dynamic programming;formal specification;formal verification;Markov processes;probability;self-adjusting systems;stochastic programming;uncertainty handling;decision-making;uncertainty;proactive self-adaptation;proactive latency-aware adaptation;self-adaptive systems;reactive adaptation;adaptation tactics latency;adaptation decision;optimization problem;adaptation path;finite look-ahead horizon;probabilistic behavior;Markov decision processes;probabilistic model checking;formal specification;stochastic system;run-time overhead;MDP offline;stochastic dynamic programming;stochastic environment model;Servers;Probabilistic logic;Adaptation models;Stochastic processes;Uncertainty;Quality of service;Computational modeling;latency-aware;proactive;self-adaptation},
}

@InProceedings{Moreno2018a,
  author    = {G. A. {Moreno} and J. {C��mara} and D. {Garlan} and M. {Klein}},
  booktitle = {2018 IEEE/ACM 13th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Uncertainty Reduction in Self-Adaptive Systems},
  year      = {2018},
  month     = {May},
  pages     = {51-57},
  abstract  = {Self-adaptive systems depend on models of themselves and their environment to decide whether and how to adapt, but these models are often affected by uncertainty. While current adaptation decision approaches are able to model and reason about this uncertainty, they do not consider ways to reduce it. This presents an opportunity for improving decision-making in self-adaptive systems, because reducing uncertainty results in a better characterization of the current and future states of the system and the environment (at some cost), which in turn supports making better adaptation decisions. We propose uncertainty reduction as the natural next step in uncertainty management in the field of self-adaptive systems. This requires both an approach to decide when to reduce uncertainty, and a catalog of tactics to reduce different kinds of uncertainty. We present an example of such a decision, examples of uncertainty reduction tactics, and describe how uncertainty reduction requires changes to the different activities in the typical self-adaptation loop.},
  file      = {:download_papers/Moreno-2018-Uncertainty Reduction in Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2305},
  keywords  = {decision making;software fault tolerance;self-adaptive systems;adaptation decisions;uncertainty management;decision-making;uncertainty reduction;Uncertainty;Servers;Computational modeling;Adaptation models;Decision making;Adaptive systems;self adaptive;uncertainty;tactics},
}

@InProceedings{Mousa2018,
  author    = {A. {Mousa} and J. {Bentahar} and O. {Alam}},
  booktitle = {2018 IEEE 6th International Conference on Future Internet of Things and Cloud (FiCloud)},
  title     = {Multi-Objective Self-Adaptive Composite SaaS Using Feature Model},
  year      = {2018},
  month     = {Aug},
  pages     = {77-84},
  abstract  = {Composite services of type SaaS run in dynamic distributed environments where the quality of service (QoS) properties of the constituent services may change during execution. To face such dynamism and volatility, adaptation of composite SaaS to the runtime changes is a vital requirement. Recent research focused on centralized environments which are impractical for dynamic composition that requires distributed settings. To address this challenge, this paper proposes a distributed approach for composite SaaS adaptation using feature selection through applying the master/slave pattern. Slaves locally monitor the distributed constituent services and send performance information to the master, which in its turn reconfigures the composite services to provide the expected QoS and monitors the overall performance. Since adapting a composite SaaS to be QoS-optimal depends on multiple criteria according to the selected features, e.g., performance and cost, we model the adaptation process as a multi-objective optimization problem and then propose a genetic algorithm to compute the Pareto-optimal set of solutions for this problem. Experimental results show that our approach is efficient in distributed and large-scale environments compared to the centralized approach.},
  doi       = {10.1109/FiCloud.2018.00019},
  file      = {:download_papers/Mousa-2018-Multi-Objective Self-Adaptive Composite SaaS Using Feature Model.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {cloud computing;feature selection;genetic algorithms;Pareto optimisation;quality of service;volatility;centralized environments;dynamic composition;distributed settings;feature selection;distributed constituent services;composite services;QoS-optimal;adaptation process;multiobjective optimization problem;large-scale environments;multiobjective self-adaptive composite SaaS;feature model;dynamic distributed environments;quality of service properties;master slave pattern;genetic algorithm;Pareto-optimal set;Software as a service;Quality of service;Adaptation models;Monitoring;Optimization;Computational modeling;Runtime;SaaS;Feature Model;Composite Services;Service Oriented Architecture},
}

@Book{Musil2017,
  author        = {Musil, A. and Musil, J. and Weyns, D. and Bures, T. and Muccini, H. and Sharaf, M.},
  title         = {Patterns for self-adaptation in Cyber-Physical Systems},
  year          = {2017},
  note          = {cited By 12},
  abstract      = {Engineering Cyber-Physical Systems (CPS) is challenging, as these systems have to handle uncertainty and change during operation. A typical approach to deal with uncertainty is enhancing the system with self-adaptation capabilities. However, realizing self-adaptation in CPS, and consequently also in Cyber-Physical Production Systems (CPPS) as a member of the CPS family, is particularly challenging due to the specific characteristics of these systems, including the seamless integration of computational and physical components, the inherent heterogeneity and large-scale of such systems, and their open-endedness. In this chapter we survey CPS studies that apply the promising design strategy of combining different self-adaptation mechanisms across the technology stack of the system. Based on the survey results, we derive recurring adaptation patterns that structure and consolidate design knowledge. The patterns offer problem-solution pairs to engineers for the design of future CPS and CPPS with self-adaptation capabilities. Finally, the chapter outlines the potential of collective intelligence systems for CPPS and their engineering based on the survey results. © Springer International Publishing AG 2017.},
  document_type = {Book Chapter},
  doi           = {10.1007/978-3-319-56345-9_13},
  file          = {:download_papers/Musil-2017-Patterns for self-adaptation in Cyber-Physical Systems.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Multi-Disciplinary Engineering for Cyber-Physical Production Systems: Data Models and Software Solutions for Handling Complex Engineering Projects},
  pages         = {331-368},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85048914233&doi=10.1007%2f978-3-319-56345-9_13&partnerID=40&md5=73d2ac980c9d25c64996879c5e4ff893},
}

@Article{Musliner1999,
  author        = {D. J. {Musliner} and R. P. {Goldman} and M. J. {Pelican} and K. D. {Krebsbach}},
  journal       = {IEEE Intelligent Systems and their Applications},
  title         = {Self-adaptive software for hard real-time environments},
  year          = {1999},
  issn          = {2374-9423},
  month         = {July},
  note          = {cited By 29},
  number        = {4},
  pages         = {23-29},
  volume        = {14},
  abstract      = {Researchers in the Automated Reasoning group at the Honeywell Technology Center and at the University of Michigan are developing adaptive intelligent software for high-risk situations. We are building a system called Self-Adaptive CIRCA (based on our cooperative intelligent real-time control architecture model) that combines the assurance of hard real-time systems with the self-modeling, self-monitoring, and self-modifying capabilities of self-adaptive software. The article describes elements of the system that are working now, as well as new components that we are still in the process of designing and building.},
  document_type = {Article},
  doi           = {10.1109/5254.784081},
  file          = {:download_papers/Musliner-1999-Self-adaptive software for hard real-time environments.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {self-adjusting systems;real-time systems;safety-critical software;self-adaptive software;hard real-time environments;adaptive intelligent software;high-risk situations;Self-Adaptive CIRCA;cooperative intelligent real-time control architecture model;self-modeling;self-monitoring;self-modification;Switches;Large Hadron Collider;Buildings;Logic;Size control;Intelligent systems;Intelligent control;Control systems;Safety;Robots},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0033359948&doi=10.1109%2f5254.784081&partnerID=40&md5=e127dd876fbc28ba93c9228388de14df},
}

@InProceedings{Nakagawa2011,
  author    = {Nakagawa, Hiroyuki and Ohsuga, Akihiko and Honiden, Shinichi},
  booktitle = {Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Gocc: A Configuration Compiler for Self-Adaptive Systems Using Goal-Oriented Requirements Description},
  year      = {2011},
  address   = {New York, NY, USA},
  pages     = {40–49},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’11},
  abstract  = {Self-adaptive systems have recently attracted attention because of their ability to cope with changing environments, including system intrusions or faults. Such software must modify itself to better fit its environment, and one of the approaches by which we expect this capability to be achieved is the introduction of multiple control loops to assess the situation and to determine whether a change in behaviors or configurations is necessary and how to implement the change. Development of such systems with multiple control loops complicates the task of identifying components, and could be greatly aided by appropriate tool support. In this paper, we propose an architectural compiler for self-adaptive systems, which generates architectural configurations from the goal-oriented requirements descriptions. We also present a framework for generating such configurations with this compiler and a pattern in the requirements description. We evaluate the framework experimentally and show that it helps to generate suitable configurations that have high performance, and that the compiler scales well to large input models.},
  doi       = {10.1145/1988008.1988015},
  file      = {:download_papers/Nakagawa-2011-gocc a configuration compiler for self-adaptive systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450305754},
  keywords  = {software architecture, development framework, self-adaptive systems, goal-oriented requirements analysis},
  location  = {Waikiki, Honolulu, HI, USA},
  numpages  = {10},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1988008.1988015},
}

@InProceedings{Nakagawa2012,
  author    = {H. {Nakagawa} and A. {Ohsuga} and S. {Honiden}},
  booktitle = {2012 IEEE Sixth International Conference on Self-Adaptive and Self-Organizing Systems},
  title     = {Towards Dynamic Evolution of Self-Adaptive Systems Based on Dynamic Updating of Control Loops},
  year      = {2012},
  month     = {Sep.},
  pages     = {59-68},
  abstract  = {Self-adaptive systems, which enable runtime adaptation, are promising ways of dealing with environmental changes, including system intrusions or faults. Such software systems must modify themselves to better fit their environment. One of the main approaches to constructing such systems is to introduce multiple control loops. Software evolution is an essential activity for expanding this adaptation capability, and dynamic evolution has been envisaged as a way of systems adapting themselves at runtime. In this paper, we establish a development process to deal with dynamic evolution. We devise a goal model compiler to generate models for designing dynamic evolutions and a programming framework that supports dynamic deployment of control loops. We experimentally applied our approach to a system and discuss how our compiler and framework support dynamic evolution of self-adaptive systems.},
  doi       = {10.1109/SASO.2012.17},
  file      = {:download_papers/Nakagawa-2012-Towards Dynamic Evolution of Self-Adaptive Systems Based on.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1949-3681},
  keywords  = {adaptive systems;formal specification;program compilers;software fault tolerance;software maintenance;dynamic evolution;self-adaptive system;dynamic updating;runtime adaptation;environmental changes;system intrusion;system fault;software system modification;software evolution;adaptation capability;goal model compiler;programming framework;dynamic control loop deployment;goal-oriented requirements modeling;Programming;Batteries;Adaptation models;Cleaning;Robots;Runtime;Program processors;self-adaptation;design;dynamic evolution;control loops;goal-oriented requirements modeling;programming framework},
}

@InProceedings{Nogueira2019,
  author        = {R. {Nogueira} and J. {Reis} and R. {Pinto} and G. {Gon?alves}},
  booktitle     = {2019 24th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA)},
  title         = {Self-adaptive Cobots in Cyber-Physical Production Systems},
  year          = {2019},
  month         = {Sep.},
  note          = {cited By 0},
  pages         = {521-528},
  volume        = {2019-September},
  abstract      = {Absolute automation in certain industries, such as the automotive industry, has proven to be disadvantageous. Robots are fairly capable when performing tasks that are repetitive and demand precision. However, a hybrid solution comprised of the adaptability and resourcefulness of humans cooperating, in the same task, with the precision and efficiency of machines is the next step for automation. Manipulators, however, lack self-adaptability and true collaborative behaviour. And so, through the integration of vision systems, manipulators can perceive their environment and also understand complex interactions. In this paper, a vision-based collaborative proof-of-concept framework is proposed using the Kinect v2, a UR5 robotic manipulator and MATLAB. This framework implements 3 behavioural modes, 1) a Self-Adaptive mode for obstacle detection and avoidance, 2) a Collaborative mode for physical human-robot interaction and 3) a standby Safe mode. These modes are activated with recourse to gestures, by virtue of the body tracking and gesture recognition algorithm of the Kinect v2. Additionally, to allow self-recognition of the robot, the Region Growing segmentation is combined with the UR5's Forward Kinematics for precise, near real-time segmentation. Furthermore, self-adaptive reactive behaviour is implemented by using artificial repulsive action for the manipulator's end-effector. Reaction times were tested for all three modes, being that Collaborative and Safe mode would take up to 5 seconds to accomplish the movement, while Self-Adaptive mode could take up to 10 seconds between reactions.},
  art_number    = {8869165},
  document_type = {Conference Paper},
  doi           = {10.1109/ETFA.2019.8869165},
  file          = {:download_papers/Nogueira-2019-Self-adaptive Cobots in Cyber-Physical Production Systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1946-0759},
  journal       = {IEEE International Conference on Emerging Technologies and Factory Automation, ETFA},
  keywords      = {cyber-physical systems;end effectors;gesture recognition;image segmentation;manufacturing systems;robot vision;adaptive cobots;cyber-physical production systems;absolute automation;automotive industry;demand precision;hybrid solution;collaborative behaviour;vision systems;complex interactions;proof-of-concept framework;Kinect v2;UR5 robotic manipulator;behavioural modes;Self-Adaptive mode;obstacle detection;Collaborative mode;physical human-robot interaction;standby Safe mode;body tracking;gesture recognition algorithm;UR5's Forward Kinematics;self-adaptive reactive behaviour;region growing segmentation;near real-time segmentation;end-effector;time 5.0 s;time 10.0 s;Manipulators;Collaboration;Service robots;Task analysis;Collision avoidance;Cameras;Cobots;Collaborative Robotics;Gesture Control;Industry 4.0;Kinect v2;Obstacle Detection;Potential Fields;Self-adaptive;Universal Robots UR5;Vision-based robot},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85074195193&doi=10.1109%2fETFA.2019.8869165&partnerID=40&md5=5afeda0b29810147455b56753eb0d88b},
}

@InProceedings{Oboril2013,
  author        = {F. {Oboril} and I. {Sagar} and M. B. {Tahoori}},
  booktitle     = {2013 IEEE 19th International On-Line Testing Symposium (IOLTS)},
  title         = {A-SOFT-AES: Self-adaptive software-implemented fault-tolerance for AES},
  year          = {2013},
  month         = {July},
  note          = {cited By 3},
  pages         = {104-109},
  abstract      = {The Advanced Encryption Standard (AES) is one of the most widespread encryption techniques used by millions of users worldwide. Although AES was designed to withstand linear or differential attacks, the security of encrypted messages is not guaranteed. Bit flips occurring during the encryption due to runtime failures or purposely invoked by an attacker are a major security concern and can significantly jeopardize integrity, privacy, and confidentiality and hence the security of the system. Therefore, techniques to increase the reliability (fault-tolerance) and with it the security of cryptographic systems are necessary. This work proposes a self-adaptive software-implemented fault-tolerance methodology for AES (A-SOFT-AES) to enhance its fault-tolerance. This technique is based on a pool of software-implemented fault-tolerance techniques out of which it dynamically chooses the best one in terms of performance, cost, and fault-tolerance for a wide range of fault rates. Therefore, it provides superior flexibility over classic hardware-based implementations.},
  art_number    = {6604059},
  document_type = {Conference Paper},
  doi           = {10.1109/IOLTS.2013.6604059},
  file          = {:download_papers/Oboril-2013-A-SOFT-AES Self-adaptive software-implemented fault-tolerance.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1942-9401},
  journal       = {Proceedings of the 2013 IEEE 19th International On-Line Testing Symposium, IOLTS 2013},
  keywords      = {cryptography;data integrity;data privacy;software fault tolerance;A-SOFT-AES;advanced encryption standard;reliability;cryptographic system security;self-adaptive software-implemented fault-tolerance methodology;fault rates;linear attacks;differential attacks;encrypted message security;system confidentiality;system privacy;system integrity;Encryption;Runtime;Fault tolerance;Fault tolerant systems;Tunneling magnetoresistance},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84885231013&doi=10.1109%2fIOLTS.2013.6604059&partnerID=40&md5=30bd431e5f158de0e4cc59d50998766a},
}

@InProceedings{Oliveira2014,
  author    = {N. {Oliveira} and L. S. {Barbosa}},
  booktitle = {2014 Eighth Brazilian Symposium on Software Components, Architectures and Reuse},
  title     = {A Self-Adaptation Strategy for Service-Based Architectures},
  year      = {2014},
  month     = {Sep.},
  pages     = {1-10},
  abstract  = {Self-adaptive software systems are known to respond at run time to changes detected internally or in their environment, in an attempt to keep meeting their own functional requirements and agreed levels of service. Such response usually targets their architectures and involve, in particular, the possibility of their dynamic reconfiguration. In contexts where change is the rule rather than the exception, it is difficult to predict when exactly such reconfigurations are needed, and if they will lead the system into a suitable configuration. However, knowing the main attributes of the context, it is possible to plan configurations that will be more likely to perform well in some conjugation of values for such attributes. In this paper we discuss both a model that lays down reconfiguration strategies, planned at design time, and a strategy which actively uses such a model to trigger architectural adaptations at run time. This strategy builds on a framework intended to the formal verification of architectural requirements, either from a qualitative or quantitative (probabilistic) perspective.},
  doi       = {10.1109/SBCARS.2014.12},
  file      = {:download_papers/Oliveira-2014-A Self-Adaptation Strategy for Service-Based Architectures.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {contracts;formal verification;probability;service-oriented architecture;self-adaptation strategy;service-based architectures;self-adaptive software systems;functional requirements;dynamic reconfiguration strategy;configuration planing;architectural adaptations;run time analysis;formal verification;architectural requirements;qualitative analysis;quantitative analysis;probabilistic method;service level agreements;Adaptation models;Quality of service;Servers;Monitoring;Context;Analytical models;Connectors},
}

@InProceedings{Oplenskedal2018,
  author    = {M. K. {Oplenskedal} and P. {Herrmann} and J. O. {Blech} and A. {Taherkordi}},
  booktitle = {2018 4th IEEE Conference on Network Softwarization and Workshops (NetSoft)},
  title     = {Simulation-driven Development of Self-adaptive Transportation Systems},
  year      = {2018},
  month     = {June},
  pages     = {372-377},
  abstract  = {Modern Intelligent Transportation Systems (ITS) operate highly automatically. Therefore, they have to be able to handle a large variety of situations each demanding a particular system behavior. That aggravates the development of control software that has to guarantee safe and expedient operation in all possible situations. To support a suitable reconfiguration of the controllers to changing environments, the use of self-adaptation seems to be a highly promising approach. In this paper, we propose to combine model-based engineering of control software with simulation. That allows us to create and test controller software in parallel with the physical systems, it shall operate. Moreover, this approach makes it possible to safely confront a transport system with situations that, otherwise, could only be reproduced taking a significant risk. In particular, we introduce a framework for the creation of control software using simulators together with a development structure. The suggested design process is illustrated with a mobile robot example.},
  doi       = {10.1109/NETSOFT.2018.8460073},
  file      = {:download_papers/Oplenskedal-2018-Simulation-driven Development of Self-adaptive Transportation.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {control engineering computing;intelligent transportation systems;mobile robots;self-adjusting systems;traffic engineering computing;control software;safe operation;physical systems;simulation-driven development;intelligent transportation systems;self-adaptive transportation systems;ITS;model-based engineering;controller software testing;Software;Unified modeling language;Robot sensing systems;Actuators;Adaptation models},
}

@InProceedings{Ouareth2018,
  author    = {S. {Ouareth} and S. {Boulehouache} and S. {Mazouzi}},
  booktitle = {2018 3rd International Conference on Pattern Analysis and Intelligent Systems (PAIS)},
  title     = {A Component-Based MAPE-K Control Loop Model for Self-adaptation},
  year      = {2018},
  month     = {Oct},
  pages     = {1-7},
  abstract  = {A Distinct external Control Loop is a promising approach to design autonomic computing systems. However, the existing designs, such as the MAPE-K Control Loop, are too general (i.e. they lack sufficient details about the structure and the dynamic of its sub-parts) and are not using well established design models. So, using the Fractal Component Model, we propose a Component-Based MAPE-K Control Loop model. The resulted MAPE-K Composite Component is sufficiently precise and explicit as it highlights the detailed architecture and hierarchy of the MAPE-K and its sub-components respectively. In addition, the proposed model promotes the reuse and the sharing of components as needed. In addition, it simplifies the maintenance of the MAPE-K Composite Component by the add, the remove, and the replacement of its sub-components.},
  doi       = {10.1109/PAIS.2018.8598529},
  file      = {:download_papers/Ouareth-2018-A Component-Based MAPE-K Control Loop Model for.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {formal specification;fractals;object-oriented programming;software architecture;design models;MAPE-K composite component;component-based MAPE-K control loop model;fractal component model;distinct external control loop;Fractals;Monitoring;Computational modeling;Adaptation models;Software;Sensors;Computer science;MAPE-K Control Loop;Fractal Component Model (FCM);Self-adaptation},
}

@InProceedings{Pandey2016,
  author    = {A. {Pandey} and G. A. {Moreno} and J. {C��mara} and D. {Garlan}},
  booktitle = {2016 IEEE 10th International Conference on Self-Adaptive and Self-Organizing Systems (SASO)},
  title     = {Hybrid Planning for Decision Making in Self-Adaptive Systems},
  year      = {2016},
  month     = {Sep.},
  pages     = {130-139},
  abstract  = {Run-time generation of adaptation plans is a powerful mechanism that helps a self-adaptive system to meet its goals in a dynamically changing environment. In the past, researchers have demonstrated successful use of various automated planning techniques to generate adaptation plans at run time. However, for a planning technique, there is often a trade-off between timeliness and optimality of the solution. For some self-adaptive systems, ideally, one would like to have a planning approach that is both quick and finds an optimal adaptation plan. To find the right balance between these conflicting requirements, this paper introduces a hybrid planning approach that combines more than one planner to obtain the benefits of each. In this paper, to instantiate a hybrid planner we combine deterministic planning with Markov Decision Process (MDP) planning to obtain the best of both worlds: deterministic planning provides plans quickly when timeliness is critical, while allowing MDP planning to generate optimal plans when the system has sufficient time to do so. We validate the hybrid planning approach using a realistic workload pattern in a simulated cloud-based self-adaptive system.},
  doi       = {10.1109/SASO.2016.19},
  file      = {:download_papers/Pandey-2016-Hybrid Planning for Decision Making in Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1949-3681},
  keywords  = {cloud computing;digital simulation;Markov processes;planning (artificial intelligence);decision making;run-time generation;dynamically changing environment;automated planning techniques;hybrid planning approach;Markov decision process planning;MDP;workload pattern;simulated cloud-based self-adaptive system;Planning;Uncertainty;Servers;Time factors;Markov processes;Maintenance engineering;Space exploration;Self-Adaptive Systems;Automated Planning;Cloud-Based Systems},
}

@InProceedings{Pandey2017,
  author    = {A. {Pandey} and D. {Garlan}},
  booktitle = {2017 IEEE 2nd International Workshops on Foundations and Applications of Self* Systems (FAS*W)},
  title     = {Hybrid Planning in Self-Adaptive Systems},
  year      = {2017},
  month     = {Sep.},
  pages     = {366-368},
  abstract  = {Self-adaptive software systems make decisions at run time that seek to change their behavior in response to faults, changing environments and attacks. Therefore, having an appropriate planning approach to find an adaptation plan is critical to successful self-adaptation. For many realistic systems, ideally one would like to have a planning approach that is both quick and finds an optimal adaptation plan. However, due to the fundamental trade-off between quality and timeliness of planning, often designers have to compromise between an approach that is quick to find a plan and an approach that is slow but finds an optimal plan. To deal with this trade-off, this work proposes a hybrid planning approach that combines more than one planning approach to bring their benefits together.},
  doi       = {10.1109/FAS-W.2017.176},
  file      = {:download_papers/Pandey-2017-Hybrid Planning in Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {planning (artificial intelligence);self-adjusting systems;software fault tolerance;system monitoring;self-adaptive software systems;optimal adaptation plan;hybrid planning approach;planning approach;self-adaptation;system behavior;planning quality;planning timeliness;Planning;Adaptive systems;Conferences;Artificial intelligence;Software;Cognition;Planning;Self-adaptation;Autonomic computing},
}

@InProceedings{Pandey2017a,
  author    = {A. {Pandey} and I. {Ruchkin} and B. {Schmerl} and J. {C��mara}},
  booktitle = {2017 IEEE/ACM 12th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Towards a Formal Framework for Hybrid Planning in Self-Adaptation},
  year      = {2017},
  month     = {May},
  pages     = {109-115},
  abstract  = {Decision-making approaches in self-adaptation face a fundamental trade-off between quality and timeliness of adaptation plans. Due to this trade-off, designers often have to make an offline compromise between finding adaptation plans quickly and finding closer-to-optimal plans that demand longer computation times. Recent work has proposed that hybrid planning can resolve this trade-off dynamically, achieving higher utility than either fast or slow approaches individually. The promise of hybrid planning is to combine multiple decision-making approaches at run time to produce adaptation plans of the high quality within given time constraints. However, the diversity of decision-making approaches makes the problem of hybrid planning complex and multi-faceted. This paper advances the theory of hybrid planning by formalizing the central concepts and four sub-problems of hybrid planning. This formalization can serve as a foundation for creating and evaluating hybrid planners in the future.},
  doi       = {10.1109/SEAMS.2017.14},
  file      = {:download_papers/Pandy-2017-Towards a Formal Framework for Hybrid Planning in Self-Adaptation.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {decision making;formal verification;planning;formal framework;hybrid planning;decision-making approaches;self-adaptation;offline compromise;Planning;Decision making;Time factors;Adaptive systems;Cognition;Servers;Face;Self-adaptive systems;Decision-making;Planning;Formal model},
}

@InProceedings{Park2008,
  author    = {Park, Jeongmin and Lee, Joonhoon and Lee, Eunseok},
  booktitle = {Proceedings of the 2nd International Conference on Ubiquitous Information Management and Communication},
  title     = {Goal Graph Based Performance Improvement for Self-Adaptive Modules},
  year      = {2008},
  address   = {New York, NY, USA},
  pages     = {58–62},
  publisher = {Association for Computing Machinery},
  series    = {ICUIMC ’08},
  abstract  = {Much effort is required to manage complex computing environments. Self-healing systems, adapted to their computing environments, offer a solution to this problem. Additional resources are required to use these systems. In our previous study, we proposed an approach that controls the behaviors of the self-adaptive components. This approach used switches to reduce the amount of resources required and enhance system performance. However, it did not include an abstraction approach to control the behavior of the self-adaptive modules. Specific code needs to be included when designing and implementing self-adaptive modules to utilize abstraction. In this study, we propose a method of 1) analyzing the behavioral levels of the self-adaptive modules through a goal graph 2) generating a behavior level activation switch using the specified levels. Through this approach, we can reduce additional resources required by the self-adaptive modules, and the effort involved in creating the code required for improving their performance. In order to evaluate the proposed approach, we draw a goal graph of a file transfer module used in a video conference system. This approach generates the template code of the behavior switch based on the goal graph that can improve the performance of self-adaptive modules. Through these processes, the generated code is applied to the modules, while verifying that the switches function properly. We compare the number of concurrent active components before and after applying this approach. In this way, we make certain that the code generated from the goal graph improves the performance of self-adaptive modules.},
  doi       = {10.1145/1352793.1352806},
  file      = {:download_papers/Park-2008-Goal graph based performance improvement for self-adaptive modules.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781595939937},
  keywords  = {self-adaptive module, activation switch, goal graph},
  location  = {Suwon, Korea},
  numpages  = {5},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1352793.1352806},
}

@Conference{Parvizi-Mosaed2014,
  author        = {Parvizi-Mosaed, A. and Moaven, S. and Habibi, J. and Heydarnoori, A.},
  title         = {Towards a tactic-based evaluation of self-adaptive software architecture availability},
  year          = {2014},
  note          = {cited By 3},
  number        = {January},
  pages         = {168-173},
  volume        = {2014-January},
  abstract      = {Nowadays, several non-automatic or semi-automatic software architecture evaluation methods have been proposed to evaluate their quality attributes as availability. In spite of their applicability, they are not effective in self-adaptive software architectures due to their off-line properties; e.g., scenario-based methods. Since the architectural tactics provide a bridge between architectural designs and quality attributes, they have sufficient potential to resolve this problem. In this paper, we assume that the software architecture is completely composed of some architectural patterns. Then we propose an automated evaluation method which composes the architectural tactics and the patterns to measure the availability of software architectures. In this method, the composition of a few availability tactics and patterns are simulated with appropriate probability distribution functions. To predict the availability of patterns, a data mining approach is applied to these simulated models to generate training models for each combination of tactics and patterns. Furthermore, a utility function is defined to compute the availability of systems by these models in O(n) where n is the number of patterns of systems. This method improves the data gathering and analysis activities of the SASSY (Self-Architecting Software SYstems) framework. To validate our method, we have applied it to the Rapidminer case study. Copyright © 2014 by Knowledge Systems Institute Graduate School.},
  document_type = {Conference Paper},
  file          = {:download_papers/Parvizi-2014-Towards a tactic-based evaluation of self-adaptive.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84938302961&partnerID=40&md5=1fd6df7eac259d38b009efbd61473eee},
}

@InProceedings{Paucar2019,
  author    = {Paucar, Luis H. Garcia and Bencomo, Nelly and Yuen, Kevin Kam Fung},
  booktitle = {Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing},
  title     = {ARRoW: AUtomatic RUntime REappraisal Of WEights for Self-Adaptation},
  year      = {2019},
  address   = {New York, NY, USA},
  pages     = {1584–1591},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’19},
  abstract  = {Decision-making for self-adaptive systems (SAS) requires the runtime trade-off of multiple non-functional requirements (NFRs) and the costs-benefits analysis of the alternative solutions. Usually, it is required the specification of the weights (a.k.a. preferences) associated with the NFRs and decision-making strategies. These preferences are traditionally defined at design-time. [<u>Questions/Problems</u>] A big challenge is the need to deal with unsuitable preferences, based on empirical evidence available at runtime, and which may not agree anymore with previous assumptions. Therefore, new techniques are needed to systematically reassess the current preferences according to empirical evidence collected at runtime. [<u>Principal ideas/ results</u>] We present ARRoW (<u>A</u>utomatic <u>R</u>untime <u>R</u>eappraisal <u>o</u>f <u>W</u>eights) to support the dynamic update of preferences/weights associated with the NFRs and decision-making strategies in SAS, while taking into account the current levels of satisficement that NFRs can reach during the system's operation. [<u>Contribution</u>] To developed ARRoW, we have extended the Primitive Cognitive Network Process (P-CNP), a version of the Analytical Hierarchy Process (AHP), to enable the handling and update of weights during runtime. Specifically, in this paper, we show a formalization for the specification of the decision-making of a SAS in terms of NFRs, the design decisions and their corresponding weights as a P-CNP problem. We also report on how the P-CNP has been extended to be used at runtime. We show how the propagation of elements of P-CNP matrices is performed in such a way that the weights are updated to therefore, improve the levels of satisficement of the NFRs to better match the current environment during runtime. ARRoW leverages the Bayesian learning process underneath, which on the other hand, provides the mechanism to get access to evidence about the levels of satisficement of the NFRs. The experiments have been applied to a case study of the networking application domain where the decision-making has been improved.},
  doi       = {10.1145/3297280.3299743},
  file      = {:download_papers/Paucar-2019-ARRoW Automatic Runtime Reappraisal of Weights for self-adaptation.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450359337},
  keywords  = {non-functional properties, bayesian evidence, decision-making, AHP, uncertainty, runtime models, self-adaptation},
  location  = {Limassol, Cyprus},
  numpages  = {8},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3297280.3299743},
}

@Conference{Perez-Palacin2011a,
  author        = {Perez-Palacin, D. and Merseguer, J.},
  title         = {Performance sensitive self-adaptive service-oriented software using hidden Markov models},
  year          = {2011},
  note          = {cited By 7},
  pages         = {201-206},
  abstract      = {Service Oriented Architecture (SOA) is a paradigm where applications are built on services offered by third party providers. Behavior of providers evolves and makes a challenge the performance prediction of SOA applications. A proper decision about when a provider should be substituted can dramatically improve the performance of the application. We propose hidden Markov models (HMM) to help service integrators to foretell the current state of third-parties. The paper leverages different algorithms that change providers based on predictions about their states. We also integrate these algorithms and HMMs in an architectural solution to coordinate them with other challenges in the SOA world.},
  document_type = {Conference Paper},
  doi           = {10.1145/1958746.1958776},
  file          = {:download_papers/Perez-2011-Performance sensitive self-adaptive service-oriented software using.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {ICPE'11 - Proceedings of the 2nd Joint WOSP/SIPEW International Conference on Performance Engineering},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-79953861697&doi=10.1145%2f1958746.1958776&partnerID=40&md5=3a5dd9fb20f9d270f40f5219d579db5c},
}

@InProceedings{Petrovska2019,
  author        = {A. {Petrovska} and A. {Pretschner}},
  booktitle     = {2019 IEEE 4th International Workshops on Foundations and Applications of Self* Systems (FAS*W)},
  title         = {Learning Approach for Smart Self-Adaptive Cyber-Physical Systems},
  year          = {2019},
  month         = {June},
  note          = {cited By 0},
  pages         = {234-236},
  abstract      = {Modern Cyber-Physical Systems (CPSs) need to be able to operate efficiently and reliably within continually changing, uncertain, and unanticipated environments. Namely, these systems should be capable of learning, automatically reconfiguring themselves, and be able to cooperate and collaborate with other CPSs. In a nutshell, exhibit human-like, smart capabilities in an autonomic manner. However, engineering such systems is all but trivial, primarily because we need to develop systems at design-time that are capable of autonomously coping with the uncertainty and change at runtime. Therefore, not only the importance of self-adaptivity as a system's feature increases, but it becomes a fundamental approach for the systems to continue meeting their functional specifications, fulfilling their business objectives while preserving the performance-despite all the runtime changes that the system may encounter. To tackle these challenges, this paper proposes the initial research vision and agenda with the envisioned contributions towards an approach for self-adaptation of cooperative, smart CPSs through shared knowledge and learning.},
  art_number    = {8791990},
  document_type = {Conference Paper},
  doi           = {10.1109/FAS-W.2019.00061},
  file          = {:download_papers/Petrovska-2019-Learning Approach for Smart Self-Adaptive Cyber-Physical Systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2019 IEEE 4th International Workshops on Foundations and Applications of Self* Systems, FAS*W 2019},
  keywords      = {learning (artificial intelligence);security of data;software architecture;software fault tolerance;autonomic manner;smart CPSs;human-like capabilities;smart capabilities;smart self-adaptive cyber-physical systems;Uncertainty;Robot sensing systems;Adaptation models;Runtime;Monitoring;Synthetic aperture sonar;Self-Adaptive Cyber-Physical Systems;Context;Change and Uncertainty;Awareness;Learning;Performance},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85071432872&doi=10.1109%2fFAS-W.2019.00061&partnerID=40&md5=4812125e6856ecd1f838d35ef5f5bb28},
}

@InProceedings{Pham2000,
  author        = {T. Q. {Pham} and K. R. {Dixon} and P. K. {Khosla}},
  booktitle     = {Proceedings. 2000 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS 2000) (Cat. No.00CH37113)},
  title         = {Software systems facilitating self-adaptive control software},
  year          = {2000},
  month         = {Oct},
  note          = {cited By 8},
  pages         = {1094-1100 vol.2},
  volume        = {2},
  abstract      = {Self-adaptive control software is a new paradigm to create robust, fault-tolerant mobile robots. This type of software analyzes its performance and dynamically modifies itself to operate better in adverse and rapidly changing conditions. We have created two systems that facilitate the creation of self-adaptive control software: PB3A and RAVE. PB3A, the Port-Based Adaptable Agent Architecture, is a mobile, agent-based framework that allows software to adapt itself at all levels. RAVE, the Real And Virtual Environment, is a mixed-reality simulation environment for mobile robots. Together these two systems allow for the creation, testing, and analysis of self-adaptive control software by on- and off-line simulation. We give brief overviews of PB3A and RAVE and present applications that demonstrate robotic systems using self-adaptive control software.},
  document_type = {Article},
  doi           = {10.1109/IROS.2000.893165},
  file          = {:download_papers/Pham-2000-Software systems facilitating self-adaptive control software.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {IEEE International Conference on Intelligent Robots and Systems},
  keywords      = {mobile robots;multi-agent systems;virtual reality;digital simulation;self-adjusting systems;software engineering;program testing;software tools;software systems;self-adaptive control software;robust fault-tolerant mobile robots;rapidly changing conditions;adverse conditions;PB3A;RAVE;Port-Based Adaptable Agent Architecture;mobile agent-based framework;Real And Virtual Environment;mixed-reality simulation environment;off-line simulation;online simulation;Software systems;Control systems;Mobile robots;Robust control;Fault tolerance;Software performance;Performance analysis;Computer architecture;Virtual environment;Virtual reality},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0034447485&doi=10.1109%2fIROS.2000.893165&partnerID=40&md5=9225d1663d393d93fae6fed2c756d83e},
}

@InProceedings{Poggi2016,
  author    = {F. {Poggi} and D. {Rossi} and P. {Ciancarini} and L. {Bompani}},
  booktitle = {2016 IEEE 2nd International Forum on Research and Technologies for Society and Industry Leveraging a better tomorrow (RTSI)},
  title     = {An application of semantic technologies to self adaptations},
  year      = {2016},
  month     = {Sep.},
  pages     = {1-6},
  abstract  = {In this paper we present an approach to add self-adaptive features to software systems not initially designed to be self-adaptive. Rapid changes in users needs, available resources, and types of system faults are everyday concerns in operating complex systems. The ability to face these issues in a (semi-)automatic fashion is a welcome feature. MAPE-K (Monitor, Analyze, Plan, Execute - Knowledge), or one of its variations, is the basic architectural pattern around which most adaptation engines are built. The knowledge (K) element in that pattern is usually a collection of dynamic and static models representing relevant aspects of the system and its environment. Knowledge-based features can be encoded using various techniques and serve a number of disparate roles: providing dynamic views of the system (Reflection Models), representing reconfiguration policies (Evaluation Models), mapping reconfigurations into system-level adaptations (Execution Models), and so forth. In our approach all these models are unified by using ontologies and Semantic Web technologies; the resulting knowledge base is then used to drive adaptation activities. We discuss how the various MAPE-K components can be designed in order to take advantage of this knowledge base by applying our approach to a real-word case study: a deployed system that was not designed to perform automatic adaptation. We then discuss merits and limits of our proposal both in the context of this specific case study and in a broader scope.},
  doi       = {10.1109/RTSI.2016.7740548},
  file      = {:download_papers/Poggi-2016-An application of semantic technologies to self adaptations.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {knowledge based systems;large-scale systems;ontologies (artificial intelligence);semantic Web;software architecture;semantic technology;self adaptations;software system self-adaptive features;complex system operation;MAPE-K;Monitor, Analyze, Plan, Execute - Knowledge;architectural pattern;adaptation engines;knowledge element;dynamic models;static models;knowledge-based features;reflection models;reconfiguration policies;evaluation models;system-level adaptations;execution models;ontologies;semantic Web;automatic adaptation;Adaptation models;Ontologies;Semantics;Monitoring;Context;Engines;Semantic Web},
}

@InProceedings{Preuveneers2006,
  author    = {D. {Preuveneers} and Y. {Berbers}},
  booktitle = {International Conference on Autonomic and Autonomous Systems (ICAS'06)},
  title     = {Multi-dimensional Dependency and Conflict Resolution for Self-adaptable Context-aware Systems},
  year      = {2006},
  month     = {July},
  pages     = {36-36},
  abstract  = {Self-adaptable systems dynamically adapt to satisfy new functionality requirements, to optimize performance and to adapt to variable runtime conditions. Context-aware systems acquire and utilize information about the context of a user and a device to provide personalized applications. Adaptation in a transparent way for the user is an important concern for both systems. To decrease the adaptation complexity of self-adaptable context-aware systems, we propose to model self-adaptation across three layers of abstractions: the runtime infrastructure, the context middleware and the user applications. The aim is to achieve per layer self-adaptation of the composition or behavior of these layers without jeopardizing the integrity and usability of the overall system. We discuss a multi-dimensional dependency and conflict resolution mechanism to guide self-adaptation and find a stable reconfiguration of the system at runtime},
  doi       = {10.1109/ICAS.2006.37},
  file      = {:download_papers/Preuveneers-2006-Multi-dimensional Dependency and Conflict Resolution.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2168-1872},
  keywords  = {knowledge based systems;middleware;ubiquitous computing;multidimensional dependency;self-adaptable context-aware system;dynamic adaptation;personalized application;adaptation complexity;self-adaptation model;runtime infrastructure;context middleware;user application;conflict resolution mechanism;stable system reconfiguration;Context-aware services;Runtime;Middleware;Computer science;Usability;Video sharing;Videoconference;Protocols;Application software;Context modeling},
}

@InProceedings{Psaier2010,
  author    = {H. {Psaier} and L. {Juszczyk} and F. {Skopik} and D. {Schall} and S. {Dustdar}},
  booktitle = {2010 Fourth IEEE International Conference on Self-Adaptive and Self-Organizing Systems},
  title     = {Runtime Behavior Monitoring and Self-Adaptation in Service-Oriented Systems},
  year      = {2010},
  month     = {Sep.},
  pages     = {164-173},
  abstract  = {Mixed service-oriented systems composed of human actors and software services build up complex interaction networks. Without any coordination, such systems may exhibit undesirable properties due to unexpected behavior. Also, communications and interactions in such networks are not preplanned by top-down composition models. Consequently, the management of service-oriented applications is difficult due to changing interaction and behavior patterns that possibly contradict and result in faults from varying conditions and misbehavior in the network. In this paper we present a self-adaptation approach that regulates local interactions to maintain desired system functionality. To prevent degraded or stalled systems, adaptations operate by link modification or substitution of actors based on similarity and trust metrics. Unlike a security perspective on trust, we focus on the notion of socially inspired trust. We design an architecture based on two separate independent frameworks. One providing a real Web service test bed extensible for dynamic adaptation actions. The other is our self-adaptation framework including all modules required by systems with self-* properties. In our experiments we study a trust and similarity based adaptation approach by simulating dynamic interactions in the real Web services test bed.},
  doi       = {10.1109/SASO.2010.44},
  file      = {:download_papers/Psaier-2010-Runtime Behavior Monitoring and Self-Adaptation in Service-Oriented.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1949-3681},
  keywords  = {software architecture;software metrics;Web services;runtime behavior monitoring;mixed service-oriented system;software services;complex interaction networks;top-down composition model;behavior pattern;interaction pattern;trust metrics;similarity metrics;software architecture;self-adaptation framework;real Web services testbed;Collaboration;Monitoring;Communities;Runtime;Web services;Humans;Adaptation model;Service-oriented collaboration;monitoring;self-adaptation;web service testbed;dynamic trust},
}

@InProceedings{Qureshi2010,
  author    = {N. A. {Qureshi} and A. {Perini}},
  booktitle = {2010 First International Workshop on Requirements@Run.Time},
  title     = {Continuous adaptive requirements engineering: An architecture for self-adaptive service-based applications},
  year      = {2010},
  month     = {Sep.},
  pages     = {17-24},
  abstract  = {Engineering self-adaptive service-based applications significantly challenges the role of requirements engineering (RE). Such systems need to cope with the evolving requirements at runtime by monitoring the changes in users' preferences and in the environment, evaluating the changes and enacting a suitable behavior ensuring an acceptable level of quality for their users. This calls for continuous reappraisal of their requirements specification enabling them to reason for them at run-time. Recently, we proposed a novel framework for Continuous Adaptive RE (CARE) supporting self-adaptive service-based applications and on conceptual tools needed to realize RE at run-time. In this position paper, we focus on a conceptual architecture for the CARE framework, and illustrate how it can work using scenarios from travel domain. Potential impact of our work and useful integration with recent studies are discussed, highlighting open points for future research.},
  doi       = {10.1109/RERUNTIME.2010.5628553},
  file      = {:download_papers/Qureshi-2010-Continuous adaptive requirements engineering An architecture.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive systems;software architecture;systems analysis;adaptive requirements engineering;self adaptive system;requirements specification;service based application architecture;Monitoring;Airports;Ontologies;Cognition;Context;Meteorology;Delay;Requirements Engineering;Self-adaptive systems;Service based Applications},
}

@InProceedings{Qureshi2010a,
  author    = {N. A. {Qureshi} and A. {Perini} and N. A. {Ernst} and J. {Mylopoulos}},
  booktitle = {2010 First International Workshop on Requirements@Run.Time},
  title     = {Towards a continuous requirements engineering framework for self-adaptive systems},
  year      = {2010},
  month     = {Sep.},
  pages     = {9-16},
  abstract  = {Requirements engineering (RE) for self-adaptive systems (SAS) is an emerging research area. The key features of such systems are to be aware of the changes in both their operating and external environments, while simultaneously remaining aware of their users' goals and preferences. This is accomplished by evaluating such changes and adapting to a suitable alternative that can satisfy those changes in the context of the user goals. Most current RE languages do not consider this `reflective' and online component of requirements models. In this paper, we propose a new framework for building SAS that is goal- and user-oriented. We sketch a framework to enable continuous adaptive requirements engineering (CARE) for SAS that leverage requirements-aware systems and exploits the Techne modeling language and reasoning system. We illustrate our framework by showing how it can handle an adaptive scenario in the travel domain.},
  doi       = {10.1109/RERUNTIME.2010.5628552},
  file      = {:download_papers/Qureshi-2010-Towards a continuous requirements engineering framework.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {software engineering;systems analysis;continuous requirements engineering framework;self adaptive systems;RE;SAS;external environments;operating environments;online component;continuous adaptive requirements engineering;CARE;techne modeling language;Synthetic aperture sonar;Adaptation model;Monitoring;Business;Context;Ontologies;Cognition},
}

@InProceedings{Riccobene2015,
  author    = {Riccobene, Elvinia and Scandurra, Patrizia},
  booktitle = {Proceedings of the 30th Annual ACM Symposium on Applied Computing},
  title     = {Formal Modeling Self-Adaptive Service-Oriented Applications},
  year      = {2015},
  address   = {New York, NY, USA},
  pages     = {1704–1710},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’15},
  abstract  = {In the context of modern service-oriented applications, components must be able to autonomously adapt their behavior in response to rapidly changing environment and business conditions. Formal frameworks for modeling self-adaptive behavior of service-oriented components (SOCs) are critically required to assure quality properties. In this paper we show how SCA-ASM, a lightweight formal framework for modeling and executing service-oriented applications, can be used to express adaptive behavior of service components. We explain how modeling an SCAASM component able to monitor and react to environmental changes (context-awareness) and to internal changes (self-awareness), and present the operators for expressing and coordinating self-adaptive behaviors in a distributed setting.},
  doi       = {10.1145/2695664.2695772},
  file      = {:download_papers/Riccobene-2015-Formal modeling self-adaptive service-oriented applications.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450331968},
  keywords  = {formal modeling, self-adaptation, SCA-ASM, service-oriented applications},
  location  = {Salamanca, Spain},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2695664.2695772},
}

@InProceedings{Robertson2004,
  author    = {P. {Robertson} and R. {Laddaga}},
  booktitle = {24th International Conference on Distributed Computing Systems Workshops, 2004. Proceedings.},
  title     = {The GRAVA self-adaptive architecture: history; design; applications; and challenges},
  year      = {2004},
  month     = {March},
  pages     = {298-303},
  abstract  = {In 1998 DARPA embarked on a program to develop self-adaptive software. One architecture that emerged from that effort was the GRAVA architecture. The GRAVA architecture has by now been applied to a number of challenging domains and continues to be extended and applied to ever more challenging problems. An overview is provided of the history that motivated the program, the design of the GRAVA architecture, and the applications to which it is being applied. Challenges and open problems are discussed.},
  doi       = {10.1109/ICDCSW.2004.1284046},
  file      = {:download_papers/Robertson-2004-The GRAVA self-adaptive architecture history design applications.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive systems;software architecture;sensor fusion;history;GRAVA self-adaptive architecture;self-adaptive software;History;Computer architecture;Application software;Context awareness;Robustness;Software performance;Open source software;Computer vision;Layout;Runtime},
}

@InProceedings{Rodrigues2018,
  author    = {Rodrigues, Arthur and Caldas, Ricardo Diniz and Rodrigues, Gena\'{\i}na Nunes and Vogel, Thomas and Pelliccione, Patrizio},
  booktitle = {Proceedings of the 13th International Conference on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {A Learning Approach to Enhance Assurances for Real-Time Self-Adaptive Systems},
  year      = {2018},
  address   = {New York, NY, USA},
  pages     = {206–216},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’18},
  abstract  = {The assurance of real-time properties is prone to context variability. Providing such assurance at design time would require to check all the possible context and system variations or to predict which one will be actually used. Both cases are not viable in practice since there are too many possibilities to foresee. Moreover, the knowledge required to fully provide the assurance for self-adaptive systems is only available at runtime and therefore difficult to predict at early development stages. Despite all the efforts on assurances for self-adaptive systems at design or runtime, there is still a gap on verifying and validating real-time constraints accounting for context variability. To fill this gap, we propose a method to provide assurance of self-adaptive systems, at design-and runtime, with special focus on real-time constraints. We combine off-line requirements elicitation and model checking with on-line data collection and data mining to guarantee the system's goals, both functional and non-functional, with fine tuning of the adaptation policies towards the optimization of quality attributes. We experimentally evaluate our method on a simulated prototype of a Body Sensor Network system (BSN) implemented in OpenDaVINCI. The results of the validation are promising and show that our method is effective in providing evidence that support the provision of assurance.},
  doi       = {10.1145/3194133.3194147},
  file      = {:download_papers/Rodrigues-2018-A learning approach to enhance assurances for real-time.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450357159},
  keywords  = {learning approach, assurance evidence, self-adaptive systems, goal-oriented, real-time systems, data mining},
  location  = {Gothenburg, Sweden},
  numpages  = {11},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3194133.3194147},
}

@InProceedings{Rodriguez2010,
  author    = {I. B. {Rodriguez} and J. {Lacouture} and K. {Drira}},
  booktitle = {2010 24th IEEE International Conference on Advanced Information Networking and Applications},
  title     = {Semantic Driven Self-Adaptation of Communications Applied to ERCMS},
  year      = {2010},
  month     = {April},
  pages     = {1292-1299},
  abstract  = {To adapt communication in order to maintain the connectivity and the quality of communications in group-wide collaborative activities becomes challenging when considering mobile entities in a wireless environment, requiring responsiveness and availability of the communication system, and designing self-adaptable communication architecture remains a complex task. To simplify this task, semantic presents a very attractive alternative to support self-adaptation and context awareness. This paper proposes three ontologies to model different aspects related to communication (organizational, collaborative and contextual) and to forecast future problems in accordance with priorities. Adaptation actions are also proposed for self-adaptation in communicating architecture. These actions deal with different changing context parameters such as resource constraints and architecture evolution requirements. To illustrate the proposed ontologies and some adaptation actions, we use ERCMS (Emergency Response and Crisis Management Systems) scenarios of the ROSACE project as a case study from the more general group communication systems.},
  doi       = {10.1109/AINA.2010.158},
  file      = {:download_papers/Rodriguez-2010-Semantic Driven Self-Adaptation of Communications.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2332-5658},
  keywords  = {emergency services;groupware;mobile communication;ontologies (artificial intelligence);ubiquitous computing;semantic driven communications self adaptation;group wide collaborative activities;wireless environment;mobile entities;context awareness;ontologies;emergency response and crisis management systems;ROSACE project;Ontologies;Mobile communication;Quality of service;Resource management;Context modeling;Software safety;Context-aware services;Uninterruptible power systems;International collaboration;Delay;Self-adaptation;Communication;Ontology},
}

@InProceedings{Romay2013,
  author    = {Romay, M. Pilar and Cuesta, Carlos E. and Fern\'{a}ndez-Sanz, Luis},
  booktitle = {Proceedings of the First International Workshop on Software Engineering for Systems-of-Systems},
  title     = {On Self-Adaptation in Systems-of-Systems},
  year      = {2013},
  address   = {New York, NY, USA},
  pages     = {29–34},
  publisher = {Association for Computing Machinery},
  series    = {SESoS ’13},
  abstract  = {Adaptivity and systems-of-systems (SoS) have always had a close relationship, as it is one of their defining features. Moreover, there is a clear similarity between the requirements of a SoS and those of many adaptive systems, such as autonomic and self-adaptive systems. In recent years, this kind of adaptive systems has been carefully studied; however, they often operate at a very different scale, being smaller than a typical SoS. The common nexus between both perspectives seem to be situated at the architectural level: the same adaptive techniques are recursively applied in different strata in a hierarchical composite. Therefore, the principles embodied in adaptive architectures seem to provide a good basis for the definition and description of SoS. This paper relates those principles to the corresponding structures in software evolution, and suggests to coordinate both through a pace layering strategy.},
  doi       = {10.1145/2489850.2489856},
  file      = {:download_papers/Romay-2013-On self-adaptation in systems-of-systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450320481},
  keywords  = {self-adaptation, ULS, software architecture, adaptive architectures, systems-of-systems, autonomic systems},
  location  = {Montpellier, France},
  numpages  = {6},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2489850.2489856},
}

@InProceedings{Roopa2016,
  author        = {Y. M. {Roopa} and A. R. {Reddy}},
  booktitle     = {2016 International Conference on Communication and Electronics Systems (ICCES)},
  title         = {Cost optimization component selection approach for component based self-adaptive software architecture using component repository},
  year          = {2016},
  month         = {Oct},
  note          = {cited By 0},
  pages         = {1-6},
  abstract      = {Now a days Ubiquitous computing plays major role in the adaptable software development. The ubiquitous computing works on the principle of context awareness. Context awareness is the methodology which recognizes and monitors the environment and adapt to the environment where they have been introduced. The self-adaptive software architecture is developed based on component based software engineering, which concentrates on the reusability of the software components to achieve better productivity. The proposed architecture uses component repository to adapt the changes to the architecture. The component repository is introduced where it contains the predefined and reusable components and their services for adaptation. The optimized algorithm applied for the component selection in the component repository. The GRASP algorithm is used to optimize the system architecture. The experimental results are validated based on real time environments and compare the results with other existing methods. The proposed models show the superiority in terms of performance.},
  art_number    = {7889859},
  document_type = {Conference Paper},
  doi           = {10.1109/CESYS.2016.7889859},
  file          = {:download_papers/Roopa-2016-Cost optimization component selection approach for component.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings of the International Conference on Communication and Electronics Systems, ICCES 2016},
  keywords      = {optimisation;software architecture;software reliability;ubiquitous computing;cost optimization component selection approach;self-adaptive software architecture;component repository;ubiquitous computing;software development;context awareness;software components;reusable components;optimized algorithm;Context;Monitoring;Computer architecture;Software;Servers;Adaptation models;component;self-adaptive software;software architecture;optimization approach;GRASP. Introduction},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85018422731&doi=10.1109%2fCESYS.2016.7889859&partnerID=40&md5=bebf5a80032545e8902d5da8bf437b4d},
}

@InProceedings{Rossi2017,
  author    = {D. {Rossi} and F. {Poggi} and P. {Ciancarini}},
  booktitle = {2017 6th International Conference on Reliability, Infocom Technologies and Optimization (Trends and Future Directions) (ICRITO)},
  title     = {Dynamic high-level in self-adaptive systems},
  year      = {2017},
  month     = {Sep.},
  pages     = {49-60},
  abstract  = {An adaptive software has the ability of modify its own behavior for responding at runtime to changes in its surround context. The ability to self-adapt to changing operational contexts or scopes means that the system can modify its behavior with respect to its original requirements at run time. Recently a new dimension of adaptation is increasing its relevance for complex systems: the ability to accommodate changes in the original requirements taking place when the system is operational. A self-adaptive system should also, to some extent, enable dynamic reconfigurations to meet new or modified requirements without the need of a new design/develop/test/deploy cycle. In this paper we present a software architecture exploiting an explicit, actionable requirement model to drive self-adaptation activities. The architecture includes some semantic-based models able to manage requirements at runtime. We show an implementation of this architecture that leverages the semantic representation of changes to requirements at runtime. We show how the requirements models are related to the software architecture and how runtime changes in these models can influence the adaptive behavior of the system.},
  doi       = {10.1109/ICRITO.2017.8342398},
  file      = {:download_papers/Rossi-2017-Dynamic high-level in self-adaptive systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive systems;software architecture;self-adaptive system;dynamic reconfigurations;software architecture;explicit requirement model;actionable requirement model;self-adaptation activities;adaptive behavior;dynamic high-level;adaptive software;operational contexts;complex systems},
}

@InProceedings{Rossi2018,
  author    = {Rossi, Davide and Poggi, Francesco and Ciancarini, Paolo},
  booktitle = {Proceedings of the 33rd Annual ACM Symposium on Applied Computing},
  title     = {Dynamic High-Level Requirements in Self-Adaptive Systems},
  year      = {2018},
  address   = {New York, NY, USA},
  pages     = {128–137},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’18},
  abstract  = {Non-functional requirements are the main drivers behind the design choices that shape a software architecture. Self-adaptive systems blur the boundary between design-time and run-time allowing the dynamic re-shaping of a running system to better accommodate changes in the execution context or in stakeholders' expectations. When these expectations are related to aspects that influence architectural decisions this imply the ability to reconsider these decisions at runtime without the need of re-deployment (and associated system downtime). Existing research works on non-functional requirements in self-adaptive systems usually focus on operationalizable requirements, which entails development activities refining these changes into their run-time counterparts (such as SLAs). In this paper we present an approach that allows the autonomic re-shaping of the architecture of a self-adaptive system when high-level nonfunctional non-operationalizable requirements change. Changes in the requirements while the system is operational can trigger a re-evaluation of specific design choices resulting in reconfiguration activities that modify the system architecture. Our approach is based on a (semantic) runtime requirements model that can be automatically refined from high-level representations using model-to-model (M2M) transformations.},
  doi       = {10.1145/3167132.3167143},
  file      = {:download_papers/Rossi-2018-Dynamic high-level requirements in self-adaptive systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450351911},
  keywords  = {model-driven engineering, self-adaptive, requirements engineering},
  location  = {Pau, France},
  numpages  = {10},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3167132.3167143},
}

@InProceedings{Safi2010,
  author        = {G. {Safi} and S. {Mirian-Hosseinabadi}},
  booktitle     = {2010 Seventh IEEE International Conference and Workshops on Engineering of Autonomic and Autonomous Systems},
  title         = {A Service Based Approach to Self-Adaptive Software Systems Based on Constructing a Group of Autonomic Elements},
  year          = {2010},
  month         = {March},
  note          = {cited By 3},
  pages         = {101-105},
  abstract      = {As requirements and environments become much more complex, the need for self-adaptive and self-healing software system grows. There are several existing works which present such systems by using different approaches. Using alternative solutions to provide a service or requirement is one of the most important approaches among existing works. In this paper an alternative-based approach for adding self-adaptive capabilities to software systems is proposed. In this approach a group of autonomic elements will be constructed based on different design or implementations that could be considered for a specific service or requirement. By using this approach, a highly adaptive software system could be built based on autonomic elements, so that it needs much less memory and processing resources in comparison to similar existing works.},
  art_number    = {5457814},
  document_type = {Conference Paper},
  doi           = {10.1109/EASe.2010.20},
  file          = {:download_papers/Safi-2010-A Service Based Approach to Self-Adaptive Software Systems.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2168-1872},
  journal       = {Proceedings of the 7th IEEE International Conference and Workshop on Engineering of Autonomic and Autonomous Systems, EASe 2010},
  keywords      = {software fault tolerance;self-adaptive software systems;autonomic elements;self-healing software system;Software systems;Pervasive computing;Conferences;Software quality;Adaptive systems;Collaborative work;Distributed computing;Software design;Machine learning;Software safety;Self-adaptive Software systems;Autonomic Elements;Software Services},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-77953195900&doi=10.1109%2fEASe.2010.20&partnerID=40&md5=16a2dd7f64bdb64c997005f7586ddd8b},
}

@InProceedings{Salehie2007a,
  author        = {M. {Salehie} and L. {Tahvildari}},
  booktitle     = {First International Conference on Self-Adaptive and Self-Organizing Systems (SASO 2007)},
  title         = {A Weighted Voting Mechanism for Action Selection Problem in Self-Adaptive Software},
  year          = {2007},
  month         = {July},
  note          = {cited By 6},
  pages         = {328-331},
  abstract      = {Self-adaptive software is a closed-loop system which aims at adjusting itself in response to changes at runtime. Such a system is required to monitor domain events, detect significant changes, decide how to react, and act in order to execute the decisions. This paper focuses on the deciding process particularly for application-level adaptation actions. For this purpose, a weighted voting mechanism has been proposed which makes decisions based on a Goal-Action- Attribute Model (GAAM). The decision-making algorithm traverses GAAM, determines activated goals and feasible actions for voting, and ultimately selects an action as the social choice. The proposed mechanism and GAAM are evaluated within a simulated model of a news web site.},
  art_number    = {4274924},
  document_type = {Conference Paper},
  doi           = {10.1109/SASO.2007.4},
  file          = {:download_papers/Salehie-2007-A Weighted Voting Mechanism for Action Selection Problem.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1949-3681},
  journal       = {First International Conference on Self-Adaptive and Self-Organizing Systems, SASO 2007},
  keywords      = {adaptive systems;knowledge representation;weighted voting mechanism;action selection;self-adaptive software;closed-loop system;domain event monitoring;application-level adaptation;goal-action-attribute model;decision making;social choice;Voting;Decision making;Runtime;Navigation;Engines;Software engineering;Autonomous agents;Computerized monitoring;Event detection;Costs},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-37049024515&doi=10.1109%2fSASO.2007.4&partnerID=40&md5=6833218154513558c67c9e0e09938690},
}

@Article{Salehie2012,
  author        = {-, M. and Tahvildari, L.},
  journal       = {Software - Practice and Experience},
  title         = {Towards a goal-driven approach to action selection in self-adaptive software},
  year          = {2012},
  note          = {cited By 26},
  number        = {2},
  pages         = {211-233},
  volume        = {42},
  abstract      = {Self-adaptive software is a closed-loop system, since it continuously monitors its context (i.e. environment) and/or self (i.e. software entities) in order to adapt itself properly to changes. We believe that representing adaptation goals explicitly and tracing them at run-time are helpful in decision making for adaptation. While goal-driven models are used in requirements engineering, they have not been utilized systematically yet for run-time adaptation. To address this research gap, this article focuses on the deciding process in self-adaptive software, and proposes the Goal-Action-Attribute Model (GAAM). An action selection mechanism, based on cooperative decision making, is also proposed that uses GAAM to select the appropriate adaptation action(s). The emphasis is on building a light-weight and scalable run-time model which needs less design and tuning effort comparing with a typical rule-based approach. The GAAM and action selection mechanism are evaluated using a set of experiments on a simulated multi-tier enterprise application, and two sample ordinal and cardinal action preference lists. The evaluation is accomplished based on a systematic design of experiment and a detailed statistical analysis in order to investigate several research questions. The findings are promising, considering the obtained results, and other impacts of the approach on engineering self-adaptive software. Although, one case study is not enough to generalize the findings, and the proposed mechanism does not always outperform a typical rule-based approach, less effort, scalability, and flexibility of GAAM are remarkable. Copyright © 2011 John Wiley & Sons, Ltd.},
  document_type = {Article},
  doi           = {10.1002/spe.1066},
  eprint        = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.1066},
  file          = {:download_papers/Salehie-2012-Towards a goal-driven approach to action selection.pdf:PDF},
  groups        = {scopus, wiley, systematic_search},
  keywords      = {self-adaptive software, goal-driven model, run-time action selection},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84856237838&doi=10.1002%2fspe.1066&partnerID=40&md5=459a1d14b00d4f3260ed8efe78ca078b},
}

@InProceedings{Satoh2012,
  author    = {I. {Satoh}},
  booktitle = {2012 IEEE Conference on Evolving and Adaptive Intelligent Systems},
  title     = {Self-adaptive mechanism for distributed computing},
  year      = {2012},
  month     = {May},
  pages     = {11-16},
  abstract  = {This paper proposes a framework for adapting software components for a disaggregated system, which dynamically composes devices, e.g., displays, keyboard, and mice, which do not attached to the same computer into a virtual computer over a distributed system, including ubiquitous/pervasive computing systems. It introduces the notions of differentiation and dedifferentiation in cellular slime molds into real distributed systems, including disaggregated systems. When software components delegates a function to another component coordinating with it, if the former has the function, this function becomes less-developed and the latter's function becomes well-developed. The framework was constructed as a middleware system and allowed us to define agents as Java objects written in JavaBean. We present several evaluations of the framework in a distributed system instead of any simulation-based systems and describes a practical application.},
  doi       = {10.1109/EAIS.2012.6232797},
  file      = {:download_papers/Satoh-2010-Self-adaptive mechanism for distributed computing.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {digital simulation;Java;middleware;self-adaptive mechanism;distributed computing;software components adaptation;disaggated system;displays;keyboard;mice;virtual computer;ubiquitous computing systems;pervasive computing systems;cellular slime molds;Java objects;JavaBean;middleware system;simulation-based systems;Hardware;Logic gates;Software;Java;Genomics;Bioinformatics},
}

@InProceedings{Savargiv2017,
  author    = {M. {Savargiv} and E. {Nazemi} and S. {MehrMolaei}},
  booktitle = {2017 Artificial Intelligence and Robotics (IRANOPEN)},
  title     = {Improved self-management architecture in self-adaptive system},
  year      = {2017},
  month     = {April},
  pages     = {1-5},
  abstract  = {Redesigning the large and complex software systems requires very high costs time and money. Hence, automatic management and automatic adaptability with minimal human intervention is unavoidable. Self-management is the greatest level of self-adaptive which include all self-adaptive details. Scalability and dynamic analysis support in the face of change are the main challenges of self-management. Due to the fact that self-managing is relevance to the all details of self-adaptive, it is required to special type of software architecture which be able to respond to all requirements of self-adaptive aspects. In this case, dynamic architecture is the best option. Regarding to the dynamic architecture, there are diverse criteria. If software architecture be able to meet these criteria, it will know as a dynamic architecture and it has license to apply in the self-management architecture. Different types of applications can be imagined for the issue of self-management software systems, some of them are: semantic web and middle ware service, networking, load balancing in distributed systems, service communication in service oriented system, etc. In this paper self-managing dynamic architecture is discussed and evaluated and a dynamic architecture for improving the self-managing architecture is proposed.},
  doi       = {10.1109/RIOS.2017.7956435},
  file      = {:download_papers/Savargiv-2017-Improved self-management architecture in self-adaptive system.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {software architecture;software management;system monitoring;improved self-management architecture;self-adaptive system;large complex software systems;automatic management;automatic adaptability;dynamic analysis;software architecture;dynamic architecture;self-management software systems;Computer architecture;Software systems;Optimization;Computers;Service-oriented architecture;Self-adaptive;Self-management;Dynamic architecture},
}

@Article{Sawyer2012,
  author   = {P. {Sawyer} and R. {Mazo} and D. {Diaz} and C. {Salinesi} and D. {Hughes}},
  journal  = {Computer},
  title    = {Using Constraint Programming to Manage Configurations in Self-Adaptive Systems},
  year     = {2012},
  issn     = {1558-0814},
  month    = {Oct},
  number   = {10},
  pages    = {56-63},
  volume   = {45},
  abstract = {Combining goal-modeling techniques with constraint programming provides the means to identify the variants best suited to the environmental contexts that a self-adaptive software system might encounter at runtime.},
  doi      = {10.1109/MC.2012.286},
  file     = {:download_papers/Sawyer-2012-Using Constraint Programming to Manage Configurations.pdf:PDF},
  groups   = {ieee, systematic_search},
  keywords = {configuration management;constraint handling;constraint programming;configuration management;goal-modeling technique;environmental context;self-adaptive software system;Context awareness;Quality of service;Wireless sensor networks;Dynamic programming;Runtime;Constraint optimization;Adaptation models;dynamic software product lines;self-adaptive systems;goal modeling;constraint programming},
}

@InProceedings{Schall2008,
  author    = {D. {Schall} and C. {Dorn} and S. {Dustdar} and I. {Dadduzio}},
  booktitle = {2008 34th Euromicro Conference Software Engineering and Advanced Applications},
  title     = {VieCAR - Enabling Self-adaptive Collaboration Services},
  year      = {2008},
  month     = {Sep.},
  pages     = {285-292},
  abstract  = {Novel forms of collaboration increasingly distribute control among e-workers, thereby allowing agile and autonomous collaboration. However, this requires a novel blend of infrastructure and algorithms for self-adaptation of collaboration services. We present VieCAR (Vienna Collaborative Activity and Resource Management Framework), a framework that addresses the requirements of new collaborative service-oriented environments. Self-adaptive collaboration services depend on the user?s context. VieCAR combines service-oriented architectures with activity-centric computing enabling people to interact and collaborate regardless of their location and across organizational boundaries. Based on VieCAR?s activity model, we present a ranking algorithm determining the relevant input for service adaptation.},
  doi       = {10.1109/SEAA.2008.25},
  file      = {:download_papers/Schall-2008-VieCAR - Enabling Self-adaptive Collaboration Services.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2376-9505},
  keywords  = {groupware;self-adjusting systems;software architecture;VieCAR-enabling self-adaptive collaboration services;agile collaboration;autonomous collaboration;Vienna collaborative activity;resource management framework;collaborative service-oriented environment;service-oriented architecture;activity centric computing;VieCAR activity model;ranking algorithm;service adaptation;Collaboration;Collaborative work;Resource management;Web services;Collaborative software;Context;Middleware;Context-aware services;Environmental management;Software engineering;service adaptation;ranking;context-aware services;agile collaboration},
}

@InProceedings{Schmid2017,
  author    = {Schmid, Sanny and Gerostathopoulos, Ilias and Prehofer, Christian and Bures, Tomas},
  booktitle = {Proceedings of the 12th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Self-Adaptation Based on Big Data Analytics: A Model Problem and Tool},
  year      = {2017},
  month     = {May},
  pages     = {102–108},
  publisher = {IEEE Press},
  series    = {SEAMS ’17},
  abstract  = {In this paper, we focus on self-adaptation in large-scale software-intensive distributed systems. The main problem in making such systems self-adaptive is that their adaptation needs to consider the current situation in the whole system. However, developing a complete and accurate model of such systems at design time is very challenging. To address this, we present a novel approach where the system model consists only of the essential input and output parameters. Furthermore, Big Data analytics is used to guide self-adaptation based on a continuous stream of operational data. We provide a concrete model problem and a reference implementation of it that can be used as a case study for evaluating different self-adaptation techniques pertinent to complex large-scale distributed systems. We also provide an extensible tool for endorsing an arbitrary system with self-adaptation based on analysis of operational data coming from the system. To illustrate the tool, we apply it on the model problem.},
  doi       = {10.1109/SEAMS.2017.20},
  file      = {:download_papers/Schmid-2017-Self-Adaptation Based on Big Data Analytics A Model Problem.pdf:PDF},
  groups    = {acm, wiley, systematic_search},
  isbn      = {9781538615508},
  keywords  = {big data analytics, self-adaptation, model problem},
  location  = {Buenos Aires, Argentina},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1109/SEAMS.2017.20},
}

@Article{Seiger2019,
  author        = {Seiger, R. and Huber, S. and Heisig, P. and Aßmann, U.},
  journal       = {Software and Systems Modeling},
  title         = {Toward a framework for self-adaptive workflows in cyber-physical systems},
  year          = {2019},
  note          = {cited By 5},
  number        = {2},
  pages         = {1117-1134},
  volume        = {18},
  abstract      = {With the establishment of Cyber-physical Systems (CPS) and the Internet of Things, the virtual world of software and services and the physical world of objects and humans move closer together. Despite being a useful means for automation, BPM technologies and workflow systems are yet not fully capable of executing processes in CPS. The effects on and possible errors and inconsistencies in the physical world are not considered by “traditional” workflow engines. In this work we propose a framework for self-adaptive workflows in CPS based on the MAPE-K feedback loop. Within this loop monitoring and analysis of additional sensor and context data is used to check for unanticipated errors in the physical world. Planning and execution of compensation actions restores Cyber-physical Consistency, which leads to an increased resilience of the process execution environment. The framework facilitates the separation of CPS aspects from the “regular” workflow views. We show the feasibility of this approach in a smart home scenario and discuss the application of our approach for legacy BPM systems. © 2017, Springer-Verlag GmbH Germany, part of Springer Nature.},
  document_type = {Article},
  doi           = {10.1007/s10270-017-0639-0},
  file          = {:download_papers/Seiger-2019-Toward a framework for self-adaptive workflows CPS.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85035146641&doi=10.1007%2fs10270-017-0639-0&partnerID=40&md5=6307205ac7c41f7968e8d0e661daf409},
}

@InProceedings{Settanni2018,
  author        = {G. {Settanni} and F. {Skopik} and A. {Karaj} and M. {Wurzenberger} and R. {Fiedler}},
  booktitle     = {2018 IEEE Industrial Cyber-Physical Systems (ICPS)},
  title         = {Protecting cyber physical production systems using anomaly detection to enable self-adaptation},
  year          = {2018},
  month         = {May},
  note          = {cited By 10},
  pages         = {173-180},
  abstract      = {The industrial world is going through its fourth revolution also known as Industry 4.0. Modern industrial processes leverage advanced IT technologies to increase productivity and often combine multiple system concepts such as Internet of Things (IoT), Cyber Physical Systems (CPS) and Cloud Computing. Cyber Physical Production Systems (CPPS) are key enablers of this revolution. In CPPS, raw materials, machines, and operations are interconnected to form a sophisticated network. Protecting them against advanced cyber-threats is a priority concern for the future implementation of Industry 4.0 applications. Any impairment of such systems can lead, in fact, to catastrophic damages resulting in a substantial financial loss for governments, companies, as well as endanger the safety of the society. The need for high availability and reliability of these systems is therefore the pillar guiding our research. This paper proposes the adoption of anomaly detection as a method to support self-adaptation in CPPS and to ensure flexibility, reliability, and protection of industrial environments against modern cyber threats. An anomaly detection mechanism can be employed to monitor, and learn the normal behavior of an industrial system, and to generate alerts when the observed events indicate abnormal activities. On this concept we base our work, and we demonstrate how timely identifying critical security events can enable, through the self-adaptation (e.g., triggering automatic configuration changes), an efficient protection of the CPPS against advanced threats, and an effective containment of their effects.},
  document_type = {Conference Paper},
  doi           = {10.1109/ICPHYS.2018.8387655},
  file          = {:download_papers/Settanni-2018-Protecting cyber physical production systems using anomaly.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2018 IEEE Industrial Cyber-Physical Systems, ICPS 2018},
  keywords      = {cloud computing;cyber-physical systems;Internet of Things;production engineering computing;security of data;self-adjusting systems;anomaly detection mechanism;productivity;IoT;Internet of Things;CPPS self-adaptation;Industry 4.0;cyber physical production systems protection;cloud computing;industrial processes;fourth industrial revolution;financial loss;cyber-threats;Security;Monitoring;Anomaly detection;Measurement;Industries;Sensors;Planning;Cyber Physical Production Systems;Self-adaptation;Anomaly Detection;Industry 4.0},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85048920786&doi=10.1109%2fICPHYS.2018.8387655&partnerID=40&md5=3bcea84f2e3e5b473e71af5305fd0e13},
}

@InProceedings{Shafiuzzaman2015,
  author    = {M. {Shafiuzzaman} and N. {Nahar} and M. R. {Rahman}},
  booktitle = {2015 18th International Conference on Computer and Information Technology (ICCIT)},
  title     = {A proactive approach for context-aware self-adaptive mobile applications to ensure Quality of Service},
  year      = {2015},
  month     = {Dec},
  pages     = {544-549},
  abstract  = {Mobile Applications are rapidly emerging as a convenient medium for using a variety of services. With the high penetration of smart phones in society, self-adaptation has become an essential capability required by mobile application users. In an ideal scenario, an application is required to adjust its behavior according to the current context of its use. This raises the challenge in mobile computing towards the design and development of applications that sense and react to contextual changes to provide a value-added user experience. In its general sense, context information can relate to the environment, the user, or the device status. In this paper, a framework is proposed for building context aware and adaptive mobile applications. Based on the concepts of software requirement specification and probabilistic modeling, this framework guides the modeling of adaptability at design time and supports context awareness and adaptability at runtime to tackle potential issues that can hamper Quality of Service (QoS). In the core of the approach, a probabilistic model has been derived from the software requirement model using the quantitative terms of context dependability and then, it is continuously verified against the runtime operations of a mobile application. Finally, the proposed approach has been used in a mobile application development use case to observe how proactive adaptability can be built into mobile application development to ensure QoS.},
  doi       = {10.1109/ICCITechn.2015.7488131},
  file      = {:download_papers/Shafiuzzaman-2016-A proactive approach for context-aware self-adaptive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {formal specification;formal verification;Markov processes;mobile computing;probability;quality of service;smart phones;systems analysis;proactive adaptability;context-aware self-adaptive mobile application;quality of service;QoS;smart phone;mobile computing;value-added user experience;software requirement specification;probabilistic modelling;mobile application development;Markov model;Context;Mobile applications;Adaptation models;Quality of service;Batteries;Software;Runtime},
}

@InProceedings{ShanTang2016,
  author        = {{Shan Tang} and {Liping Li} and {Xiaolin Cao}},
  booktitle     = {2016 7th IEEE International Conference on Software Engineering and Service Science (ICSESS)},
  title         = {Research on building trustworthy software system by self-adaptation},
  year          = {2016},
  month         = {Aug},
  note          = {cited By 0},
  pages         = {1068-1071},
  volume        = {0},
  abstract      = {The execution context of today's software systems changes continually, which makes systems have to cope with changing environments while at the same time facing high non-functional requirements such as flexibility and dependability. Runtime adaptation technology can modify behaviors and structures in response to changes in the system itself or in its environment and thus improve dependability at run time. This leads to a more flexible and effective way to build dependable software system. However, current works address adaptation often remain a neglected gap between the architecture model and the system state. To solve this problem, we present a systematic process that covers requirements modeling, architecture and system modeling of trustworthy software based on a runtime self-adaptation perspective.},
  art_number    = {7883250},
  document_type = {Conference Paper},
  doi           = {10.1109/ICSESS.2016.7883250},
  file          = {:download_papers/Tang-2016-Research on building trustworthy software system by self-adaptation.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2327-0594},
  journal       = {Proceedings of the IEEE International Conference on Software Engineering and Service Sciences, ICSESS},
  keywords      = {formal specification;software architecture;trusted computing;trustworthy software system;nonfunctional requirements;runtime adaptation technology;systematic process;requirements modeling;runtime self-adaptation perspective;architecture model;Adaptation models;Systems modeling;Multimedia communication;reliable requirements;goal;software architecture;self-adaptation;runtime system},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85017010097&doi=10.1109%2fICSESS.2016.7883250&partnerID=40&md5=e8fe29b5174c0d841f861387af875666},
}

@InProceedings{Sharifloo2015,
  author    = {Sharifloo, Amir Molzam},
  booktitle = {Proceedings of the 2015 European Conference on Software Architecture Workshops},
  title     = {Models for Self-Adaptive Systems},
  year      = {2015},
  address   = {New York, NY, USA},
  publisher = {Association for Computing Machinery},
  series    = {ECSAW ’15},
  abstract  = {Developing self-adaptive systems has been an active research area of software engineering in the last decade. Models are so essential in building these systems that stretch their applications from design time to run time. This paper focuses on the roles of models and the relationships among them in self-adaptive systems. It classifies the types of models often required, and points out the research gaps for future investigation.},
  articleno = {24},
  doi       = {10.1145/2797433.2797457},
  file      = {:download_papers/Sharifloo-2015-Models for Self-Adaptive Systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450333931},
  keywords  = {Self-adaptive systems, Models},
  location  = {Dubrovnik, Cavtat, Croatia},
  numpages  = {5},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2797433.2797457},
}

@InProceedings{Shen2012a,
  author    = {L. {Shen} and X. {Peng} and W. {Zhao}},
  booktitle = {2012 IEEE 36th Annual Computer Software and Applications Conference},
  title     = {Quality-Driven Self-Adaptation: Bridging the Gap between Requirements and Runtime Architecture by Design Decision},
  year      = {2012},
  month     = {July},
  pages     = {185-194},
  abstract  = {Running with static requirements and design decisions, a software system cannot always perform optimally in a highly uncertain and rapidly changing environment. Quality-driven self-adaptation, which enables a software system to continually adapt its structure and behavior to improve the overall quality satisfaction, thus becomes a promising capability of software systems. Existing researches on self-adaptive systems, although having proposed effective methods and techniques on requirements-driven self-adaptation and reflective components, do not well address the gap between requirements and runtime architecture. In this paper, we propose a quality-driven self-adaptation approach, which incorporates both requirements- and architecture-level adaptations. At the requirements level, value-based quality tradeoff decisions are made with the aim of maximizing system-level value propositions. At the architecture level, component-based architecture adaptations are conducted. To bridge the gap between requirements and runtime architecture, design decisions capturing alternative design options and their rationales are introduced to help map requirements adaptations and context changes to adaptation operations on the runtime architecture. To validate the effectiveness, we implement the approach based on a reflective component model and conduct an experimental study on it. The results show that the approach leads to better performance compared with traditional software and the overall quality satisfaction is kept maintained. Furthermore, the development effort is affordable but the approach still has shortage in extensibility.},
  doi       = {10.1109/COMPSAC.2012.29},
  file      = {:download_papers/Shen-2012-Quality-Driven Self-Adaptation Bridging the Gap between Requirements.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {software quality;quality driven self-adaptation;runtime architecture;requirements architecture;design decision;static requirements;software system;architecture level adaptations;component based architecture adaptations;Adaptation models;Runtime;Computer architecture;Decision trees;Context;Algorithm design and analysis;Fractals;self-adaptation;requirements;reflective component reconfiguration;design decision},
}

@InProceedings{Shevtsov2016,
  author    = {Shevtsov, Stepan and Weyns, Danny},
  booktitle = {Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
  title     = {Keep It SIMPLEX: Satisfying Multiple Goals with Guarantees in Control-Based Self-Adaptive Systems},
  year      = {2016},
  address   = {New York, NY, USA},
  pages     = {229–241},
  publisher = {Association for Computing Machinery},
  series    = {FSE 2016},
  abstract  = {An increasingly important concern of software engineers is handling uncertainties at design time, such as environment dynamics that may be difficult to predict or requirements that may change during operation. The idea of self-adaptation is to handle such uncertainties at runtime, when the knowledge becomes available. As more systems with strict requirements require self-adaptation, providing guarantees for adaptation has become a high-priority. Providing such guarantees with traditional architecture-based approaches has shown to be challenging. In response, researchers have studied the application of control theory to realize self-adaptation. However, existing control-theoretic approaches applied to adapt software systems have primarily focused on satisfying only a single adaptation goal at a time, which is often too restrictive for real applications. In this paper, we present Simplex Control Adaptation, SimCA, a new approach to self-adaptation that satisfies multiple goals, while being optimal with respect to an additional goal. SimCA offers robustness to measurement inaccuracy and environmental disturbances, and provides guarantees. We evaluate SimCA for two systems with strict requirements that have to deal with uncertainties: an underwater vehicle system used for oceanic surveillance, and a tele-assistance system for health care support.},
  doi       = {10.1145/2950290.2950301},
  file      = {:download_papers/Shevtsov-2016-Keep it SIMPLEX satisfying multiple goals with guarantees.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450342186},
  keywords  = {simplex, multiple goals, control theory, Self-adaptive system},
  location  = {Seattle, WA, USA},
  numpages  = {13},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2950290.2950301},
}

@InProceedings{Shevtsov2016a,
  author        = {Shevtsov, Stepan},
  booktitle     = {Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
  title         = {Developing a Reusable Control-Based Approach to Build Self-Adaptive Software Systems with Formal Guarantees},
  year          = {2016},
  address       = {New York, NY, USA},
  note          = {cited By 1},
  pages         = {1060–1062},
  publisher     = {Association for Computing Machinery},
  series        = {FSE 2016},
  volume        = {13-18-November-2016},
  abstract      = {An increasingly important concern of software engineers is handling uncertainty at runtime. Over the last decade researchers have applied architecture-based self-Adaptation approaches to address this concern. However, providing guarantees required by current software systems has shown to be challenging with these approaches. To tackle this challenge, we study the application of control theory to realize self-Adaptation and develop novel control-based adaptation mechanisms that guarantee desired system properties. Results are validated on systems with strict requirements. © 2016 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/2950290.2983949},
  file          = {:download_papers/Shevtsov-2016-Developing a reusable control-based approach to build.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450342186},
  journal       = {Proceedings of the ACM SIGSOFT Symposium on the Foundations of Software Engineering},
  keywords      = {software, self-adaptive, control theory, guarantees},
  location      = {Seattle, WA, USA},
  numpages      = {3},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2950290.2983949},
}

@InProceedings{Shevtsov2017,
  author    = {S. {Shevtsov} and D. {Weyns} and M. {Maggio}},
  booktitle = {2017 IEEE/ACM 12th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Handling New and Changing Requirements with Guarantees in Self-Adaptive Systems Using SimCA},
  year      = {2017},
  month     = {May},
  pages     = {12-23},
  abstract  = {Self-adaptation provides a principled way to deal with change during operation. As more systems with strict goals require self-adaptation, the need for guarantees in self-adaptive systems is becoming a high-priority concern. Designing adaptive software using principles from control theory has been identified as one of the approaches to provide guarantees. However, current solutions can only handle pre-specified requirements either in the form of setpoint values (S-reqs) or values to be optimized (O-reqs). This paper presents SimCA* that makes two contributions to control-based self-adaptation: (a) it allows the user to specify a third type of requirement that keeps a value above/below a threshold (T-reqs), and (b) it can deal with requirement sets that change at runtime (i.e., requirements can be adjusted, activated, and deactivated on the fly). SimCA* offers robustness to disturbances and provides adaptation guarantees. We evaluate SimCA* for two systems with strict goals from different domains: an underwater vehicle system used for oceanic surveillance, and a tele-assistance system for health care support. The test results demonstrate that SimCA* can deal with the three types of requirements (STO-reqs) operating under various types of dynamics and the set of requirements can be changed on the fly.},
  doi       = {10.1109/SEAMS.2017.3},
  file      = {:download_papers/Shevtsov-2017-Handling New and Changing Requirements with Guarantees.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {data flow analysis;formal specification;formal verification;optimisation;self-adjusting systems;software fault tolerance;systems analysis;requirements;self-adaptive systems;SimCA;adaptive software design;control theory;values optimization;system runtime;Software;Sensors;Control theory;Runtime;Surveillance;Stakeholders;Time factors;self-adaptation;control theory;software;SimCA},
}

@Article{Shevtsov2019,
  author     = {Shevtsov, Stepan and Weyns, Danny and Maggio, Martina},
  journal    = {ACM Trans. Auton. Adapt. Syst.},
  title      = {SimCA*: A Control-Theoretic Approach to Handle Uncertainty in Self-Adaptive Systems with Guarantees},
  year       = {2019},
  issn       = {1556-4665},
  month      = jul,
  number     = {4},
  volume     = {13},
  abstract   = {Self-adaptation provides a principled way to deal with software systems’ uncertainty during operation. Examples of such uncertainties are disturbances in the environment, variations in sensor readings, and changes in user requirements. As more systems with strict goals require self-adaptation, the need for formal guarantees in self-adaptive systems is becoming a high-priority concern. Designing self-adaptive software using principles from control theory has been identified as one of the approaches to provide guarantees. In general, self-adaptation covers a wide range of approaches to maintain system requirements under uncertainty, ranging from dynamic adaptation of system parameters to runtime architectural reconfiguration. Existing control-theoretic approaches have mainly focused on handling requirements in the form of setpoint values or as quantities to be optimized. Furthermore, existing research primarily focuses on handling uncertainty in the execution environment. This article presents SimCA*, which provides two contributions to the state-of-the-art in control-theoretic adaptation: (i) it supports requirements that keep a value above and below a required threshold, in addition to setpoint and optimization requirements; and (ii) it deals with uncertainty in system parameters, component interactions, system requirements, in addition to uncertainty in the environment. SimCA* provides guarantees for the three types of requirements of the system that is subject to different types of uncertainties. We evaluate SimCA* for two systems with strict requirements from different domains: an Unmanned Underwater Vehicle system used for oceanic surveillance and an Internet of Things application for monitoring a geographical area. The test results confirm that SimCA* can satisfy the three types of requirements in the presence of different types of uncertainty.},
  address    = {New York, NY, USA},
  articleno  = {17},
  doi        = {10.1145/3328730},
  file       = {:download_papers/Shevtsov-2019-SimCA A Control-theoretic Approach to Handle Uncertainty.pdf:PDF},
  groups     = {acm, systematic_search},
  issue_date = {July 2019},
  keywords   = {self-adaptation, control theory, SimCA*, UUV, Software, IoT, uncertainty},
  numpages   = {34},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/3328730},
}

@Book{Shevtsov2019a,
  author        = {Shevtsov, S. and Weyns, D. and Maggio, M.},
  title         = {Self-adaptation of software using automatically generated control-theoretical solutions},
  year          = {2019},
  note          = {cited By 1},
  abstract      = {Control theory has contributed a set of foundational techniques to handle "change" at runtime in software applications. These techniques however have fundamental limitations as well: (i) they require the development and understanding of mathematical models; (ii) synthesizing solutions is often done on a per-problem basis, discouraging flexibility and generality. Software engineering, as a discipline, has always aimed at finding reusable and modular solutions. The combination of the desire to apply formally grounded control-theoretical principles and reuse existing solutions has motivated research on the topic of automatically generated control solutions. This research aims at designing control strategies in an automated way from data that qualifies the given problem at hand. This chapter provides an overview of the research topic of automatically generated control-theoretical solutions, explaining the key research contributions and paving the way for future research. © Springer Nature Singapore Pte Ltd. 2019. All Rights reserved.},
  document_type = {Book Chapter},
  doi           = {10.1007/978-981-13-2185-6_2},
  file          = {:download_papers/Shevtsov-2019-Self-adaptation of software using automatically.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Engineering adaptive software systems: Communications of nii shonan meetings},
  pages         = {35-55},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85078198507&doi=10.1007%2f978-981-13-2185-6_2&partnerID=40&md5=5d45aa59e7707e530add43ef907ee199},
}

@InProceedings{Shin2019,
  author    = {Shin, Yong-Jun and Baek, Young-Min and Jee, Eunkyoung and Bae, Doo-Hwan},
  booktitle = {Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing},
  title     = {Data-Driven Environment Modeling for Adaptive System-of-Systems},
  year      = {2019},
  address   = {New York, NY, USA},
  pages     = {2044–2047},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’19},
  abstract  = {Since a System-of-Systems (SoS) is constructed and managed under a complex and dynamic environment, self-adaptability has become one of the key capabilities that SoSs should have. To design an adaptive SoS, analyzing and modeling the environment are important. Studies on self-adaptive systems (SAS) have proposed various analysis and design approaches to deal with dynamic environment and operating conditions. However, most existing approaches require a considerable amount of domain experts' knowledge about the operating environment without specific and practical guidelines, so there still remain many challenges for engineers to analyze and design an adaptive SoS. In this study, we propose a data-driven method of generating environment models for adaptive SoS. To guide the analysis and understanding of the environment, we propose a metamodel that encompasses characteristics of the dynamic environment. Based on the metamodel, an environment model is generated from historical data for effective analysis of the SoS's complex environment. As a case study, we apply our method to a traffic environment modeling with real data. We show that our proposed method can practically help engineers generate environment models with concrete features that are necessary for adaptive SoS modeling by considering the environment as a major entity for SAS analysis and design.},
  doi       = {10.1145/3297280.3297618},
  file      = {:download_papers/Shin-2019-Data-driven environment modeling for adaptive system-of-systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450359337},
  keywords  = {adaptive system-of-systems, data-driven analysis, environment modeling, modeling methodology, smart traffic system, self-adaptive system},
  location  = {Limassol, Cyprus},
  numpages  = {4},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3297280.3297618},
}

@InProceedings{Silva2018,
  author    = {da Silva, Jo\~{a}o Pablo S. and Ecar, Miguel and Pimenta, Marcelo S. and Kepler, Fabio Natanael and Guedes, Gilleanes T. A. and Betemps, Carlos Michel},
  booktitle = {Proceedings of the 33rd Annual ACM Symposium on Applied Computing},
  title     = {Improving Self-Adaptive Systems Conceptual Modeling},
  year      = {2018},
  address   = {New York, NY, USA},
  pages     = {1292–1299},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’18},
  abstract  = {Self-adaptive Systems (SaSs) operate under uncertainty conditions and have intrinsic properties that have posed some challenges for requirements analysis. Conceptual modeling is useful to requirements analysis because it aids to understand the situation in which a problem occurs. SaSs conceptual modeling is a non-trivial activity because it is necessary to deal with requirements uncertainty, contextual changes, and behavior adaptation. Since conceptual models are built by humans, their quality heavily depends on the humans expertise, which is not a good software engineering practice. Regarding SaSs, the exposure to quality risks increases because of intrinsic characteristic in this class of system. In this paper, we present a SaSs conceptual modeling approach composed of a metamodel and a modeling process. The process defines how to instantiate the metamodel from requirements specifications to create SaSs conceptual models. We performed a controlled experiment with subjects to evaluate our modeling approach effectiveness. As the outcome, we found that our approach had a better performance than an ad hoc approach. The contribution of this paper is a well-defined approach for guiding SaSs conceptual modeling, supported by evidence of its effectiveness by means of an empirical experiment.},
  doi       = {10.1145/3167132.3167271},
  file      = {:download_papers/Silva-2018-Improving self-adaptive systems conceptual modeling.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450351911},
  keywords  = {requirements analysis, empirical experiment, self-adaptive system, conceptual modeling},
  location  = {Pau, France},
  numpages  = {8},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3167132.3167271},
}

@InProceedings{Solano2019,
  author    = {Solano, Gabriela F\'{e}lix and Caldas, Ricardo Diniz and Rodrigues, Gena\'{\i}na Nunes and Vogel, Thomas and Pelliccione, Patrizio},
  booktitle = {Proceedings of the 14th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Taming Uncertainty in the Assurance Process of Self-Adaptive Systems: A Goal-Oriented Approach},
  year      = {2019},
  pages     = {89–99},
  publisher = {IEEE Press},
  series    = {SEAMS ’19},
  abstract  = {Goals are first-class entities in a self-adaptive system (SAS) as they guide the self-adaptation. A SAS often operates in dynamic and partially unknown environments, which cause uncertainty that the SAS has to address to achieve its goals. Moreover, besides the environment, other classes of uncertainty have been identified. However, these various classes and their sources are not systematically addressed by current approaches throughout the life cycle of the SAS. In general, uncertainty typically makes the assurance provision of SAS goals exclusively at design time not viable. This calls for an assurance process that spans the whole life cycle of the SAS. In this work, we propose a goal-oriented assurance process that supports taming different sources (within different classes) of uncertainty from defining the goals at design time to performing self-adaptation at runtime. Based on a goal model augmented with uncertainty annotations, we automatically generate parametric symbolic formulae with parameterized uncertainties at design time using symbolic model checking. These formulae and the goal model guide the synthesis of adaptation policies by engineers. At runtime, the generated formulae are evaluated to resolve the uncertainty and to steer the self-adaptation using the policies. In this paper, we focus on reliability and cost properties, for which we evaluate our approach on the Body Sensor Network (BSN) implemented in OpenDaVINCI. The results of the validation are promising and show that our approach is able to systematically tame multiple classes of uncertainty, and that it is effective and efficient in providing assurances for the goals of self-adaptive systems.},
  doi       = {10.1109/SEAMS.2019.00020},
  file      = {:download_papers/Solano-2019-Taming Uncertainty in the Assurance Process of Self-Adaptive Systems.pdf:PDF},
  groups    = {acm, systematic_search},
  keywords  = {adaptation policy, self-adaptive systems, goal modeling, uncertainty, symbolic model checking},
  location  = {Montreal, Quebec, Canada},
  numpages  = {11},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1109/SEAMS.2019.00020},
}

@Article{Son2015,
  author   = {Yunsik Son and Jin-Woo Jung},
  journal  = {Procedia Computer Science},
  title    = {Self-Management Technique for Adaptive Robot Software based on Task Environment Similarity},
  year     = {2015},
  issn     = {1877-0509},
  note     = {The 10th International Conference on Future Networks and Communications (FNC 2015) / The 12th International Conference on Mobile Systems and Pervasive Computing (MobiSPC 2015) Affiliated Workshops},
  pages    = {538 - 543},
  volume   = {56},
  abstract = {In this paper, we propose a novel method by which the robot can choose the most suitable software module for the given task based on the evaluation of task environment, and the resulting relationship between the environmental information and robot software module is managed by the robot itself. In addition, the performance of the robot can be improved through the update process of the E-S(Environment-S/W module) relationship information when the new environmental information or new robot software modules are given. The effectiveness of the proposed self-management technique is shown by the experiments with 70 random maps, which shows the improvement of performance as the task continues to proceed.},
  doi      = {https://doi.org/10.1016/j.procs.2015.07.248},
  file     = {:download_papers/Son-2015-Self-Management Technique for Adaptive Robot Software based.pdf:PDF},
  groups   = {sciencedirect, systematic_search},
  keywords = {Self-Update of Software Modules, Environment-S/W Module Relationship Information, Similarity of Task Environments, Adaptive Robot Software Framework.},
  url      = {http://www.sciencedirect.com/science/article/pii/S1877050915017299},
}

@InProceedings{Stavru2011,
  author        = {Stavru, Stavros},
  booktitle     = {Proceedings of the 12th International Conference on Computer Systems and Technologies},
  title         = {Managing Change in Self-Adaptive Software Systems},
  year          = {2011},
  address       = {New York, NY, USA},
  note          = {cited By 1},
  pages         = {647–652},
  publisher     = {Association for Computing Machinery},
  series        = {CompSysTech ’11},
  volume        = {578},
  abstract      = {Self-adaptive software systems are expected to deal with change during their execution with limited or no human interaction. Therefore a better understanding of change and how it could be managed is a crucial step for achieving self-adaptation. Most of the research in self-adaptive software systems is focused on managing change, which is critical for the system in terms of sustaining its efficiency and operation. The work in this paper takes new direction and introduces the idea of exploratory change, heavily used in many other disciplines to successfully achieve self-adaptation. It proposes a new classification model of change in self-adaptive software systems, which extends the existing taxonomies in the research literature with five new criteria: change motif, change trigger, change adoption, change frequency and change speed. The purpose of this classification model is to aid the distinction between three different approaches for self-adaptation: exploitative, exploratory and mixed approaches. © 2011 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/2023607.2023715},
  file          = {:download_papers/Stavru-2011-Managing change in self-adaptive software systems.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450309172},
  journal       = {ACM International Conference Proceeding Series},
  keywords      = {evolutionary biology, self-adaptive software systems, strategic management},
  location      = {Vienna, Austria},
  numpages      = {6},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2023607.2023715},
}

@InProceedings{Stein2016,
  author    = {A. {Stein} and S. {Tomforde} and D. {Rauh} and J. {H?hner}},
  booktitle = {2016 IEEE International Conference on Autonomic Computing (ICAC)},
  title     = {Dealing with Unforeseen Situations in the Context of Self-Adaptive Urban Traffic Control: How to Bridge the Gap},
  year      = {2016},
  month     = {July},
  pages     = {167-172},
  abstract  = {Autonomously adapting signalling strategies to changing traffic demands in urban areas have been frequently used as application scenario for self-organising systems in general as well as for Autonomic or Organic Computing systems in particular. The Organic Traffic Control (OTC) system is one of the most prominent representatives in this domain. OTC implements a multi-layered Observer/Controller (O/C) architecture and utilises a strongly modified eXtended Classifier System (XCSO/C) for the task of self-adaptation. In this paper, we extend the algorithmic structure of XCS-O/C by a novel interpolation-based approach that incorporates existing knowledge beyond the traditional means. We demonstrate the benefit of the developed approach in terms of reduced delay times for near-to-reality simulations of realistic traffic conditions from Hamburg, Germany.},
  doi       = {10.1109/ICAC.2016.20},
  file      = {:download_papers/Stein-2016-Dealing with Unforeseen Situations in the Context of Self-Adaptive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive control;control engineering computing;interpolation;learning (artificial intelligence);observers;pattern classification;road traffic control;self-adjusting systems;software fault tolerance;traffic engineering computing;self-adaptive urban traffic control;self-organizing system;autonomic computing;organic computing;organic traffic control system;OTC system;observer/controller architecture;O/C architecture;extended classifier system;XCSO/C;on-line learning system;interpolation-based approach;Interpolation;Delays;Context;Urban areas;Control systems;Complexity theory;Aerospace electronics;Organic Computing;Self-Adaptation;Learning Classifier Systems;Inverse Distance Weighting;Urban Traffic Control},
}

@InProceedings{Sum-Im2012,
  author    = {T. {Sum-Im}},
  booktitle = {2012 47th International Universities Power Engineering Conference (UPEC)},
  title     = {A self-adaptive differential evolution algorithm for dynamic economic dispatch with valve-point effects},
  year      = {2012},
  month     = {Sep.},
  pages     = {1-6},
  abstract  = {In this paper, a self-adaptive differential evolution algorithm (SaDEA) is proposed for solving dynamic economic dispatch (DED) problem with valve-point effects consideration. The purpose of DED problem is to minimize the total generation costs of thermal power plants associated with the technical and economical constraints. The software development has been performed within the mathematical programming environment of MATLAB in this work. The efficiency and effectiveness of the proposed technique is initially demonstrated via the analysis of 3-unit and 10-unit test systems considering valve-point loading and ramp rate constraints. A detailed comparative study among an evolutionary programming (EP), a particle swarm optimization (PSO), an enhanced particle swarm optimization (EPSO), an enhanced particle swarm optimization with Gaussian mutation (EPSO-GM), a hybrid method between evolutionary programming and sequential quadratic programming (EP-SQP), a modified hybrid EP-SQP (MHEP-SQP) and the proposed method is presented. From the experimental results, the proposed method has the achieved solutions with good accuracy, stable convergence characteristics, simple implementation and satisfactory computational time.},
  doi       = {10.1109/UPEC.2012.6398551},
  file      = {:download_papers/Sum-Im-2012-A self-adaptive differential evolution algorithm for dynamic.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {evolutionary computation;particle swarm optimisation;power generation dispatch;power generation economics;quadratic programming;thermal power stations;self-adaptive differential evolution algorithm;dynamic economic dispatch;valve-point effects;SaDEA;DED problem;total generation costs;thermal power plants;Matlab;mathematical programming environment;unit test systems;ramp rate constraints;evolutionary programming;particle swarm optimization;PSO;enhanced particle swarm optimization;EPSO;enhanced particle swarm optimization with Gaussian mutation;EPSO-GM;sequential quadratic programming;modified hybrid EP-SQP method;Vectors;Generators;Sociology;Statistics;Heuristic algorithms;Cost function;Power generation;dynamic economic dispatch;self-adaptive differential evolution algorithm},
}

@InProceedings{Suwardi2015,
  author    = {I. S. {Suwardi} and {Aradea}},
  booktitle = {2015 2nd International Conference on Advanced Informatics: Concepts, Theory and Applications (ICAICTA)},
  title     = {Automatically relation modeling on spatial relationship as self-adaptation ability},
  year      = {2015},
  month     = {Aug},
  pages     = {1-6},
  abstract  = {Self-adaptive system is a system that can take proper action automatically to reach its goal, based on the situation which occur at this system environment to meet satisfactory of its users. This paper would illustrate a case about self-adaptation function requirement in application tools that correspond to the requirement of graphic element adjustment function. One of the problems that can arise are related to connectivity function graphic elements, wherein when graphic elements associated with other graphic elements, elements of the relationship between the graphic elements can occupy the working area irregularly, even if there are other graphic elements that block the path relations, the relation element can penetrate into that graphic element. This condition has to rearrange by a user manually, so it is quite difficult and time consuming. Strategy that needed to overcome that problems, which must guarantee the availability of areas as working environment, as well as the appropriate decision-making mechanisms when determining an alternative option to connect between elements graphic automatically as self-adaptation ability. The solution for this problem, we propose strategy to automate relation space management of graphic element, as a result of an adaptation mechanism which more flexible and simplify users to do the job. Core concept that developed consist of two approaches namely free space management and neighbourhood modeling. These both concepts realised to polish up adaptation ability from tools limitation that exists at the current time.},
  doi       = {10.1109/ICAICTA.2015.7335356},
  file      = {:download_papers/Suwardi-2015-Automatically relation modeling on spatial relationship.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {computer graphics;decision making;software engineering;neighbourhood modeling;free space management;decision-making mechanism;connectivity function graphic elements;graphic element adjustment function;self-adaptation function requirement;self-adaptive system;relation modeling;spatial relationship;self-adaptation ability;Adaptation models;Graphics;Synthetic aperture sonar;Automation;Connectors;Planning;Software;automatic link modeling;spatial relationship;self-adaptation;free space management;neighbourhood modeling},
}

@InProceedings{Svae2017,
  author        = {Svae, Alexander and Taherkordi, Amir and Herrmann, Peter and Blech, Jan Olaf},
  booktitle     = {Proceedings of the Symposium on Applied Computing},
  title         = {Self-Adaptive Control in Cyber-Physical Systems: The Autonomous Train Experiment},
  year          = {2017},
  address       = {New York, NY, USA},
  note          = {cited By 1},
  pages         = {1436–1443},
  publisher     = {Association for Computing Machinery},
  series        = {SAC ’17},
  volume        = {Part F128005},
  abstract      = {Autonomous systems have become more and more important in today's transport sector. They often operate in dynamic environments in which unpredictable events may occur at any time. These events may affect the safe operation of vehicles, calling for highly efficient control software technologies to reason about and react on their appearance. A crucial efficiency parameter is timeliness as vehicles often operate under high speed. The contribution of this paper is the presentation and analysis of design aspects of dynamic control software in the context of an autonomous train experiment. This is achieved through a self-adaptation software framework intended for autonomous trains and built on a demonstrator using Lego Mindstorms. The main mission of the framework is to collect context information, reason about it, and adapt the train behavior accordingly. The adaptation framework is implemented using the development tool Reactive Blocks and tested on the demonstrator. The evaluation results provide useful insights into the performance of the framework, particularly about the time needed to reason about the context and to carry out reconfigurations. Copyright 2017 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/3019612.3019651},
  file          = {:download_papers/Svae-2017-Self-adaptive control in cyber-physical systems the autonomous.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450344869},
  journal       = {Proceedings of the ACM Symposium on Applied Computing},
  keywords      = {timeliness, cyber-physical systems, autonomous trains, self-adaptation},
  location      = {Marrakech, Morocco},
  numpages      = {8},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/3019612.3019651},
}

@InProceedings{Sykes2007,
  author    = {Sykes, Daniel and Heaven, William and Magee, Jeff and Kramer, Jeff},
  booktitle = {Proceedings of the 2007 Conference on Specification and Verification of Component-Based Systems: 6th Joint Meeting of the European Conference on Software Engineering and the ACM SIGSOFT Symposium on the Foundations of Software Engineering},
  title     = {Plan-Directed Architectural Change for Autonomous Systems},
  year      = {2007},
  address   = {New York, NY, USA},
  pages     = {15–21},
  publisher = {Association for Computing Machinery},
  series    = {SAVCBS ’07},
  abstract  = {Autonomous systems operate in an unpredictable world, where communication with those people responsible for its software architecture may be infrequent or undesirable. If such a system is to continue reliable operation it must be able to derive and initiate adaptations to new circumstances on its own behalf. Much of the previous work on dynamic reconfigurations supposes that the programmer is able to express the possible adaptations before the system is deployed, or at least is able to add new adaptation strategies after deployment. We consider the challenges in providing an autonomous system with the capability to direct its own adaptation, and describe an initial implementation where change in the software architecture of an autonomous system is enacted as a result of executing a reactive plan.},
  doi       = {10.1145/1292316.1292318},
  file      = {:download_papers/Sykes-2007-Plan-directed architectural change for autonomous systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781595937216},
  keywords  = {software architecture, self-adaptive, autonomous systems, self-healing, dynamic reconfiguration},
  location  = {Dubrovnik, Croatia},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1292316.1292318},
}

@InProceedings{Tamura2013,
  author    = {G. {Tamura} and N. M. {Villegas} and H. A. {Muller} and L. {Duchien} and L. {Seinturier}},
  booktitle = {2013 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Improving context-awareness in self-adaptation using the DYNAMICO reference model},
  year      = {2013},
  month     = {May},
  pages     = {153-162},
  abstract  = {Self-adaptation mechanisms modify target systems dynamically to address adaptation goals, which may evolve continuously due to changes in system requirements. These changes affect values and thresholds of observed context variables and monitoring logic, or imply the addition and/or deletion of context variables, thus compromising self-adaptivity effectiveness under static monitoring infrastructures. Nevertheless, self-adaptation approaches often focus on adapting target systems only rather than monitoring infrastructures. Previously, we proposed DYNAMICO, a reference model for self-adaptive systems where adaptation goals and monitoring requirements change dynamically. This paper presents an implementation of DYNAMICO comprising our SMARTERCONTEXT monitoring infrastructure and QoS-CARE adaptation framework in a self-adaptation solution that maintains its context-awareness relevance. To evaluate our reference model we use self-adaptive system properties and the Znn.com exemplar to compare the Rainbow system with our DYNAMICO implementation. The results of the evaluation demonstrate the applicability, feasibility, and effectiveness of DYNAMICO, especially for self-adaptive systems with context-awareness requirements.},
  doi       = {10.1109/SEAMS.2013.6595502},
  file      = {:download_papers/Tamura-2013-Improving context-awareness in self-adaptation using the DYNAMICO.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2321},
  keywords  = {service-oriented architecture;ubiquitous computing;DYNAMICO reference model;self-adaptation mechanism;adaptation goal;SMARTERCONTEXT monitoring infrastructure;QoS-CARE adaptation framework;context-awareness relevance;self-adaptive system property;Rainbow system;dynamic adaptation monitoring and control objectives model;dynamic SOA governance;service-oriented architecture;QoS contract-aware reconfiguration system;quality of service;Znn.com exemplar;Monitoring;Context;Quality of service;Feedback loop;Adaptation models;Runtime;Synthetic aperture sonar},
}

@InProceedings{Tanabe2017,
  author    = {Tanabe, Moeka and Tei, Kenji and Fukazawa, Yoshiaki and Honiden, Shinichi},
  booktitle = {Proceedings of the Symposium on Applied Computing},
  title     = {Learning Environment Model at Runtime for Self-Adaptive Systems},
  year      = {2017},
  address   = {New York, NY, USA},
  pages     = {1198–1204},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’17},
  abstract  = {Self-adaptive systems alter their behavior in response to environmental changes to continually satisfy their requirements. Self-adaptive systems employ an environment model, which should be updated during runtime to maintain consistency with the real environment. Although some techniques have been proposed to learn environment model based on execution traces at the design time, these techniques are time consuming and consequently inappropriate for runtime learning. Herein, a technique using a stochastic gradient descent and the difference in the data acquired during the runtime is proposed as an efficient learning environment model. The computational time and accuracy of our technique are verified through study.},
  doi       = {10.1145/3019612.3019776},
  file      = {:download_papers/Tanabe-2017-Learning environment model at runtime for self-adaptive systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450344869},
  keywords  = {self-adaptive, learning, gradient descent},
  location  = {Marrakech, Morocco},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3019612.3019776},
}

@InProceedings{Tang2013,
  author        = {S. {Tang} and Q. {Liu}},
  booktitle     = {2013 IEEE 37th Annual Computer Software and Applications Conference},
  title         = {Supporting Integration of COTS Components from a Perspective of Self-Adaptive Software Architecture},
  year          = {2013},
  month         = {July},
  note          = {cited By 0},
  pages         = {706-713},
  abstract      = {Component-Based Software Development (CBSD) provides a high efficient and low cost way to construct software systems by integrating reusable software components. Although CBSD has already become a widely accepted paradigm, it is still beyond possibility to assemble components easily from commercial-off-the-shelf (COTS) components into one application system. A variety of mismatches between components often impede the integration of COTS components, and component adaptation is becoming a key problem in Component-Based Software Engineering (CBSE). Aiming at this requirement, this paper presents a self-adaptive software architecture (model-based) approach for supporting seamless integration of COTS components. Specifically, we first propose a self-adaptive software architecture model, and then we discuss and exemplify how to eliminate the mismatches between heterogeneous COTS components based on this model. A simplified on-line shopping system is referred throughout the paper to illustrate our approach.},
  art_number    = {6649901},
  document_type = {Conference Paper},
  doi           = {10.1109/COMPSAC.2013.112},
  file          = {:download_papers/Tang-2013-Supporting Integration of COTS Components.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {0730-3157},
  journal       = {Proceedings - International Computer Software and Applications Conference},
  keywords      = {object-oriented programming;software architecture;software reusability;COTS components;self-adaptive software architecture model;component-based software development;CBSD;software systems;reusable software components;commercial-off-the-shelf components;component-based software engineering;CBSE;simplified on-line shopping system;Ports (Computers);Connectors;Software;Protocols;Semantics;Adaptation models;Ontologies;COTS components;behavioral protocol;adaptor;port;semantic},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84891287312&doi=10.1109%2fCOMPSAC.2013.112&partnerID=40&md5=af29732c719d83d668502ffdb2f278f5},
}

@InProceedings{Tang2015,
  author    = {S. {Tang} and L. {Li} and X. {Cao} and W. {Tan}},
  booktitle = {2015 6th IEEE International Conference on Software Engineering and Service Science (ICSESS)},
  title     = {Bridging the gap between requirement analysis and architecture design of self-adaptive systems},
  year      = {2015},
  month     = {Sep.},
  pages     = {1102-1105},
  abstract  = {Modern software systems often run on a changing and unpredictable environment, they need to adapt itself at runtime in response to changing requirements of users and running environment. Therefore, numerous methods have been proposed to support the development of self-adaptive system. Some approaches are requirements-based. Other approaches are architecture-based. By considering only a partial view of software systems, such proposals are limited in specifying the adaptivity of a software system. Aiming at this problem, this paper will discuss how to bridge the gap between the requirement analysis and architecture design of self-adaptive systems.},
  doi       = {10.1109/ICSESS.2015.7339244},
  file      = {:download_papers/Tang-2015-Bridging the gap between requirement analysis and architecture design.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2327-0594},
  keywords  = {formal specification;software architecture;requirement analysis;architecture design;self-adaptive systems;software system adaptivity specification;users requirements;running environment;requirements-based approach;architecture-based approach;Adaptation models;Runtime;Software systems;Monitoring;Computer architecture;Analytical models;self-adaptive system;goal model;requirement model;software architecture model;MAPE-K control loop},
}

@InProceedings{Tang2016,
  author    = {Z. {Tang} and Y. {Guo} and X. {Chen}},
  booktitle = {2016 IEEE 40th Annual Computer Software and Applications Conference (COMPSAC)},
  title     = {Self-Adaptive Step Counting on Smartphones under Unrestricted Stepping Modes},
  year      = {2016},
  month     = {June},
  pages     = {788-797},
  volume    = {1},
  abstract  = {Pedometer apps on smartphones and wearable electronics are increasingly popular nowadays, as they are widely used for health monitoring and location-based systems. Most pedometer apps are based on inertial sensors and each step counting algorithm works precisely under restricted stepping modes because steps are detected and validated after comparing their parameters to pre-determined optimal values related to particular conditions. In this paper, we propose self-adaptive step counting in order to improve step counting accuracy under unrestricted stepping modes on smartphones. Based on our human stepping model, we propose self-adaptive method that can detect new steps by monitoring vertical acceleration and validate new steps by comparing to self-adaptive values, which are adjusted dynamically after each step occurs. We show the flexibility of the proposed approach by incorporating it into two existing step counting algorithms WPD and DTW. We also propose a new stepping cycle recognition (SCR) algorithm that is self-adaptive and performs the best under variant stepping modes. With experiments under different stepping modes including fixed and variant modes, we show that self-adaptive methods perform significantly better compared to original methods using fixed optimal values.},
  doi       = {10.1109/COMPSAC.2016.187},
  file      = {:download_papers/Tang-2016-Self-Adaptive Step Counting on Smartphones under Unrestricted.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {gait analysis;health care;smart phones;wearable computers;self-adaptive step counting;smartphones;unrestricted stepping modes;pedometer apps;wearable electronics;health monitoring;location-based systems;WPD;DTW;stepping cycle recognition;SCR;Acceleration;Heuristic algorithms;Smart phones;Sensors;Legged locomotion;Gravity;Thyristors;Self-adaptive;Linear accelerometer;Gravity sensor;Step counting;Human stepping model;Dynamic time warping},
}

@Article{Tang2018,
  author   = {Z. {Tang} and X. {Ding} and Y. {Zhong} and L. {Yang} and K. {Li}},
  journal  = {IEEE Transactions on Information Forensics and Security},
  title    = {A Self-Adaptive Bell�CLaPadula Model Based on Model Training With Historical Access Logs},
  year     = {2018},
  issn     = {1556-6021},
  month    = {Aug},
  number   = {8},
  pages    = {2047-2061},
  volume   = {13},
  abstract = {In currently popular access control models, the security policies and regulations never change in the running system process once they are identified, which makes it possible for attackers to find the vulnerabilities in a system, resulting in the lack of ability to perceive the system security status and risks in a dynamic manner and exposing the system to such risks. By introducing the maximum entropy (MaxENT) models into the rule optimization for the Bell-LaPadula (BLP) model, this paper proposes an improved BLP model with the self-learning function: MaxENT-BLP. This model first formalizes the security properties, system states, transformational rules, and a constraint model based on the states transition of the MaxENT. After handling the historical system access logs as the original data sets, this model extracts the user requests, current states, and decisions to act as the feature vectors. Second, we use k -fold cross validation to divide all vectors into a training set and a testing set. In this paper, the model training process is based on the Broyden-Fletcher-Goldfarb-Shanno algorithm. And this model contains a strategy update algorithm to adjust the access control rules dynamically according to the access and decision records in a system. Third, we prove that MaxENT-BLP is secure through theoretical analysis. By estimating the precision, recall, and F1-score, the experiments show the availability and accuracy of this model. Finally, this paper provides the process of model training based on deep learning and discussions regarding adversarial samples from the malware classifiers. We demonstrate that MaxENT-BLP is an appropriate choice and has the ability to help running information systems to avoid more risks and losses.},
  doi      = {10.1109/TIFS.2018.2807793},
  file     = {:download_papers/Tang-2018-A Self-Adaptive Bell–LaPadula Model Based on Model Training.pdf:PDF},
  groups   = {ieee, systematic_search},
  keywords = {authorisation;entropy;invasive software;learning (artificial intelligence);optimisation;historical access;security policies;regulations;running system process;system security status;maximum entropy models;rule optimization;improved BLP model;MaxENT-BLP;security properties;system states;transformational rules;constraint model;states transition;historical system access;training set;Broyden-Fletcher-Goldfarb-Shanno algorithm;access control rules;decision records;running information systems;training process;self-adaptive Bell-LaPadula model;access control models;precision;recall;F1-score;Hidden Markov models;Training;Access control;Data models;Feature extraction;Machine learning;Adversarial sample;BLP;machine learning;mandatory access control;maximum entropy model;rule optimization},
}

@Article{Tangari2018,
  author        = {G. {Tangari} and D. {Tuncer} and M. {Charalambides} and Y. {Qi} and G. {Pavlou}},
  journal       = {IEEE Transactions on Network and Service Management},
  title         = {Self-Adaptive Decentralized Monitoring in Software-Defined Networks},
  year          = {2018},
  issn          = {1932-4537},
  month         = {Dec},
  note          = {cited By 5},
  number        = {4},
  pages         = {1277-1291},
  volume        = {15},
  abstract      = {The software-defined networking (SDN) paradigm can allow network management solutions to automatically and frequently reconfigure network resources. When developing SDN-based management architectures, it is of paramount importance to design a monitoring system that can provide timely and consistent updates to heterogeneous management applications. To support such applications operating with low latency requirements, the monitoring system should scale with increasing network size and provide precise network views with minimum overhead on the available resources. In this paper, we present a novel, self-adaptive, decentralized framework for resource monitoring in SDN. Our framework enables accurate statistics to be collected with limited burden on the network resources. This is realized through a self-tuning, adaptive monitoring mechanism that automatically adjusts its settings based on the traffic dynamics. We evaluate our proposal based on a realistic use case scenario, where a content distribution service and an on-demand gaming platform are deployed within an ISP network. The results show that reduced monitoring latencies are obtained with the proposed framework, thus enabling shorter reconfiguration control loops. In addition, the proposed adaptive monitoring method achieves significant gain in terms of monitoring overhead, while preserving the performance of the services considered.},
  art_number    = {8488488},
  document_type = {Article},
  doi           = {10.1109/TNSM.2018.2874813},
  file          = {:download_papers/Tangari-2018-Self-Adaptive Decentralized Monitoring in Software-Defined Networks.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {computer network management;IP networks;resource allocation;software defined networking;system monitoring;telecommunication traffic;adaptive decentralized monitoring;software-defined networking paradigm;network management solutions;network resources;monitoring system;heterogeneous management applications;low latency requirements;network size;precise network views;decentralized framework;resource monitoring;adaptive monitoring mechanism;ISP network;reduced monitoring latencies;adaptive monitoring method;monitoring overhead;SDN-based management architectures;Monitoring;Switches;Software defined networking;Synchronization;Resource management;Task analysis;Frequency measurement;Network monitoring;software-defined networks;self-adaptation},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85054662140&doi=10.1109%2fTNSM.2018.2874813&partnerID=40&md5=31cd311e59b1e8d27000c2836f3970b8},
}

@InProceedings{Torres2011,
  author        = {R. {Torres} and H. {Astudillo}},
  booktitle     = {2011 IEEE World Congress on Services},
  title         = {Externalizing the Autopoietic Part of Software to Achieve Self-Adaptability},
  year          = {2011},
  month         = {July},
  note          = {cited By 1},
  pages         = {107-114},
  abstract      = {The autopietic/allopietic duality has been proposed to address the fact that Software systems must look to their own survival besides their successful mission completion. To the best of our knowledge, there are no explicit computational models to operationalize and test this distinction. This article describes a framework to add autopietic capabilities to composite Software systems, by using an external self-organized market full of service providers willing to provide services for satisfying new requirements and recovering actions. The approach is exemplified when a QoS agreement violation occurs in a composite application system.},
  art_number    = {6012701},
  document_type = {Conference Paper},
  doi           = {10.1109/SERVICES.2011.69},
  file          = {:download_papers/Torres-2011-Externalizing the Autopoietic Part of Software to Achieve Self-Adapt.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2378-3818},
  journal       = {Proceedings - 2011 IEEE World Congress on Services, SERVICES 2011},
  keywords      = {multi-agent systems;service-oriented architecture;autopoietic part;allopietic duality;software system;service provider;QoS agreement violation;composite application system;Web services;Quality of service;Monitoring;Software;Computer architecture;Weather forecasting;Multiagent systems;Service oriented architectures;request for tender;Zeuthen strategy},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-80053422529&doi=10.1109%2fSERVICES.2011.69&partnerID=40&md5=a45cc3174410a727412af611431a6773},
}

@InProceedings{Torres2013,
  author    = {R. {Torres} and N. {Bencomo} and H. {Astudillo}},
  booktitle = {2013 2nd International Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE)},
  title     = {Addressing the QoS drift in specification models of self-adaptive service-based systems},
  year      = {2013},
  month     = {May},
  pages     = {28-34},
  abstract  = {Analysts elaborate precise and verifiable specification models, using as inputs non-functional requirements and assumptions drawn from the current environment studied at design time. As most real world applications exist in dynamic environments, recently there has been research efforts towards the design of software systems that use their specification models during runtime. The main idea is that software systems should endeavor to keep their requirements satisfied by adapting their architectural configurations when appropriated. Unfortunately, such specifications models use specific numbers (i.e. values) to specify non-functional constraints (NFCs) and may become rapidly obsolete during runtime given the drastic changes that operational environments can go through. The above may create circumstances when software systems are unaware that their requirements have been violated. To mitigate the obsolescence of specification models we have already proposed to use computing with words (CWW) to represent the NFCs with linguistic values instead of numbers. The ��numerical meanings�� of these linguistic values are computed from the measurements of non-functional properties (NFPs) gathered by a monitoring infrastructure. This article introduces the concept of ��QoS-drift�� to represent a significant degree of change in the ��numerical meanings�� of the linguistic values of the NFPs in the service market. We add to our former proposal a QoS-drift's vigilance unit to update linguistic values only when a QoS-drift is detected. Therefore, the new models are proactive and automatically maintained, what results in a more efficient assessment of run-time requirements' compliance under non-stationary environments. We validate the effectiveness of our approach using (1) a service market of 1500 services with two NFPs, (2) a synthetical QoS-drift and, (3) five systems built by different service compositions. We have detected that four of the five systems experienced requirements violations that would not have been detected without the use of our approach.},
  doi       = {10.1109/RAISE.2013.6615201},
  file      = {:download_papers/Torres-2013-Addressing the QoS drift in specification models of self-adaptive.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {computational linguistics;formal specification;quality of service;software quality;QoS drift;specification models;self-adaptive service-based systems;nonfunctional requirements;software systems;linguistic values;service market;nonstationary environments;run-time requirements compliance;NFPs;nonfunctional properties;CWW;computing with words;NFCs;nonfunctional constraints;Pragmatics;Runtime;Analytical models;Adaptation models;Fuzzy sets;Quality of service;Computational modeling;concept drift;specification models;require-ments@run.time;computing with words;fuzzy logic},
}

@InProceedings{Torres2017,
  author        = {R. {Torres} and M. {Aros} and J. F. {Calder��n}},
  booktitle     = {2017 CHILEAN Conference on Electrical, Electronics Engineering, Information and Communication Technologies (CHILECON)},
  title         = {Towards self-adaptation for cyber-physical systems using a distributed MAPE-K schema over XMPP},
  year          = {2017},
  month         = {Oct},
  note          = {cited By 0},
  pages         = {1-5},
  volume        = {2017-January},
  abstract      = {Cyber-Physical Systems (CPSs) may fail during runtime on supporting decision making if they are not capable of detecting and correcting their own failures. Thus, it has been proposed that CPSs should be self-aware, context-aware and goal-aware. In this paper we present preliminary results about how an architecture built over the Extensible Messaging and Presence Protocol (XMPP) may implement a distributed MAPE-K schema in order to support the implementation of the self-adaptation capability in CPSs. We present a basic example where failures on Things are simulated in order to test the self-adaptation capability.},
  document_type = {Conference Paper},
  doi           = {10.1109/CHILECON.2017.8229533},
  file          = {:download_papers/Torres-2017-Towards self-adaptation for CPSs.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {2017 CHILEAN Conference on Electrical, Electronics Engineering, Information and Communication Technologies, CHILECON 2017 - Proceedings},
  keywords      = {cyber-physical systems;decision making;Internet of Things;protocols;cyber-physical systems;distributed MAPE-K schema;XMPP;CPSs;decision making;self-adaptation capability;extensible messaging and presence protocol;Computer architecture;Servers;Runtime;Protocols;Adaptation models;Standards;Internet of Things;Internet of Things;self-adaptation;cyber-physical system},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85043266216&doi=10.1109%2fCHILECON.2017.8229533&partnerID=40&md5=6c03fe10883fbcfd06c450255d1895ba},
}

@Conference{VanHoorn2009,
  author        = {Van Hoorn, A. and Hasselbring, W. and Rohr, M.},
  title         = {Engineering and continuously operating self-Adaptive software systems: Required design decisions},
  year          = {2009},
  note          = {cited By 0},
  pages         = {52-63},
  volume        = {537},
  abstract      = {Self-adaptive or autonomic systems are computing systems which are able to manage/adapt themselves at runtime according to certain high-level goals. It is appropriate to equip software systems with adaptation capabilities in order to optimize runtime properties, such as performance, availability, or operating costs. Architectural models are often used to guide system adaptation. When engineering such systems, a number of cross-cutting design decisions, e.g. instrumentation, targeting at a system's later operation/maintenance phase must and can be considered during early design stages. In this paper, we discuss some of these required design decisions for adaptive software systems and how models can help in engineering and operating these systems. The discussion is based on our experiences, including those gathered from evaluating research results in industrial settings. To illustrate the discussion, we use our selfadaptation approach SLAstic to describe how we address the discussed issues. SLAstic aims to improve a software system's resource efficiency by performing architecturebased runtime reconfigurations that adapt the system capacity to varying workloads, for instance to decrease the operating costs.},
  document_type = {Conference Paper},
  file          = {:download_papers/VanHoorn-2009-Engineering and continuously operating self-Adaptive systems.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {CEUR Workshop Proceedings},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84893493228&partnerID=40&md5=9328b909ca7942d785d1a25f91392e2a},
}

@InProceedings{VanWambeke2007,
  author    = {N. {Van Wambeke} and F. {Armando} and C. {Chassot} and E. {Exposito}},
  booktitle = {21st International Conference on Advanced Information Networking and Applications Workshops (AINAW'07)},
  title     = {Architecture and Models for Self-Adaptability of Transport Protocols},
  year      = {2007},
  month     = {May},
  pages     = {977-982},
  volume    = {1},
  abstract  = {Quality of service (QoS) oriented self-adaptive transport protocols are a major issue in the conception of future services for emergent networking technologies (wireless, mobiles, ad-hoc... ). Indeed, transport protocols will have to cope with dynamic applicative and network requirements/constraints throughout the lifetime of a connection while still having to provide the best possible end-to-end QoS to the end users. This is due to the multiplication of access network technologies and the deployment of cross- technology handover (i.e. convergence WiFi/GSM) combined with the generalized mobility of end users in the future "ambient" Internet. Transport protocols whose internal architecture may be dynamically configured appear to be a very promising solution for the support of QoS oriented adaptation. In this context, various problems such as the coordination of distributed adapting entities as well as the best way to guide this adaptation still remain under exploration. Regarding this last problem, model based decision process is a promising approach to avoid ad-hoc specific solutions. Following this approach, this paper introduces an analytical model for the decision process aimed at choosing the best module composition to be instantiated in order to optimize the QoS in a dynamic context. This approach is further illustrated by a case study in which the model is used to self-adaptively optimize applicative QoS for the recently introduced IEEE 802.11e wireless networks standard.},
  doi       = {10.1109/AINAW.2007.99},
  file      = {:download_papers/Wambeke-2007-Architecture and Models for Self-Adaptability.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {quality of service;self-adjusting systems;transport protocols;self-adaptability;quality of service;self-adaptive transport protocols;QoS oriented adaptation;distributed adapting entity;model based decision process;IEEE 802.11e wireless networks standard;Transport protocols;Quality of service;IP networks;Analytical models;Context;GSM;Wireless networks;Layout;Application software;Collaborative work;Quality of Service;Self-adaptation;Micro Protocols;Transport Protocol;Decision model},
}

@InProceedings{Vassev2008a,
  author    = {E. {Vassev} and M. {Hinchey}},
  booktitle = {2008 Second IEEE International Conference on Self-Adaptive and Self-Organizing Systems Workshops},
  title     = {ASSL Specification of Emergent Self-Adapting Behavior for NASA Swarm-Based Exploration Missions},
  year      = {2008},
  month     = {Oct},
  pages     = {13-18},
  abstract  = {We describe a biologically-inspired approach to modeling self-adapting behavior of NASA swarm-based exploration missions, whereby individual entities in the system can sacrifice themselves for the greater good of the entire system. We investigate aspects of possible emergent self-adapting behavior of swarm-based systems, inspired by the self-sacrifice behavior observed in some hive cultures. Moreover, we propose an ASSL specification model for the self-sacrifice behavior of the swarm individuals. ASSL (Autonomic System Specification Language) is a specification language dedicated to autonomic systems, and with which we have been experimenting with some positive results.},
  doi       = {10.1109/SASOW.2008.19},
  file      = {:download_papers/Vassev-2008-ASSL Specification of Emergent Self-Adapting Behavior for NASA.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {aerospace computing;fault tolerant computing;formal specification;specification languages;ASSL specification;emergent self-adapting behavior;NASA swarm-based exploration missions;biologically-inspired approach;swarm-based systems;Autonomic System Specification Language;NASA;Space vehicles;Specification languages;Protection;Software engineering;Security;Testing;Conferences;Educational institutions;Biological system modeling},
}

@InProceedings{Vromant2011,
  author    = {Vromant, Pieter and Weyns, Danny and Malek, Sam and Andersson, Jesper},
  booktitle = {Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {On Interacting Control Loops in Self-Adaptive Systems},
  year      = {2011},
  address   = {New York, NY, USA},
  pages     = {202–207},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’11},
  abstract  = {Control loops in self-adaptive systems are typically conceived as a sequence of four computations: Monitor-Analyze-Plan-Execute (MAPE). During the development of a traffic monitoring system with support for self-healing, we have noticed that simple MAPE loops are not sufficient to deal with the more complex failure scenarios. To manage the adaptations in these scenarios, we extend MAPE loops with support for two types of coordination. First, we introduce support for intra-loop coordination enabling MAPE computations within one loop to coordinate with one another. Intra-loop coordination allows the execution of multiple sub-loops within one control loop. Second, we introduce support for inter-loop coordination enabling MAPE computations across multiple loops to coordinate with one another. Inter-loop coordination allows the MAPE computations of different loops to coordinate the various phases of adaptations. We show how we used the extensions to support self-healing in the traffic monitoring system. We discuss an implementation framework that supports coordination of MAPE loops, and from our experiences offer recommendations for future research in this area.},
  doi       = {10.1145/1988008.1988037},
  file      = {:download_papers/Vromant-2011-On interacting control loops in self-adaptive systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450305754},
  keywords  = {coordination, mape, control loop, self-adaptation},
  location  = {Waikiki, Honolulu, HI, USA},
  numpages  = {6},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1988008.1988037},
}

@InProceedings{Wan2017,
  author        = {J. {Wan} and Q. {Li} and L. {Wang} and L. {He} and Y. {Li}},
  booktitle     = {2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS)},
  title         = {A self-adaptation framework for dealing with the complexities of software changes},
  year          = {2017},
  month         = {Nov},
  note          = {cited By 0},
  pages         = {521-524},
  volume        = {2017-November},
  abstract      = {Software Self-adaption (SA) is a promising technology to reduce the cost of software maintenance. However, the complexities of software changes such as various and producing different effects, interrelated and occurring in an unpredictable context challenge the SA. The current methods may be insufficient to provide the required self-adaptation abilities to handle all the existent complexities of changes. Thus, this paper presents a self-adaptation framework which can provide a multi-agent system for self-adaptation control to equip software system with the required adaptation abilities. we employ the hybrid control mode and construct a two-layer MAPE control structure to deal with changes hierarchically. Multi-Objective Evolutionary Algorithm and Reinforcement Learning are applied to plan an adequate strategy for these changes. Finally, in order to validate the framework, we exemplify these ideas with a meta-Search system and confirm the required self-adaptive ability.},
  document_type = {Conference Paper},
  doi           = {10.1109/ICSESS.2017.8342969},
  file          = {:download_papers/Wan-2017-A self-adaptation framework for dealing with the complexities.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {2327-0594},
  journal       = {Proceedings of the IEEE International Conference on Software Engineering and Service Sciences, ICSESS},
  keywords      = {evolutionary computation;learning (artificial intelligence);multi-agent systems;software maintenance;SA;Multi-Objective Evolutionary Algorithm;Reinforcement Learning;meta-Search system;software maintenance;software Self-adaption;required self-adaptive ability;two-layer MAPE control structure;hybrid control mode;required adaptation abilities;software system;self-adaptation control;multiagent system;self-adaptation framework;existent complexities;required self-adaptation abilities;current methods;unpredictable context challenge;software changes;Planning;Google;Learning (artificial intelligence);Servers;Task analysis;Complexity theory;Software;Self-adaptive systems;Search-based software engineering;Multi-agent systems;Reinforcement Learning;Multi-Objective Evolutionary Algorithm},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85046993609&doi=10.1109%2fICSESS.2017.8342969&partnerID=40&md5=b5d33fbd46b8c7796af933bcdd033f25},
}

@Article{Wang2005,
  author     = {Wang, Qianxiang},
  journal    = {SIGSOFT Softw. Eng. Notes},
  title      = {Towards a Rule Model for Self-Adaptive Software},
  year       = {2005},
  issn       = {0163-5948},
  month      = jan,
  number     = {1},
  pages      = {8},
  volume     = {30},
  abstract   = {Most self-adaptive software use rules explicitly or implicitly to decide how to react to monitored events. Meanwhile, rules are usually scattered in different procedures, which makes procedures more complex. This paper proposes a Rule Model, which is used to extract scattered rules from different procedures, so as to enhance the self-adaptive ability of software. The paper presents what is Rule Model, including: three key concepts (event, parameter, and rule), hierarchical organization, role in application, and XML-based representation. The paper also introduces how to map declarative rules inside one deployable application to executable rules inside one rule engine, based on one J2EE-compliant application server.},
  address    = {New York, NY, USA},
  doi        = {10.1145/1039174.1039198},
  file       = {:download_papers/Wang-2005-Towards a rule model for self-adaptive software.pdf:PDF},
  groups     = {acm, systematic_search},
  issue_date = {January 2005},
  keywords   = {rule model, self-adaptive software},
  numpages   = {5},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/1039174.1039198},
}

@InProceedings{Wang2007,
  author        = {H. {Wang} and J. {Ying}},
  booktitle     = {31st Annual International Computer Software and Applications Conference (COMPSAC 2007)},
  title         = {Toward Runtime Self-adaptation Method in Software-Intensive Systems Based on Hidden Markov Model},
  year          = {2007},
  month         = {July},
  note          = {cited By 6},
  pages         = {601-606},
  volume        = {2},
  abstract      = {To reduce the overload of human management, recently runtime self-adaptation is emerging as an important characteristic required by most intelligent software-intensive systems. Most methods are built upon the analysis of concepts of architecture and exploit some "craft" from the perspective of qualitative analysis. However, these methods are often incapable of reasoning about the history of requested services, hence it is difficult to improve more efficiently software efficiency and predictability. Quantitative analysis based on the theory of stochastic processes would be a better option to depict the runtime environment more accurately. This paper presents a demonstration of the idea. In this paper, we employ the mathematic characteristic of Hidden Markov Model to achieve self-adaptation at runtime by means of modeling the behavior of users' requests and the runtime context. After analyzing the history of requested services and reconstructing the request sequence, the model responds to requests in a more efficient and rapid fashion.},
  art_number    = {4291184},
  document_type = {Conference Paper},
  doi           = {10.1109/COMPSAC.2007.214},
  file          = {:download_papers/Wang-2007-Toward Runtime Self-adaptation Method in Software-Intensive.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {0730-3157},
  journal       = {Proceedings - International Computer Software and Applications Conference},
  keywords      = {hidden Markov models;software engineering;stochastic processes;runtime self-adaptation method;intelligent software-intensive systems;hidden Markov model;qualitative analysis;software efficiency;quantitative analysis;stochastic processes;request sequence;Hidden Markov models;History;Humans;Intelligent systems;Computer architecture;Stochastic processes;Runtime environment;Mathematics;Context modeling;Mathematical model},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-37349001573&doi=10.1109%2fCOMPSAC.2007.214&partnerID=40&md5=2e036b082b0b552e091c50644be04d96},
}

@InProceedings{Wang2010,
  author        = {M. {Wang} and H. {Mei} and W. {Jiao} and J. {Jie} and J. {Ma}},
  booktitle     = {2010 International Conference on Artificial Intelligence and Computational Intelligence},
  title         = {A Self-Adaptive Mechanism for Software Configuration Based on Case-based Reasoning and Policy},
  year          = {2010},
  month         = {Oct},
  note          = {cited By 0},
  pages         = {250-255},
  volume        = {3},
  abstract      = {Self-adaptive software expects the system to adapt its behaviors to environment changes. One main challenge is how to improve self-adaptation efficiency. In this paper case-based reasoning method is used to support the self-configuration case reuse which results in the configuration efficiency improvement. If there is no case to reuse directly, the policy-based technique is utilized to achieve the self-configuring plan. Moreover, the new generated configuration plan will be stored to the case repository for later reuse. This self-adaptive mechanism is more flexible and efficient which also is applicable to the self-optimizing, self-healing and self-protecting etc. It has proved to be available and very helpful in software system self-configuration.},
  art_number    = {5655393},
  document_type = {Conference Paper},
  doi           = {10.1109/AICI.2010.290},
  file          = {:download_papers/Wang-2010-A Self-Adaptive Mechanism for Software Configuration.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - International Conference on Artificial Intelligence and Computational Intelligence, AICI 2010},
  keywords      = {case-based reasoning;configuration management;software fault tolerance;software reusability;self adaptive mechanism;software configuration;case based reasoning;software reusability;policy based technique;Petroleum;Cognition;Software;Monitoring;Computer architecture;Object recognition;Concrete;self-adaptive;case-based reasoning;policy},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-78651425792&doi=10.1109%2fAICI.2010.290&partnerID=40&md5=d9aaa8e8861eabcc15ee43e0fd0f59fb},
}

@InProceedings{Wang2010a,
  author        = {H. {Wang} and Z. {Zheng}},
  booktitle     = {2010 International Conference on Artificial Intelligence and Computational Intelligence},
  title         = {Self-adaptive Method Based on Software Architecture by Inspecting Uncertainty},
  year          = {2010},
  month         = {Oct},
  note          = {cited By 2},
  pages         = {208-214},
  volume        = {3},
  abstract      = {A recent common approach to monitor and adapt system behavior at runtime is to decouple one or more external modules and self-adaptive mechanisms from the target system. The non-invasive manners have the main advantage of realizing separation of concerns. However, some uncertainty aspects emerge while utilizing these separate control units. The unanticipated inherence and complexity of upcoming services and applications make proactive self-adaptation essential. In this work, the specification of software architecture is extended using CHAM (Chemical Abstract Machine) by inspecting uncertainty. Software architecture guides the topology of the constituent computational elements (such as components and connectors) of the system under consideration. The proposed self-adaptive model is novel as it leverages standard software architecture models, and quantifies behaviors of the system in terms of relevant architectural elements. Experiment results show the effectiveness of the proposed method.},
  art_number    = {5654770},
  document_type = {Conference Paper},
  doi           = {10.1109/AICI.2010.282},
  file          = {:download_papers/Wang-2010-Self-adaptive Method Based on Software Architecture.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - International Conference on Artificial Intelligence and Computational Intelligence, AICI 2010},
  keywords      = {program compilers;software architecture;software fault tolerance;uncertainty handling;self adaptive method;software architecture;uncertainty inspection;noninvasive manner;CHAM;chemical abstract machine;computational element;Software architecture;Uncertainty;Hidden Markov models;Software;Connectors;Adaptation model;Cost accounting;self-adaptive;software architecture;uncertainty;chemical abstract machine},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-78651451423&doi=10.1109%2fAICI.2010.282&partnerID=40&md5=c970baa860b76a473d5810f14ce77e76},
}

@InProceedings{Wang2012,
  author        = {L. {Wang} and Y. {Gao} and C. {Cao} and L. {Wang}},
  booktitle     = {2012 IEEE 36th Annual Computer Software and Applications Conference Workshops},
  title         = {Towards a General Supporting Framework for Self-Adaptive Software Systems},
  year          = {2012},
  month         = {July},
  note          = {cited By 4},
  pages         = {158-163},
  abstract      = {When confronted with their internal and environmental dynamics, various software systems increasingly require self-adaptation capabilities. The vision above requires the self-adaptation approach to tackle these challenges and some software systems have their own specific implementations. However, in this paper a general supporting framework is proposed for software systems to self-adapt with running environmental dynamics and meanwhile fulfill various user requirements. Three key issues are covered in the framework: 1) the overall control architecture, which adopts the double closed-loop style and respectively includes the self-adaptation loop and the self-learning loop; 2) a general descriptive language, which is a application-independent and unified language to represent self-adaptation knowledge about target systems; 3) three implementation mechanisms, including forward reasoning, planning and reinforcement learning using feedback, which are supported by the above descriptive language and executed at runtime in different modules. Finally, one scenario of on-demand services of massive data mining tasks is selected and the case study demonstrates how the framework is customized as required and how the approach works.},
  art_number    = {6341568},
  document_type = {Conference Paper},
  doi           = {10.1109/COMPSACW.2012.38},
  file          = {:download_papers/Wang-2012-Towards a General Supporting Framework.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - International Computer Software and Applications Conference},
  keywords      = {data mining;inference mechanisms;software engineering;unsupervised learning;self-adaptive software system;environmental dynamics;general supporting framework;overall control architecture;self-adaptation loop;self-learning loop;general descriptive language;self-adaptation knowledge;forward reasoning;reinforcement learning;on-demand service;data mining;Software systems;Planning;Monitoring;Computer architecture;Cognition;Adaptation models;Learning;Self-Adaptive System;Self-Adaptive Supporting Framework;Double Closed-loop Control Arthitecture;General Descriptive Language;Hierarchical Task Network;Rete Algorithm},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84870801132&doi=10.1109%2fCOMPSACW.2012.38&partnerID=40&md5=036aaf69b1a7c0f6c77995f79a58b336},
}

@Article{Wang2012c,
  author   = {Tieshan Wang and Bin Li and Lingjun Zhao and Xiaowei Zhang},
  journal  = {Physics Procedia},
  title    = {A goal-driven Self-adaptive Software System Design Framework based on Agent},
  year     = {2012},
  issn     = {1875-3892},
  note     = {International Conference on Applied Physics and Industrial Engineering 2012},
  pages    = {2010 - 2016},
  volume   = {24},
  abstract = {The methods currently apply to ensure the robustness and dependability of software system do not effectively map to more open, dynamic environments. A new goal-driven self-adaptive software system design framework based on agent is proposed. Every layer of our model provides specific conceptual descriptions and domain capabilities of their domain. let goal be the core modeling concept, a self-adaptive software system modeling framework driven by goal is proposed; let Agent be core implementing entity, the self-adaptive software system is build in open environment.},
  doi      = {https://doi.org/10.1016/j.phpro.2012.02.295},
  file     = {:download_papers/Wang-2012-A goal-driven Self-adaptive Software System Design Framework.pdf:PDF},
  groups   = {sciencedirect, systematic_search},
  keywords = {Goal, Role, Multi-Agent Systems, Goal model},
  url      = {http://www.sciencedirect.com/science/article/pii/S1875389212003380},
}

@InProceedings{Wang2016,
  author        = {L. {Wang} and Q. {Li}},
  booktitle     = {2016 IEEE International Conference on Software Maintenance and Evolution (ICSME)},
  title         = {A Multiagent-Based Framework for Self-Adaptive Software with Search-Based Optimization},
  year          = {2016},
  month         = {Oct},
  note          = {cited By 5},
  pages         = {621-625},
  abstract      = {Planning a suitable solution to adapt to software changes is the most important and fundamental ability of self-adaptive software (SAS). However, with the increasing complexities of managed resources, context and user preferences, existing self-adaptive planning approaches need to be improved to deal with the complex changes which are multiple, interrelated and evolving. Search-based optimization (SBO) is well-suited to deal with multiple and complex problems. Hence, using SBO as a new self-adaptive planning approach may be a particularly promising research trajectory. This paper proposes a multi-agent framework for SAS with SBO to deal with complex changes, reduce maintenance time and cost, and enhance software quality. This framework defines a special software architecture of SAS to choose different planning approaches, uses the SBO to plan solutions for complex changes, and supports the online planning by multi agents. In addition, a corresponding workbench is being established to develop SAS according to this framework.},
  art_number    = {7816529},
  document_type = {Conference Paper},
  doi           = {10.1109/ICSME.2016.16},
  file          = {:download_papers/Wang-2016-A Multiagent-Based Framework for Self-Adaptive Software.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2016 IEEE International Conference on Software Maintenance and Evolution, ICSME 2016},
  keywords      = {multi-agent systems;optimisation;planning (artificial intelligence);software architecture;software maintenance;software quality;multiagent-based framework;self-adaptive software;SAS;search-based optimization;SBO;self-adaptive planning;software quality;software architecture;software maintenance;Synthetic aperture sonar;Planning;Software;Search problems;Software architecture;Context;Optimization;Self-adaptive systems;Search-based software engineering;Multi-agent systems;Self-adaptive planning approaches;Search-based optimization},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85013059693&doi=10.1109%2fICSME.2016.16&partnerID=40&md5=7f15f78ccd9eca80b17409e5983689dc},
}

@InProceedings{Wang2017a,
  author        = {Wang, Lu},
  booktitle     = {Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering},
  title         = {Using Search-Based Software Engineering to Handle the Changes with Uncertainties for Self-Adaptive Systems},
  year          = {2017},
  address       = {New York, NY, USA},
  note          = {cited By 2},
  pages         = {1014–1017},
  publisher     = {Association for Computing Machinery},
  series        = {ESEC/FSE 2017},
  volume        = {Part F130154},
  abstract      = {The changes confronting contemporary Self-Adaptive Systems (SASs) are characterized by uncertainties. To generate adaptation strategies for handling these changes, existing adaptation planning methods, which ignore these uncertainties, must be improved. This thesis explores the possibilities of using Search-Based Software Engineering (SBSE) to establish a search-based planning method capable of handling multiple changes in an uncertain context without defining their priorities. Meanwhile, both the assurance approach and the selection approach are proposed to solve emerging research questions that arise when such planning method is applied in actual SASs. From this experience, we are able to derive innovative methods for the designers of SASs as a reference, which may observably promote the widespread use of SBSE in SASs. © 2017 Copyright held by the owner/author(s).},
  document_type = {Conference Paper},
  doi           = {10.1145/3106237.3119871},
  file          = {:download_papers/Wang-2017-Using search-based software engineering to handle the changes.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450351058},
  journal       = {Proceedings of the ACM SIGSOFT Symposium on the Foundations of Software Engineering},
  keywords      = {Self-adaptive systems, Self-adaptation planning, Search-based software engineering, Multi-object optimization},
  location      = {Paderborn, Germany},
  numpages      = {4},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/3106237.3119871},
}

@InProceedings{Wang2017c,
  author    = {Y. {Wang} and Y. {Huang} and W. {Zheng} and Z. {Zhou} and D. {Liu} and M. {Lu}},
  booktitle = {2017 IEEE International Conference on Industrial Technology (ICIT)},
  title     = {Combining convolutional neural network and self-adaptive algorithm to defeat synthetic multi-digit text-based CAPTCHA},
  year      = {2017},
  month     = {March},
  pages     = {980-985},
  abstract  = {We always use CAPTCHA(Completely Automated Public Turing test to Tell Computers and Humans Apart) to prevent automated bot for data entry. Although there are various kinds of CAPTCHAs, text-based scheme is still applied most widely, because it is one of the most convenient and user-friendly way for daily user [1]. The fact is that segmentations of different types of CAPTCHAs are not always the same, which means one of CAPTCHA's bottleneck is the segmentation. Once we could accurately split the character, the problem could be solved much easier. Unfortunately, the best way to divide them is still case by case, which is to say there is no universal way to achieve it. In this paper, we present a novel algorithm to achieve state-of-the-art performance, what was more, we also constructed a new convolutional neural network as an add-on recognition part to stabilize our state-of-the-art performance of the whole CAPTCHA system. The CAPTCHA datasets we are using is from the State Administration for Industry& Commerce of the People's Republic of China. In this datasets, there are totally 33 entrances of CAPTCHAs. In this experiments, we assume that each of the entrance is known. Results are provided showing how our algorithms work well towards these CAPTCHAs.},
  doi       = {10.1109/ICIT.2017.7915494},
  file      = {:download_papers/Wang-2017-Combining convolutional neural network and self-adaptive algorithm.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {character recognition;convolution;image segmentation;neural nets;text analysis;convolutional neural network;self-adaptive algorithm;synthetic multidigit text-based CAPTCHA;completely automated public turing test to tell computers and humans apart;data entry;text-based scheme;CAPTCHA segmentations;character segmentation;add-on recognition part;China;CAPTCHAs;Image segmentation;Optical character recognition software;Neural networks;Character recognition;Business;Clustering algorithms;CAPTCHA;convolutional neural network;segmentation;reverse Turing test;clustering},
}

@Article{Wang2018,
  author   = {X. {Wang} and Z. {Feng} and K. {Huang}},
  journal  = {IEEE Access},
  title    = {D3L-Based Service Runtime Self-Adaptation Using Replanning},
  year     = {2018},
  issn     = {2169-3536},
  pages    = {14974-14995},
  volume   = {6},
  abstract = {For business processes based on micro service architecture in an enterprise, failures often occur because of modified business rules or goals, change of service availability, and dynamical running environment. Based on dynamical replanning technologies, these failures can be repaired at runtime. However, semantic conflicts among services from different providers can greatly decrease response efficiency and response success rate of a business goal. In this paper, we propose a novel service runtime self-adaptation framework to decrease response time and raise success rate. Distributed dynamic description logic is utilized to eliminate semantic conflicts among services and provide basic models for carrying out planning among services. Considering inputs, outputs, preconditions, and effects properties of services, local and global planning algorithms based on artificial intelligence graph planning are designed. Local planning can rapidly search a service-based path only including services from a provider, and global planning can try to explore a path including services from multiple providers. Based on these two algorithms, local and global replanning strategies are designed to handle runtime exceptions at service level and path level. We implement a prototype system by means of workflow engine Activiti and business process language BPMN2.0. Experiments show that compared with previous works, our framework can guarantee higher efficiency and success rate.},
  doi      = {10.1109/ACCESS.2018.2810848},
  file     = {:download_papers/Wang-2018-D3L-Based Service Runtime Self-Adaptation Using Replanning.pdf:PDF},
  groups   = {ieee, systematic_search},
  keywords = {business data processing;cloud computing;graph theory;planning (artificial intelligence);service-oriented architecture;Web services;workflow management software;business goal;self-adaptation framework;response time;distributed dynamic description logic;global planning;artificial intelligence graph planning;local planning;multiple providers;local replanning strategies;global replanning strategies;service runtime;business process language BPMN2.0;workflow engine Activiti;response success rate;response efficiency;semantic conflicts;dynamical replanning technologies;dynamical running environment;service availability;modified business rules;microservice architecture;D3L;service level;runtime exceptions;Runtime;Planning;Business;Ontologies;Monitoring;Engines;Semantics;Running self-adaptation;software service;graph planning;D3L;workflow},
}

@InProceedings{Wei?bach2017,
  author        = {M. {Wei?bach} and P. {Chrszon} and T. {Springer} and A. {Schill}},
  booktitle     = {2017 IEEE 11th International Conference on Self-Adaptive and Self-Organizing Systems (SASO)},
  title         = {Decentrally Coordinated Execution of Adaptations in Distributed Self-Adaptive Software Systems},
  year          = {2017},
  month         = {Sep.},
  note          = {cited By 5},
  pages         = {111-120},
  abstract      = {Software systems in domains like Smart Cities, the Internet of Things or autonomous cars are coined by a high degree of distribution across several independent computing devices and the requirement to be able to adjust themselves to varying situations in their operational environment. Self-adaptive software systems are a natural choice to implement such context-dependent software systems. A multitude of approaches already implement self-adaptive systems and some consider even distribution aspects.Yet, none of the existing solutions supports the coordination of adaptation operations spanning multiple independent nodes, which is necessary to ensure a consistent adaptation even in presence of network errors or node failures. In this paper, we tackle this challenge to execute adaptations in distributed self-adaptive software systems in a coordinated manner. We present a protocol that enables the self-adaptive software system to execute correlated adaptations on multiple nodes in a transactional manner ensuring an atomic and consistent transition of the distributed system from its source to the desired target configuration. The protocol is validated to be free of deadlocks for any given adaptation at any point in time using a model-checking approach. The performance of our approach is investigated in experiments that emulate the protocol's execution on real devices for different sizes of distributed applications and adaptation scenarios.},
  art_number    = {8064035},
  document_type = {Conference Paper},
  doi           = {10.1109/SASO.2017.20},
  file          = {:download_papers/Wang-2017-Decentrally Coordinated Execution of Adaptations in Distributed.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {1949-3681},
  journal       = {Proceedings - 11th IEEE International Conference on Self-Adaptive and Self-Organizing Systems, SASO 2017},
  keywords      = {adaptive systems;Internet of Things;self-adjusting systems;smart cities;distributed self-adaptive software systems;context-dependent software systems;decentrally coordinated execution;smart cities;Internet of Things;Software systems;Protocols;Adaptation models;Context modeling;Middleware;Concrete;Smart cities},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85035341625&doi=10.1109%2fSASO.2017.20&partnerID=40&md5=6c37546e4b842dc217aebbe73ffca1fc},
}

@InProceedings{Weisbach2017,
  author    = {Wei\ss{}bach, Martin and Springer, Thomas},
  booktitle = {Proceedings of the Symposium on Applied Computing},
  title     = {Coordinated Execution of Adaptation Operations in Distributed Role-Based Software Systems},
  year      = {2017},
  address   = {New York, NY, USA},
  pages     = {45–50},
  publisher = {Association for Computing Machinery},
  series    = {SAC ’17},
  abstract  = {Future applications will run in a highly heterogeneous and dynamic execution environment that forces them to adapt their behavior and offered functionality depending on the user's or the system's current situation. Since application components in such heterogeneous multi-device systems will be distributed over multiple interconnected devices and cooperate to achieve a common goal, a coordinated adaptation is required to ensure a consistent system behavior. In this paper we present a decentralized adaptation middleware to adapt a distributed software system. Our approach supports the reliable execution of multiple adaptation operations that depend on each other and are performed transactionally even in unsteady environments coined by message loss or node failures. We implemented our approach in a search-and-rescue robot scenario to show its feasibility and conduct first performance evaluations.},
  doi       = {10.1145/3019612.3019624},
  file      = {:download_papers/Weissbach-2017-Coordinated execution of adaptation operations in distributed.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450344869},
  keywords  = {multi-device systems, decentralized coordinated adaptation, self-adaptive systems, roles},
  location  = {Marrakech, Morocco},
  numpages  = {6},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3019612.3019624},
}

@InProceedings{Weiss2018,
  author    = {Weiss, Gereon and Schleiss, Philipp and Schneider, Daniel and Trapp, Mario},
  booktitle = {Proceedings of the 13th International Conference on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Towards Integrating Undependable Self-Adaptive Systems in Safety-Critical Environments},
  year      = {2018},
  address   = {New York, NY, USA},
  pages     = {26–32},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’18},
  abstract  = {Modern cyber-physical systems (CPS) integrate more and more powerful computing power to master novel applications and adapt to changing situations. A striking example is the recent progression in the automotive market towards autonomous driving. Powerful artificial intelligent algorithms must be executed on high performant parallelized platforms. However, this cannot be employed in a safe way, as the platforms stemming from the consumer electronics (CE) world still lack required dependability and safety mechanisms. In this paper, we present a concept to integrate undependable self-adaptive subsystems into safety-critical environments. For this, we introduce self-adaptation envelopes which manage undependable system parts and integrate within a dependable system. We evaluate our approach by a comprehensive case study of autonomous driving. Thereby, we show that the potential failures of the AUTOSAR Adaptive platform as exemplary undependable system can be handled by our concept. In overall, we outline a way of integrating inherently undependable adaptive systems into safety-critical CPS.},
  doi       = {10.1145/3194133.3194157},
  file      = {:download_papers/Weiss-2018-Towards integrating undependable self-adaptive systems.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450357159},
  keywords  = {autonomous driving, self-adaptive, AUTOSAR adaptive, cyber-physical systems},
  location  = {Gothenburg, Sweden},
  numpages  = {7},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/3194133.3194157},
}

@InProceedings{Weyns2007,
  author    = {D. {Weyns} and T. {Holvoet}},
  booktitle = {International Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS '07)},
  title     = {An Architectural Strategy for Self-Adapting Systems},
  year      = {2007},
  month     = {May},
  pages     = {3-3},
  abstract  = {Self-adaptation is the ability of a software system to adapt to dynamic and changing operating conditions autonomously. In this paper, we present an architectural strategy for self-adapting systems. An architectural strategy embodies architectural knowledge about a particular solution approach. The architectural strategy for self-adapting systems structures the software into a number of interacting autonomous entities (agents) that are situated in an environment. It integrates a set of architectural patterns that have proved to be valuable in the design of various self-adapting applications. The self-adapting properties of the approach are based on the agents' abilities to adapt their behavior to dynamic and changing circumstances. The architectural strategy provides an asset base architects can draw from when developing new self-adapting applications that share its common base.},
  doi       = {10.1109/SEAMS.2007.3},
  file      = {:download_papers/Weyns-2007-An Architectural Strategy for Self-Adapting Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2321},
  keywords  = {multi-agent systems;software architecture;software reliability;software reusability;self-adapting system;multiagent system;software architecture;software reliability;software reusability;Software systems;Application software;Control systems;Large-scale systems;Multiagent systems;Computer science;Computer networks;Distributed computing;Communications technology;Communication system traffic control},
}

@InProceedings{Wu2016,
  author    = {R. {Wu} and L. {Huang} and P. {Yu} and K. {Shen} and Q. {Shi} and H. {Zhou}},
  booktitle = {2016 IEEE Trustcom/BigDataSE/ISPA},
  title     = {Meta-Model Evolution with Self-Adaptation: An Empirical Development Approach for Distributed Parallel Computing Framework},
  year      = {2016},
  month     = {Aug},
  pages     = {2227-2234},
  abstract  = {Distributed parallel computing platform performs well in processing big data. However, due to the platform's complexity and distributed characteristics, it is hard to design and achieve. For example, during the platform's design phase, variations are unpredictable. To address these issues, a highly structured object-oriented framework for systematic modeling, which has high flexibility, reusability and maintainability, is needed. In this paper, we present and implement an empirical development approach to achieve the specific modeling framework, based on meta-model evolution with hot-spots (variable parts) recognition. Our work expands this idea into the following directions. Firstly, we define a generic and stable meta-model. We give out concept models, object models and dynamic models of main objects. General data partitioning, job division and inter-node communication mechanism are designed. Secondly, based on the meta-model, we complete framework's incremental adaptation using an iterative process according to design variations. Practical experience of our empirical case study shows, the approach gets a relatively mature framework for design theory instruction. The integrated framework clearly expresses main objects and their relationship. This work promotes the development of parallel computing framework to have a qualitative leap, and eventually have more extensive application and popularization of the established framework.},
  doi       = {10.1109/TrustCom.2016.0343},
  file      = {:download_papers/Wu-2016-Meta-Model Evolution with Self-Adaptation An Empirical Development.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2324-9013},
  keywords  = {Big Data;object-oriented methods;parallel programming;software maintenance;software reusability;meta-model evolution;self-adaptation;distributed parallel computing;Big Data processing;object-oriented framework;systematic modeling;reusability;maintainability;hot-spots recognition;concept models;object models;dynamic models;data partitioning;job division;inter-node communication;incremental adaptation;iterative process;Parallel processing;Computational modeling;Object oriented modeling;Computer architecture;Unified modeling language;Software;Computers;big data processing;platform;distributed parallel computing;development approach;modeling;meta-model;evolution},
}

@Article{Wu2018,
  author        = {Wu, T. and Li, Q. and Wang, L. and He, L. and Li, Y.},
  journal       = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
  title         = {Using reinforcement learning to handle the runtime uncertainties in self-adaptive software},
  year          = {2018},
  note          = {cited By 2},
  pages         = {387-393},
  volume        = {11176 LNCS},
  abstract      = {The growth of scale and complexity of software as well as the complex environment with high dynamic lead to the uncertainties in self-adaptive software’s decision making at run time. Self-adaptive software needs the ability to avoid negative effects of uncertainties to the quality attributes of the software. However, existing planning methods cannot handle the two types of runtime uncertainties caused by complexity of system and running environment. This paper proposes a planning method to handle these two types of runtime uncertainties based on reinforcement learning. To handle the uncertainty from the system, the proposed method can exchange ineffective self-adaptive strategies to effective ones according to the iterations of execution effects at run time. It can plan dynamically to handle uncertainty from environment by learning knowledge of relationship between system states and actions. This method can also generate new strategies to deal with unknown situations. Finally, we use a complex distributed e-commerce system, Bookstore, to validate the ability of proposed method. © Springer Nature Switzerland AG 2018.},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-030-04771-9_28},
  file          = {:download_papers/Wu-2018-Using Reinforcement Learning To Ha.pdf:PDF},
  groups        = {scopus, systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85058578606&doi=10.1007%2f978-3-030-04771-9_28&partnerID=40&md5=6b20e5e80c7e0521e7d06c2d03e5ab6b},
}

@InProceedings{Xia2008,
  author    = {X. {Xia} and B. {Cao}},
  booktitle = {2008 International Conference on Computer Science and Software Engineering},
  title     = {The Design and Definition of Architecture-Centric Agent Self-Adaption Model},
  year      = {2008},
  month     = {Dec},
  pages     = {464-467},
  volume    = {2},
  abstract  = {This paper is to implement the architecture-centric self-adaption. The basic components is formally defined as agent abstraction, then their relations are establishment. Flexible pivot of models are ground on agent-oriented concept. By architecture rulespsila relationship, the implementation conditions are defined formally and abilities simulated. In final, self-adaptive architecture is gotten as "modularization of relations" and "relationship of models".},
  doi       = {10.1109/CSSE.2008.800},
  file      = {:download_papers/Xia-2008-The Design and Definition of Architecture-Centric Agent.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {object-oriented programming;software architecture;software reusability;architecture-centric agent self-adaption model;agent abstraction;agent-oriented concept;software reusability;Computer architecture;Computer science;Software quality;Decision making;Switches;Software engineering;Software design;Educational institutions;Programming;Visualization;Software Reusability;Architecture-centric;Agent;Self-adaptive;Modularization of Relations;Relationship of models},
}

@InProceedings{Xia2008a,
  author    = {X. {Xia} and B. {Cao}},
  booktitle = {2008 International Symposium on Intelligent Information Technology Application Workshops},
  title     = {The Self-Adaptive Design Model of Architecture-Centric Granularity Service Cluster},
  year      = {2008},
  month     = {Dec},
  pages     = {979-982},
  abstract  = {This paper discusses architecture-centric concept. For its adaptive all-purpose demand, decision-making and belief mechanism of agent is put forward, whose logic relations will be built. According to self-adaptive agent network mechanism, fine-grained service and coarse-grained service defined specifically. By AA/TT engine's topology process, service clusters are selected and optimized as agent group, that is implemented in architecture supported by Variation Facade.},
  doi       = {10.1109/IITA.Workshops.2008.79},
  file      = {:download_papers/Xia-2008-The Self-Adaptive Design Model of Architecture-Centric Granularity.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {belief maintenance;decision making;fault tolerant computing;multi-agent systems;software architecture;self-adaptive agent design model;architecture-centric granularity service cluster;decision-making;belief mechanism;fine-grained service;coarse-grained service;Decision making;Logic;Engines;Computer architecture;System buses;Encapsulation;Information technology;Application software;Computer science;Educational institutions;Architecture-centric;Agent;Facade Mode;Trusted Customer;Granularity;Service Cluster;Agent Group},
}

@InProceedings{Xu2013,
  author    = {C. {Xu} and {Wenhua Yang} and X. {Ma} and C. {Cao} and J. {L��}},
  booktitle = {2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE)},
  title     = {Environment rematching: Toward dependability improvement for self-adaptive applications},
  year      = {2013},
  month     = {Nov},
  pages     = {592-597},
  abstract  = {Self-adaptive applications can easily contain faults. Existing approaches detect faults, but can still leave some undetected and manifesting into failures at runtime. In this paper, we study the correlation between occurrences of application failure and those of consistency failure. We propose fixing consistency failure to reduce application failure at runtime. We name this environment rematching, which can systematically reconnect a self-adaptive application to its environment in a consistent way. We also propose enforcing atomicity for application semantics during the rematching to avoid its side effect. We evaluated our approach using 12 self-adaptive robot-car applications by both simulated and real experiments. The experimental results confirmed our approach's effectiveness in improving dependability for all applications by 12.5-52.5%.},
  doi       = {10.1109/ASE.2013.6693118},
  file      = {:download_papers/Xu-2013-Environment rematching Toward dependability improvement.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {automobiles;mobile robots;self-adjusting systems;environment rematching;dependability improvement;consistency failure;application failure;application semantics;self-adaptive robot-car applications;Noise measurement;Semantics;Correlation;Legged locomotion;Robot sensing systems;Consistency failure;environment rematching},
}

@InProceedings{Yang2010,
  author        = {Yang, Qiliang and L\"{u}, Jian and Li, Juelong and Ma, Xiaoxing and Song, Wei and Zou, Yang},
  booktitle     = {Proceedings of the Second Asia-Pacific Symposium on Internetware},
  title         = {Toward a Fuzzy Control-Based Approach to Design of Self-Adaptive Software},
  year          = {2010},
  address       = {New York, NY, USA},
  note          = {cited By 7},
  publisher     = {Association for Computing Machinery},
  series        = {Internetware ’10},
  abstract      = {Self-adaptive software is expected to adjust itself attributes or structures at runtime in response to changes. Aiming at addressing some challenging problems such as difficult mathematically modeling software using the current control theoretical methods, we propose a novel fuzzy-control-based approach to achieve self-adaptive software, which is presented as framework of fuzzy self-adaptive software (FFSAS). In this framework, the general model, the implementation architecture, and the design methodology are put forward and discussed in detail. The fuzzy-control-based approach is evaluated with a news-website case study.},
  art_number    = {15},
  articleno     = {15},
  document_type = {Conference Paper},
  doi           = {10.1145/2020723.2020738},
  file          = {:download_papers/Yang-2010-Toward a fuzzy control-based approach to design.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450306942},
  journal       = {Proceedings of the 2nd Asia-Pacific Symposium on Internetware, Internetware 2010},
  keywords      = {control theory, software methodology, fuzzy control, self-adaptive software, software engineering},
  location      = {Suzhou, China},
  numpages      = {4},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2020723.2020738},
}

@InProceedings{YiweiLei2015,
  author        = {{Yiwei Lei} and {Kerong Ben} and {Zhiyong He}},
  booktitle     = {2015 12th International Conference on Fuzzy Systems and Knowledge Discovery (FSKD)},
  title         = {A model driven agent-oriented self-adaptive software development method},
  year          = {2015},
  month         = {Aug},
  note          = {cited By 7},
  pages         = {2242-2246},
  abstract      = {Software running in dynamic open environments needs to be able to autonomously adapt to changing contexts, which challenges traditional software development methods. Based on the existing work, we present a model-driven agent-oriented adaptive software development method. During the requirement analysis phase, we extend the Tropos goal model with external context conditions and internal event conditions, which can be utilized to specify adaptive software variations. In the design phase, we present an architecture design method based on model transformations, and provide a solution to map the requirement model to the design model. During the implementation phase, we design an integrated development environment which combines the Jadex platform and the JADE middleware, and propose a detailed implementation process based on the integrated environment.},
  art_number    = {7382301},
  document_type = {Conference Paper},
  doi           = {10.1109/FSKD.2015.7382301},
  file          = {:download_papers/Lei-2015-A model driven agent-oriented self-adaptive software development.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {2015 12th International Conference on Fuzzy Systems and Knowledge Discovery, FSKD 2015},
  keywords      = {middleware;object-oriented programming;software architecture;model driven agent-oriented self-adaptive software development method;Tropos goal model;external context conditions;internal event conditions;requirement analysis phase;adaptive software variation;architecture design method;model transformation;JADE middleware;Jadex platform;Adaptation models;Fires;Software;Context;Unified modeling language;Object oriented modeling;Context modeling;model-driven development;self-adaptive software;BDI agent;model transformation},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84966642061&doi=10.1109%2fFSKD.2015.7382301&partnerID=40&md5=0c423f19d4d5eca22cd34ab6b7352796},
}

@InProceedings{Yu2015,
  author    = {D. {Yu} and Q. {Li} and L. {Wang} and Y. {Lin}},
  booktitle = {2015 IEEE 39th Annual Computer Software and Applications Conference},
  title     = {An Agent-Based Self-Adaptive Mechanism with Reinforcement Learning},
  year      = {2015},
  month     = {July},
  pages     = {582-585},
  volume    = {3},
  abstract  = {In order to solve the problem in choosing action for a system in a dynamic environment, a self-adaptive mechanism combining the technology of agent and reinforcement learning is presented in this paper. With such a mechanism, the system determines all possible initial states of the agent's execution strategy, and adopts Q-learning algorithm on all the initial states. And then, the best result of all learning results is chosen as the current execution strategy. Meanwhile, agents can share learning results to improve the efficiency of the system. At the end of this paper, a case study is illustrated to validate the effectiveness of the proposed mechanism.},
  doi       = {10.1109/COMPSAC.2015.276},
  file      = {:download_papers/Yu-2015-An Agent-Based Self-Adaptive Mechanism with  Reinforcement Learning.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {0730-3157},
  keywords  = {learning (artificial intelligence);multi-agent systems;agent-based self-adaptive mechanism;reinforcement learning;agent execution strategy;Q-learning algorithm;learning results;Learning (artificial intelligence);Software;Electronic mail;Algorithm design and analysis;Software engineering;Adaptive systems;Computers;multi-agent system; reinforcement learning; selfadaptive mechanism},
}

@InProceedings{Yuan2014,
  author        = {Yuan, Eric and Esfahani, Naeem and Malek, Sam},
  booktitle     = {Proceedings of the 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title         = {Automated Mining of Software Component Interactions for Self-Adaptation},
  year          = {2014},
  address       = {New York, NY, USA},
  note          = {cited By 11},
  pages         = {27–36},
  publisher     = {Association for Computing Machinery},
  series        = {SEAMS 2014},
  abstract      = {A self-adaptive software system should be able to monitor and analyze its runtime behavior and make adaptation decisions accordingly to meet certain desirable objectives. Traditional software adaptation techniques and recent\models@runtime approaches usually require an a priori model for a system's dynamic behavior. Oftentimes the model is difficult to define and labor-intensive to maintain, and tends to get out of date due to adaptation and architecture decay. We propose an alternative approach that does not require defining the system's behavior model beforehand, but in-stead involves mining software component interactions from system execution traces to build a probabilistic usage model, which is in turn used to analyze, plan, and execute adaptations. Our preliminary evaluation of the approach against an Emergency Deployment System shows that the associations mining model can be used to effectively address a variety of adaptation needs, including (1) safely applying dynamic changes to a running software system without creating inconsistencies, (2) identifying potentially malicious (abnormal) behavior for self-protection, and (3) our ongoing research on improving deployment of software components in a distributed setting for performance self-optimization.},
  document_type = {Conference Paper},
  doi           = {10.1145/2593929.2593934},
  file          = {:download_papers/Yuan-2014-Automated mining of software component interactions.pdf:PDF},
  groups        = {acm, wiley, systematic_search},
  isbn          = {9781450328647},
  journal       = {9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2014 - Proceedings},
  keywords      = {Self-Adaptation, Component-Based Software, Data Mining},
  location      = {Hyderabad, India},
  numpages      = {10},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2593929.2593934},
}

@InProceedings{Yun2015,
  author    = {Yun, Jaeyoung and Park, Jinsu and Baek, Woongki},
  booktitle = {Proceedings of the 52nd Annual Design Automation Conference},
  title     = {HARS: A Heterogeneity-Aware Runtime System for Self-Adaptive Multithreaded Applications},
  year      = {2015},
  address   = {New York, NY, USA},
  month     = {June},
  pages     = {1-6},
  publisher = {Association for Computing Machinery},
  series    = {DAC ’15},
  abstract  = {Heterogeneous multi-processing (HMP) is rapidly emerging as a promising solution for high-performance and low-power computing. Despite extensive prior work, system-software support for self-adaptive multithreaded applications has been little explored in the context of HMP. To bridge this gap, we propose HARS, a heterogeneity-aware runtime system for self-adaptive multithreaded applications. HARS continuously monitors the application performance and dynamically adapts the system state to enhance the performance/watt of the target self-adaptive multithreaded applications on HMP systems, while satisfying the user-specified performance goal. We quantify the effectiveness of HARS by demonstrating that HARS achieves significantly higher efficiency than the baseline version with the Linux HMP scheduler and comparable efficiency with that of the static optimal version.},
  articleno = {107},
  doi       = {10.1145/2744769.2744848},
  file      = {:download_papers/Yun-2015-HARS a heterogeneity-aware runtime system for self-adaptive.pdf:PDF},
  groups    = {acm, wiley, systematic_search},
  isbn      = {9781450335201},
  issn      = {0738-100X},
  keywords  = {heterogeneous multiprocessing, self-adaptive computing},
  location  = {San Francisco, California},
  numpages  = {6},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2744769.2744848},
}

@InProceedings{Zambonelli2011,
  author    = {F. {Zambonelli} and N. {Bicocchi} and G. {Cabri} and L. {Leonardi} and M. {Puviani}},
  booktitle = {2011 Fifth IEEE Conference on Self-Adaptive and Self-Organizing Systems Workshops},
  title     = {On Self-Adaptation, Self-Expression, and Self-Awareness in Autonomic Service Component Ensembles},
  year      = {2011},
  month     = {Oct},
  pages     = {108-113},
  abstract  = {Software systems operating in open-ended and unpredictable environments have to become autonomic, i.e., capable of dynamically adapting their behavior in response to changing situations. To this end, key research issues include: (i) framing the schemes that can facilitate components (or ensembles of) to exhibit self-adaptive behaviors, (ii) identifying mechanisms to enable components or ensembles to self-express the most suitable adaptation scheme, and (iii) acquiring the proper degree of self-awareness to enable putting in action self-adaptation and self-expression schemes. In this position paper, with the help of a representative case study, we frame and discuss the above issues, survey the state of the art in the area, and sketch the main research challenges that will be faced in the ASCENS project towards the definition of a fully-fledged framework for autonomic services.},
  doi       = {10.1109/SASOW.2011.24},
  file      = {:download_papers/Zambonelli-2011-On Self-Adaptation Self-Expression and Self-Awareness.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {fault tolerant computing;self-adaptation;self-expression;self-awareness;autonomic service component ensembles;software system;self-adaptive behavior;ASCENS project;Robot kinematics;Adaptation models;Software systems;Switches;Context;Self-adaptation;autonomic computing;self-awareness},
}

@Article{Zeadally2019,
  author        = {S. {Zeadally} and T. {Sanislav} and G. D. {Mois}},
  journal       = {IEEE Access},
  title         = {Self-Adaptation Techniques in Cyber-Physical Systems (CPSs)},
  year          = {2019},
  issn          = {2169-3536},
  note          = {cited By 0},
  pages         = {171126-171139},
  volume        = {7},
  abstract      = {Cyber-Physical Systems (CPSs) are large-scale complex systems that monitor and control physical processes by using computer algorithms tightly integrated with networking and their users. Monitoring and controlling the physical environment is a hot topic for today's researchers and engineers in academia and industry. Within this realm, an important feature of current and future Information and Communications Technology (ICT) systems is self-adaptation-yet there is a shortage of information focusing on this characteristic in the literature, particularly as it relates to CPSs. Here, we investigate current state-of-the-art research on CPSs from this perspective, and evaluate the main self-adaptive approaches proposed in the literature, along with their results, strengths, and weaknesses. We also discuss appropriate techniques for enabling self-adaptation capabilities within CPSs at different architectural layers. Overcoming the challenges associated with designing and implementing self-adaptive mechanisms in CPSs will provide a path for bolstering a new generation of CPSs with greater robustness and reliability.},
  art_number    = {8913497},
  document_type = {Article},
  doi           = {10.1109/ACCESS.2019.2956124},
  file          = {:download_papers/Zeadally-2019-Self-Adaptation Techniques in Cyber-Physical Systems (CPSs).pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {cyber-physical systems;software architecture;ICT systems;information and communications technology;self-adaptive mechanisms;self-adaptation capabilities;self-adaptive approaches;large-scale complex systems;cyber-physical systems;self-adaptation techniques;CPSs;Reliability;Cyber-physical systems;Monitoring;Software;Scalability;Computer architecture;Security;Adaptive systems;cyber-physical systems;self-adaptation},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85078403794&doi=10.1109%2fACCESS.2019.2956124&partnerID=40&md5=ac0ad13602e57ff214eb6867f0bbfc4a},
}

@InProceedings{Zeller2011,
  author    = {M. {Zeller} and C. {Prehofer} and G. {Weiss} and D. {Eilers} and R. {Knorr}},
  booktitle = {2011 IEEE Fifth International Conference on Self-Adaptive and Self-Organizing Systems},
  title     = {Towards Self-Adaptation in Real-Time, Networked Systems: Efficient Solving of System Constraints for Automotive Embedded Systems},
  year      = {2011},
  month     = {Oct},
  pages     = {79-88},
  abstract  = {While there has been considerable work on self-adaptive systems, applying these techniques to networked, embedded systems poses several new problems due to the requirements of embedded real-time systems. Among others, we have to consider memory and hardware limitations, as well as task schedulability and timing dependencies. The goal of this paper is to find a correct placement of software components efficiently, even though most of these individual constraints are highly intractable (NP-complete). This is a prerequisite for runtime adaptation in such domains and can be used for system optimization, extension or failure handling. We introduce an integrated model of system constraints for efficient computation of software component allocation, focusing on automotive embedded systems. For solving these, we have developed and compared two techniques based on SAT solving and Simulated Annealing, which enforce placement constraints efficiently. This reduces the size of the constraints significantly, but still leads to 2 million variables and more than 126 thousand equations in our case study with realistic automotive system settings. We show that both approaches provide solutions in several seconds on current commodity hardware, and show that SAT solving is more efficient for larger sets of equations.},
  doi       = {10.1109/SASO.2011.19},
  file      = {:download_papers/Zeller-2011-Towards Self-Adaptation in Real-Time Networked Systems Efficient.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1949-3681},
  keywords  = {automotive engineering;embedded systems;simulated annealing;self-adaptation;networked system;system constraint;automotive embedded system;self-adaptive system;embedded real-time system;system optimization;software component allocation;simulated annealing;realistic automotive system;commodity hardware;SAT solving;Automotive engineering;Actuators;Embedded systems;Resource management;Runtime;Sensors;runtime adaptation;networked embedded systems;automotive;constraints;allocation},
}

@InProceedings{Zhang2010,
  author        = {X. {Zhang} and C. {Lung}},
  booktitle     = {2010 IEEE 34th Annual Computer Software and Applications Conference},
  title         = {Improving Software Performance and Reliability with an Architecture-Based Self-Adaptive Framework},
  year          = {2010},
  month         = {July},
  note          = {cited By 7},
  pages         = {72-81},
  abstract      = {Modern computer systems for distributed service computing become highly complex and difficult to manage. A self-adaptive approach that integrates monitoring, analyzing, and actuation functionalities has the potential to accommodate to a dynamically changing environment. The main objective of this paper is to develop an architecture-based self-adaptive framework to improve performance and resource efficiency of a server while maintaining reliable services. The target problem is distributed and concurrent systems. This paper proposes a Self-Adaptive Framework for Concurrency Architecture (SAFCA) that includes multiple concurrency architectural patterns or alternatives. The framework has monitoring and managing capabilities that can invoke another architectural alternative at run-time to cope with increasing demands or for reliability purpose. Two control mechanisms have been developed: SAFCA-Q and SAFCA-R. With SAFCA-Q, the system does not need to be statically configured for the highest workloads; hence, resource usage becomes more efficient in normal conditions and the system still is able to handle busty demands. SAFCA-R is used to improve reliability in the case of a failure by conducting a switchover to another software architecture. Experiment results demonstrate that the performance of SAFCA-Q is better than systems using only standalone concurrency architecture and resources are also better utilized. SAFCA-R also shows fast recovery in the face of a failure.},
  art_number    = {5676339},
  document_type = {Conference Paper},
  doi           = {10.1109/COMPSAC.2010.68},
  file          = {:download_papers/Zhang-2010-Improving Software Performance and Reliability.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  issn          = {0730-3157},
  journal       = {Proceedings - International Computer Software and Applications Conference},
  keywords      = {distributed processing;fault tolerant computing;software architecture;software maintenance;software performance evaluation;software reliability;software performance;software reliability;architecture based selfadaptive framework;computer system;distributed service computing;dynamically changing environment;resource efficiency;reliable service maintainance;distributed system;concurrency architectural pattern;SAFCA-R;SAFCA-Q;resource usage;software architecture;Computer architecture;Concurrent computing;Servers;Instruction sets;Reliability;Monitoring;Lead;autonomic computing;software architecture;performance;reliability;distributed and concurrent architecture},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-78751698008&doi=10.1109%2fCOMPSAC.2010.68&partnerID=40&md5=6831d09b8143070ab29f0eebba2a8afb},
}

@InProceedings{Zhang2012,
  author    = {L. {Zhang} and C. {Xu} and X. {Ma} and T. {Gu} and X. {Hong} and C. {Cao} and J. {Lu}},
  booktitle = {2012 19th Asia-Pacific Software Engineering Conference},
  title     = {Resynchronizing Model-Based Self-Adaptive Systems with Environments},
  year      = {2012},
  month     = {Dec},
  pages     = {184-193},
  volume    = {1},
  abstract  = {Self-adaptive systems are attractive due to their ability of adapting to changeable environments automatically. However, such systems may be subject to runtime failures when all environmental dynamics cannot be adequately considered at design time. When such failures occur at runtime, a system's internal adaptation logic usually has become inconsistent with its environment, according to our observation. We call this inconsistency sync-loss error. From our project experiences, we empirically identified a strong correlation between sync-loss error and system failure. This motivated us to fix sync-loss error in order to reduce failure for self-adaptive systems. In this paper, we formulate the problem of detecting sync-loss error, and present a framework ReSync to automatically fix sync-loss errors by desynchronizing a system with its environment. We experimentally evaluated ReSync on real robot cars with 20 different system versions. The evaluation reported promising results that ReSync can automatically recover our robot car systems from sync-loss errors, and significantly reduce the failure rate from 90.9% to 11.7-28.8%.},
  doi       = {10.1109/APSEC.2012.62},
  file      = {:download_papers/Zhang-2012-Resynchronizing Model-Based Self-Adaptive Systems.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {1530-1362},
  keywords  = {adaptive control;automobiles;mobile robots;model-based self-adaptive system;changeable environment;environmental dynamics;internal adaptation logic;inconsistency sync-loss error detection;system failure;ReSync framework;robot car system;resynchronization;Robot sensing systems;Adaptation models;Runtime;Legged locomotion;Synchronization;Transient analysis;self-adaptive system;sync-loss error;resynchronization},
}

@InProceedings{Zhang2014,
  author        = {X. {Zhang} and B. {Li} and J. {Zhu}},
  booktitle     = {2014 Second International Conference on Advanced Cloud and Big Data},
  title         = {A Monitoring and Prediction Model of Workflow Based Self-Adaptive Software System},
  year          = {2014},
  month         = {Nov},
  note          = {cited By 3},
  pages         = {115-121},
  abstract      = {It is critical of self-adaptive software system to monitor all kinds of information in real-time and obtain relevant data of the system to make the system can adjust automatically when necessary. In order to cope with the current market needs and rapidly changing environment, and combine the Web services with self-adaptive software systems perfectly, we proposed a monitoring and prediction model for workflow based self-adaptive system (WSAS for short) based on our previous work, which gives users more flexibility in expressing requirements on the model level, provides dynamic QoS value calculation and prediction at run time, and can both monitors operating status of system in real-time and monitor the context of the system, allowing software systems to better meet users' changing needs, and the operating environment changes. We also proposed ratio dependent and variable exponential smooth prediction method for QoS based on above model. Finally, through some experiment, it confirms that the prediction method of this paper is feasible and effective.},
  art_number    = {7176080},
  document_type = {Conference Paper},
  doi           = {10.1109/CBD.2014.22},
  file          = {:download_papers/Zhang-2014-A Monitoring and Prediction Model of Workflow Based.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2014 2nd International Conference on Advanced Cloud and Big Data, CBD 2014},
  keywords      = {quality of service;Web services;workflow based self-adaptive software system;Web services;WSAS;dynamic QoS value calculation;dynamic QoS prediction;quality of service;Quality of service;Monitoring;Predictive models;Web services;Context;Data models;Prediction algorithms;Monitor;Self-adaptive System;QoS;Context;Exponential Smooth Predict},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84959552207&doi=10.1109%2fCBD.2014.22&partnerID=40&md5=aa7bfbcf761c5b3ca530d18ddfd69127},
}

@InProceedings{Zhao2016,
  author    = {T. {Zhao}},
  booktitle = {2016 IEEE 24th International Requirements Engineering Conference (RE)},
  title     = {The Generation and Evolution of Adaptation Rules in Requirements Driven Self-Adaptive Systems},
  year      = {2016},
  month     = {Sep.},
  pages     = {456-461},
  abstract  = {One of the challenges in self-adaptive software systems is to make adaptation plans in response to possible changes. A good plan mechanism shall have the capability of: 1) selecting the most appropriate adaptation actions in response to changes both in the environment and requirements, 2) making adaptation decisions efficiently to react timely to arising situations at run-time. In existing approaches for plan process, rule-based adaptation provides an efficient offline planning method. However, it can react neither to changeable requirements nor to unexpected environment changes. On the contrary, goal-based and utility-based approaches provide online planning mechanisms, which can well handle a highly uncertain environment with dynamically changing requirements and environment. However, online adaptation decision making is often computationally expensive and may encounter less-efficiency problems. The aim of our research is to improve the planning processin requirements driven self-adaptive systems, i.e., enabling the self-adaptive system to efficiently make adaptation plans to cope with the dynamic environment and changeable requirements. To achieve such advantages, we propose a solution to enhance the traditional rule-based adaptation with a rule generation and a rule evolution process, so that the proposed approach can maintain the advantages of efficient planning process while being enhanced with the capability of dealing with runtime uncertainty.},
  doi       = {10.1109/RE.2016.18},
  file      = {:download_papers/Zhao-2016-The Generation and Evolution of Adaptation Rules in Requirements.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2332-6441},
  keywords  = {decision making;formal specification;knowledge based systems;runtime uncertainty;dynamic environment;planning processing requirements;online adaptation decision making;online planning mechanisms;utility-based approaches;goal-based approaches;offline planning method;rule-based adaptation;plan process;adaptation actions;requirements driven self-adaptive software systems;adaptation rule evolution;adaptation rule generation;Planning;Learning (artificial intelligence);Algorithm design and analysis;Software algorithms;Machine learning algorithms;Software systems;requirement driven self-adaptation;adaptation plan;reinforcement learning;case-based reasoning},
}

@InProceedings{Zhong2019,
  author    = {Y. {Zhong} and Z. {Zhou} and D. {Li} and M. {Guo} and Q. {Liu} and Y. {Liu} and L. {Guo}},
  booktitle = {2019 IEEE Intl Conf on Parallel Distributed Processing with Applications, Big Data Cloud Computing, Sustainable Computing Communications, Social Computing Networking (ISPA/BDCloud/SocialCom/SustainCom)},
  title     = {SAED: A Self-Adaptive Encryption and Decryption Architecture},
  year      = {2019},
  month     = {Dec},
  pages     = {388-397},
  abstract  = {The Transport Layer Security (TLS) and Secure Socket Layer (SSL) are currently the predominant protocols to provide information security and data integrity between two communication endpoints. However, with dramatically increased network traffic, the cryptography algorithms used in SSL/TLS for encryption and decryption introduce substantial computation overhead due to the expensive CPU execution time. To accelerate the complex encryption computation, researchers have proposed novel architectures based hardware accelerators such as FPGAs, which can handle a massive amount of offloaded traffic with complex processing at very high throughput. In this paper, we study the real-world traffic workload and find that the performance of several crypto algorithms is heavily data-dependent: for small packets, software-based encryption and decryption solutions outperform hardware-based solutions, while hardwarebased solutions show higher processing speed for large packets. So there is no one-size-fits-all solution for packet processing. As a result, we propose a software-hardware co-design with quick assist technology. It combines both advantages of softwareand hardware-based approaches and be able to choose the optimal cryptography solution dynamically based on traffic status and system state. Our evaluation shows that our proposed architecture could achieve high throughput for encrypted traffic on a secured network compared to pure software or hardware solutions.},
  doi       = {10.1109/ISPA-BDCloud-SustainCom-SocialCom48970.2019.00063},
  file      = {:download_papers/Zhong-2019-SAED A Self-Adaptive Encryption and Decryption Architecture.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {cryptography;field programmable gate arrays;telecommunication traffic;pure software;SAED;self-adaptive encryption;decryption architecture;transport layer security;secure socket layer;predominant protocols;information security;data integrity;communication endpoints;dramatically increased network traffic;cryptography algorithms;expensive CPU execution time;complex encryption computation;hardware accelerators;offloaded traffic;complex processing;real-world traffic workload;crypto algorithms;software-based encryption;decryption solutions;hardware-based solutions;hardwarebased solutions;higher processing speed;one-size-fits-all solution;packet processing;software-hardware codesign;softwareand hardware-based approaches;optimal cryptography solution;traffic status;system state;encrypted traffic;secured network;software hardware co-design, self-adaption, parallel acceleration},
}

@InProceedings{Zhou2018a,
  author    = {Z. {Zhou} and X. {Zhang} and Q. {Liu} and Y. {Zhu} and D. {Li} and L. {Guo}},
  booktitle = {2018 IEEE Global Communications Conference (GLOBECOM)},
  title     = {SASD: A Self-Adaptive Stateful Decompression Architecture},
  year      = {2018},
  month     = {Dec},
  pages     = {206-212},
  abstract  = {Due to the increasing threats in the current network environment, many researchers have shifted their interests to network content audit, which combines deep packet inspection and natural language processing. However, the performance of network content audit systems is becoming the bottle-neck because of the demand on processing fast growing compressed traffic. While compressed traffic is often split into multiple out-of-order packets for transmission, stateful decompression ensures that the compressed data are processed in a timely manner without waiting for all the compressed traffic to arrive before decompressing. In the meanwhile, hardware innovations lead to new type of devices being invented, which shows promise to fully handle the offloaded traffic for complex calculations at higher throughput than software-based solutions. We consider both software-based and hardware-based solutions for decompressing traffic from network content audit systems and study the workload. We notice that the performance is data-dependant: hardware-based decompression solutions perform better for longer compressed data than software method. On the contrary, software-based decompressing methods are more preferred for the short content in terms of the processing speed. So there is no one-size-fits-all solution. In this paper, we combine the advantages of hardware and software and propose a novel self-adaptive stateful decompression architecture to support fast decompression in accordance with the traffic status and system state. Experiments on real-world traffic show that our proposed architecture can achieve about three times of the data decompression efficiency, compared to the best pure software and hardware algorithm, which can significantly improve the detection efficiency of many network content audit systems.},
  doi       = {10.1109/GLOCOM.2018.8647636},
  file      = {:download_papers/Zhou-2018-SASD A Self-Adaptive Stateful Decompression Architecture.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2576-6813},
  keywords  = {data compression;Internet;telecommunication traffic;self-adaptive stateful decompression architecture;SASD;software-based decompressing methods;offloaded traffic;compressed traffic;network content audit systems;data decompression efficiency;traffic status;Hardware;Software;Computer architecture;Monitoring;Industries;Security;Protocols},
}

@Article{Zhou2019,
  author        = {P. {Zhou} and D. {Zuo} and K. {Hou} and Z. {Zhang} and J. {Dong}},
  journal       = {IEEE Transactions on Reliability},
  title         = {Improving the Dependability of Self-Adaptive Cyber Physical System With Formal Compositional Contract},
  year          = {2019},
  issn          = {1558-1721},
  note          = {cited By 0},
  pages         = {1-17},
  abstract      = {To adapt to the uncertain environment smartly and timely, cyber physical systems (CPSs) have to interact with the physical world in a decentralized but rigorous, organized way. Guaranteeing the timing reliability is key to achieve consensus on the order of distributed events, as well as dependable cooperative decision processing. Based on our hierarchically decentralized compositional self-adaptive framework, we propose a formal compositional reliability-contract-based solution to guarantee the timing reliability of event observation and decision processing in a large-scale, geographically distributed CPS. As the prophetic decision may not fit the local situation well because of the uncertainties, we propose a gradual contract optimization solution to refine the dependability, timeliness, and energy consumption. Following the seven proposed composition schemes, we employ the nondominated sorting genetic algorithm II (NSGA-II) algorithm to optimize arrangement of decision. Moreover, a topology-aware time reserving solution is applied to improve the resilience of processing time and to tolerance timing failures. Both simulation results and real-world testing are introduced to evaluate the efficacy of our proposal. We believe that the formal compositional contract will be a competitive CPS solution to analyze requirements and optimize the self-adaptation decision at runtime.},
  document_type = {Article},
  doi           = {10.1109/TR.2019.2930009},
  file          = {:download_papers/Zhou-2020-Improving the Dependability of Self-Adaptive Cyber Physical System.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  keywords      = {Contracts;Timing;Actuators;Sensors;Runtime;Redundancy;Compositional contract;cyber physical systems (CPSs);model@run.time;NSGA-II;self-adaptation;timing reliability},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85072520553&doi=10.1109%2fTR.2019.2930009&partnerID=40&md5=71ad07d8ab85240bf62c66e97cd188ec},
}

@InProceedings{Zolfpour-Arokhlo2011,
  author    = {M. {Zolfpour-Arokhlo} and A. {Selamat} and S. Z. M. {Hashim}},
  booktitle = {2011 Malaysian Conference in Software Engineering},
  title     = {Self-adaptive and multi-agent reinforcement learning in route guidance system},
  year      = {2011},
  month     = {Dec},
  pages     = {383-387},
  abstract  = {Several challenges in traffic control in route guidance system causes increasing number of vehicles to transport goods and people in our society. The concept of autonomous agents fits most actors in transportation systems: the traffic, the expert, the driver. More so, traffic signals and intersection can also be regarded as an autonomous agent. Though, there are increased number of agents, typical agents make response to changes in their environment and are highly self-adaptive, but create an unpredictable collective pattern, and response in a highly coupled environment, most challenges for standard techniques are created by this domain in route guidance system from multi-agent systems such as reinforcement learning and self-adaptive. This research has two main goals in route guidance system: first, to present problems, methods, new approaches; and second, open problems and challenges are highlighted so that future research in route guidance system using multi-agent systems will be able to address them.},
  doi       = {10.1109/MySEC.2011.6140702},
  file      = {:download_papers/Zolfpour-Arokhlo-2011-Self-adaptive and multi-agent reinforcement learning.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {learning (artificial intelligence);multi-agent systems;traffic control;multiagent reinforcement learning;route guidance system;traffic control;transportation systems;multiagent systems;autonomous agent;unpredictable collective pattern;Vehicles;Multiagent systems;Learning;Roads;Mathematical model;Adaptation models;self-adaptive multi-agent system (SAMAS);route guidance system (RGS);multi-agent reinforcement learning (MARL);shortest path problem (SPP)},
}

@InProceedings{Zou2016,
  author        = {L. {Zou} and H. {Yang} and L. {Xu}},
  booktitle     = {2016 IEEE International Conference on Software Quality, Reliability and Security Companion (QRS-C)},
  title         = {An Approach to Controlling Context by Combining Game Theory and Control Theory for Self-Adaptive Software in Creative Computing},
  year          = {2016},
  month         = {Aug},
  note          = {cited By 0},
  pages         = {311-317},
  abstract      = {Self-adaptive software is widely-use for users who need to output varies results after responding from changing environment. The results are normally followed by the Control Theory in order to be constructed in a rigid feedback loop. According to the Control Theory, the controller is designed to measure result errors for the purpose of re-inputs of edited results into the system. The research in the paper proposes an approach to improving the context-aware ability of controller by designing a controller that enhance the self-adaptive software to solve both certain and uncertain problems especially in business. The controller relies on both Control Theory based modules and combination based module, in order to generate outputs including but not limited to activities based on costs or balanced scorecards through adding business context sensors, and create feedback loop to test differences for each module. When the proposed controller is established in self-adaptive software, it is important to extract and filter business information due to user demands, and make software to react itself in a changing environment. In summary, a designed controller model will help self-adaptive software to understand users' need and requirements clearly, so that not only existing parameters could be changed, but also the self-adaptive software can be made to to gain the ability to modify the parameter itself, and more importantly, a good context-aware controlled self-adaptive software could save costs for organisations in addition to improving the effectiveness and efficiency for business in a creative way.},
  art_number    = {7573763},
  document_type = {Conference Paper},
  doi           = {10.1109/QRS-C.2016.48},
  file          = {:download_papers/Zou-2016-An Approach to Controlling Context by Combining Game Theory.pdf:PDF},
  groups        = {ieee, wiley, systematic_search},
  journal       = {Proceedings - 2016 IEEE International Conference on Software Quality, Reliability and Security-Companion, QRS-C 2016},
  keywords      = {control system analysis computing;control system synthesis;feedback;game theory;self-adjusting systems;ubiquitous computing;context control;game theory;self-adaptive software;creative computing;feedback loop;controller design;context-aware ability;control theory based modules;combination based module;users need;users requirements;Software;Context;Game theory;Control theory;Creativity;Context modeling;Game Theory;Control Theory;Context-Awareness;Decision Making;Semantic Web;Creative Computing},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84991746033&doi=10.1109%2fQRS-C.2016.48&partnerID=40&md5=fe2e06cb9142408e03ce6809e82974b6},
}

@InProceedings{Zouari2010,
  author    = {M. {Zouari} and M. {Segarra} and F. {Andr��}},
  booktitle = {2010 10th IEEE International Conference on Computer and Information Technology},
  title     = {A Framework for Distributed Management of Dynamic Self-adaptation in Heterogeneous Environments},
  year      = {2010},
  month     = {June},
  pages     = {265-272},
  abstract  = {Ubiquitous computing environments are becoming more heterogeneous and highly dynamic. Systems need to dynamically self-adapt in order to accommodate dynamically changing resources, needs of different users and failure events. This paper focuses on the runtime adaptation mechanisms that need to be dealt with the distributed nature of systems and the heterogeneity of the environment. We tackle the problem of distributed management of dynamic adaptation where separate adaptation processes are performed concurrently. We elaborate mechanisms to coordinate adaptation processes in order to improve the correctness of the system during and after the adaptation. We implement a framework that offers the required support for distributed management of adaptability. The framework is customizable to meet application-specific requirements and the operating environment characteristics. Our focus will be on the architectural principles and the coordination mechanisms of the framework. We developed a self-adaptive replication system based on our framework for the specification and the enforcement of the adaptation mechanisms.},
  doi       = {10.1109/CIT.2010.78},
  file      = {:download_papers/Zouari-2010-A Framework for Distributed Management of Dynamic Self-adaptation.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {adaptive systems;distributed object management;ubiquitous computing;distributed management;dynamic selfadaptation;heterogeneous environments;ubiquitous computing environments;runtime adaptation mechanisms;coordinate adaptation processes;application-specific requirements;operating environment characteristics;selfadaptive replication system;Context;Adaptation model;Protocols;Computer architecture;Software;Quality of service;Engines;software architecture;self-adaptability;distributed system;data management},
}

@Article{Affonso2015Selfadaptivesoftware,
  author    = {Frank Jos{\'{e}} Affonso and Elisa Yumi Nakagawa},
  journal   = {Revista Brasileira de Computa{\c{c}}{\~{a}}o Aplicada},
  title     = {Self-adaptive software: development approach and automatic process for adaptation at runtime},
  year      = {2015},
  month     = {apr},
  number    = {1},
  volume    = {7},
  abstract  = {The development of Self-adaptive Software (SaS) is a complex task, since this type of software constantly deals with structural and/or behavioral changes at runtime so that the needs of its users or its execution environment are met. Although important initiatives in the area of Software Engineering for SaS (SE4SaS), including approaches, processes, methods, and techniques for the SaS development, can be found in the literature. Approaches with automated support need to be explored, since they are an alternative to maximize the speed of SaS implementation and, at the same time, minimize the involvement of developers. Based on this scenario, this article presents an approach with automated support for the SaS development. It acts on a controlled adaptation modality, i.e., software engineers define the adaptation level supported by SaS in the development stage and the SaS can be automatically adapted without the participation of developers. Case studies were conducted for the evaluation of our approach. The results show that this approach can effectively contribute to the SE4SaS area.},
  doi       = {10.5335/rbca.2015.4224},
  file      = {:download_papers/Affonso-2015-Self-adaptive Software Development Approach and Automatic.pdf:PDF},
  groups    = {Model-based, expert_search},
  publisher = {{UPF} Editora},
}

@Article{Amoui2012Achievingdynamicadaptation,
  author    = {Mehdi Amoui and Mahdi Derakhshanmanesh and Jürgen Ebert and Ladan Tahvildari},
  journal   = {Journal of Systems and Software},
  title     = {Achieving dynamic adaptation via management and interpretation of runtime models},
  year      = {2012},
  month     = {dec},
  number    = {12},
  pages     = {2720--2737},
  volume    = {85},
  abstract  = {In this article, we present a generic model-centric approach for realizing fine-grained dynamic adaptation in software systems by managing and interpreting graph-based models of software at runtime. We implemented this approach as the Graph-based Runtime Adaptation Framework (GRAF), which is particularly tailored to facilitate and simplify the process of evolving and adapting current software towards runtime adaptivity. As a proof of concept, we present case study results that show how to achieve runtime adaptivity with GRAF and sketch the framework's capabilities for facilitating the evolution of real-world applications towards self-adaptive software. The case studies also provide some details of the GRAF implementation and examine the usability and performance of the approach.},
  doi       = {10.1016/j.jss.2012.05.033},
  file      = {:download_papers/Amoui-2010-Achieving dynamic adaptation via management and interpretation.pdf:PDF},
  groups    = {Model-based, expert_search},
  publisher = {Elsevier {BV}},
}

@InProceedings{Asadollahi2009StarMXframeworkdeveloping,
  author    = {Reza Asadollahi and Mazeiar Salehie and Ladan Tahvildari},
  booktitle = {2009 {ICSE} Workshop on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {{StarMX}: A framework for developing self-managing Java-based systems},
  year      = {2009},
  month     = {may},
  publisher = {{IEEE}},
  abstract  = {Realizing self-managing systems poses several development and operational challenges. Reusable software frameworks assist in addressing these challenges by utilizing appropriate patterns, and also providing essential runtime services for self-managing systems. This paper presents the StarMX framework, designed for building self-managing Java-based applications. It is a generic framework based on standards and well-established principles, and supports common tasks in the development of such systems. StarMX facilitates creating the management closed loop using various mechanisms such as action policies. The framework architecture and its utilization process, along with an example of its application are presented in this paper. Moreover, quality attributes and autonomic characteristics of the proposed framework are discussed.},
  doi       = {10.1109/seams.2009.5069074},
  file      = {:download_papers/Asadollahi-2009-StarMX  A Framework for Developing Self-Managing.pdf:PDF},
  groups    = {Architectural-based, expert_search},
}

@InProceedings{Baresi2010FuzzyGoalsRequirements,
  author    = {Luciano Baresi and Liliana Pasquale and Paola Spoletini},
  booktitle = {2010 18th {IEEE} International Requirements Engineering Conference},
  title     = {Fuzzy Goals for Requirements-Driven Adaptation},
  year      = {2010},
  month     = {sep},
  publisher = {{IEEE}},
  abstract  = {Self-adaptation is imposing as a key characteristic of many modern software systems to tackle their complexity and cope with the many environments in which they can operate. Self-adaptation is a requirement per-se, but it also impacts the other (conventional) requirements of the system; all these new and old requirements must be elicited and represented in a coherent and homogenous way. This paper presents FLAGS, an innovative goal model that generalizes the KAOS model, adds adaptive goals to embed adaptation countermeasures, and fosters self-adaptation by considering requirements as live, runtime entities. FLAGS also distinguishes between crisp goals, whose satisfaction is boolean, and fuzzy goals, whose satisfaction is represented through fuzzy constraints. Adaptation countermeasures are triggered by violated goals and the goal model is modified accordingly to maintain a coherent view of the system and enforce adaptation directives on the running system. The main elements of the approach are demonstrated through an example application.},
  doi       = {10.1109/re.2010.25},
  file      = {:download_papers/Baresi-2010-Fuzzy goals for requirements-driven adaptation..pdf:PDF},
  groups    = {Model-based, expert_search},
}

@InProceedings{Baresi2010Livegoalsadaptive,
  author    = {Luciano Baresi and Liliana Pasquale},
  booktitle = {Proceedings of the 2010 {ICSE} Workshop on Software Engineering for Adaptive and Self-Managing Systems - {SEAMS} {\textquotesingle}10},
  title     = {Live goals for adaptive service compositions},
  year      = {2010},
  publisher = {{ACM} Press},
  abstract  = {Service compositions represent an important family of self-adaptive systems. Though many approaches for monitoring and adapting service compositions have already been proposed, a clear connection with the motivations for using such techniques is still missing. To this aim we address self-adaptation from requirements elicitation down to execution. In this paper, we propose to enrich existing goal models with adaptive goals, responsible for the actual evolution/adaptation of the goal model at runtime. We also translate the goal model with both conventional and adaptive goals, into the actual functionality provided by the system and the adaptation policies needed to make it self-adapt.},
  doi       = {10.1145/1808984.1808997},
  file      = {:download_papers/Baresi-2010-Live goals for adaptive service compositions.pdf:PDF},
  groups    = {Model-based, expert_search},
}

@InProceedings{Bartels2011CSPbasedframework,
  author    = {Björn Bartels and Moritz Kleine},
  booktitle = {Proceeding of the 6th international symposium on Software engineering for adaptive and self-managing systems - {SEAMS} {\textquotesingle}11},
  title     = {A {CSP}-based framework for the specification, verification, and implementation of adaptive systems},
  year      = {2011},
  publisher = {{ACM} Press},
  doi       = {10.1145/1988008.1988030},
  file      = {:download_papers/Bartels-2011-A CSP-based framework for the specification, verification.pdf:PDF},
  groups    = {Formal-method, expert_search},
}

@Article{Bracciali2005formalapproachcomponent,
  author    = {Andrea Bracciali and Antonio Brogi and Carlos Canal},
  journal   = {Journal of Systems and Software},
  title     = {A formal approach to component adaptation},
  year      = {2005},
  month     = {jan},
  number    = {1},
  pages     = {45--54},
  volume    = {74},
  abstract  = {Component adaptation is widely recognised to be one of the crucial problems in Component-Based Software Engineering (CBSE). We present a formal methodology for adapting components with mismatching interaction behaviour. The three main ingredients of the methodology are: (1) the inclusion of behaviour specifications in component interfaces, (2) a simple, high-level notation for expressing adaptor specifications, and (3) a fully automated procedure to derive concrete adaptors from given high-level specifications.},
  doi       = {10.1016/j.jss.2003.05.007},
  file      = {:download_papers/Bracciali-2005-A formal approach to component adaptation.pdf:PDF},
  groups    = {Formal-method, expert_search},
  publisher = {Elsevier {BV}},
}

@InCollection{Caporuscio2016ReinforcementLearningTechniques,
  author    = {M. Caporuscio and M. D'Angelo and V. Grassi and R. Mirandola},
  booktitle = {Service-Oriented and Cloud Computing},
  publisher = {Springer International Publishing},
  title     = {Reinforcement Learning Techniques for Decentralized Self-adaptive Service Assembly},
  year      = {2016},
  pages     = {53--68},
  abstract  = {This paper proposes a self-organizing fully decentralized solution for the service assembly problem, whose goal is to guarantee a good overall quality for the delivered services, ensuring at the same time fairness among the participating peers. The main features of our solution are: (i) the use of a gossip protocol to support decentralized information dissemination and decision making, and (ii) the use of a reinforcement learning approach to make each peer able to learn from its experience the service selection rule to be followed, thus overcoming the lack of global knowledge. Besides, we explicitly take into account load-dependent quality attributes, which lead to the definition of a service selection rule that drives the system away from overloading conditions that could adversely affect quality and fairness. Simulation experiments show that our solution self-adapts to occurring variations by quickly converging to viable assemblies maintaining the specified quality and fairness objectives.},
  doi       = {10.1007/978-3-319-44482-6_4},
  file      = {:download_papers/Caporuscio-2016-Reinforcment learning techniques for decentralized.pdf:PDF},
  groups    = {Learning, Formal-method, expert_search},
}

@Article{Chaari2007comprehensiveapproachmodel,
  author    = {Tarak Chaari and Dejene Ejigu and Fr{\'{e}}d{\'{e}}rique Laforest and Vasile-Marian Scuturici},
  journal   = {Journal of Systems and Software},
  title     = {A comprehensive approach to model and use context for adapting applications in pervasive environments},
  year      = {2007},
  month     = {dec},
  number    = {12},
  pages     = {1973--1992},
  volume    = {80},
  abstract  = {With an increasing diversity of pervasive computing devices integrated in our surroundings and an increasing mobility of users, it will be important for computer systems and applications to be context-aware. Lots of works have already been done in this direction on how to capture context data and how to carry it to the application. Among the remaining challenges are to create the intelligence to analyze the context information and deduce the meaning out of it, and to integrate it into adaptable applications. Our work focuses on these challenges by defining generic context storage and processing model and by studying its impact on the application core. We propose a reusable context ontology model that is based on two levels: a generic level and a domain specific level. We propose a generic adaptation framework to guarantee adaptation of applications to the context in a pervasive computing environment. We also introduce a comprehensive adaptation approach that involves content adaptation and presentation adaptation inline with the adaptation of the core services of applications. Our case study shows that the context model and the application adaptation strategies provide promising service architecture.},
  doi       = {10.1016/j.jss.2007.03.010},
  file      = {:download_papers/Chaari-2007-A comprehensive approach to model and use context.pdf:PDF},
  groups    = {Model-based, expert_search},
  publisher = {Elsevier {BV}},
}

@InProceedings{Epifani2009Modelevolutionrun,
  author    = {Ilenia Epifani and Carlo Ghezzi and Raffaela Mirandola and Giordano Tamburrelli},
  booktitle = {2009 {IEEE} 31st International Conference on Software Engineering},
  title     = {Model evolution by run-time parameter adaptation},
  year      = {2009},
  publisher = {{IEEE}},
  abstract  = {Models can help software engineers to reason about design-time decisions before implementing a system. This paper focuses on models that deal with non-functional properties, such as reliability and performance. To build such models, one must rely on numerical estimates of various parameters provided by domain experts or extracted by other similar systems. Unfortunately, estimates are seldom correct. In addition, in dynamic environments, the value of parameters may change over time. We discuss an approach that addresses these issues by keeping models alive at run time and feeding a Bayesian estimator with data collected from the running system, which produces updated parameters. The updated model provides an increasingly better representation of the system. By analyzing the updated model at run time, it is possible to detect or predict if a desired property is, or will be, violated by the running implementation. Requirement violations may trigger automatic reconfigurations or recovery actions aimed at guaranteeing the desired goals. We illustrate a working framework supporting our methodology and apply it to an example in which a Web service orchestrated composition is modeled through a discrete time Markov chain. Numerical simulations show the effectiveness of the approach.},
  doi       = {10.1109/icse.2009.5070513},
  file      = {:download_papers/Epifani-2009-Model Evolution by Run-Time Parameter Adaptation.pdf:PDF},
  groups    = {Model-based, expert_search},
}

@InCollection{Geihs2009ModelingContextAware,
  author    = {Kurt Geihs and Roland Reichle and Michael Wagner and Mohammad Ullah Khan},
  booktitle = {Software Engineering for Self-Adaptive Systems},
  publisher = {Springer Berlin Heidelberg},
  title     = {Modeling of Context-Aware Self-Adaptive Applications in Ubiquitous and Service-Oriented Environments},
  year      = {2009},
  pages     = {146--163},
  abstract  = {Mobile computing in ubiquitous environments has to cope with both predictable and unpredictable changes in the execution context, which introduces the need for context-aware adaptive applications. Such environments are also characterized by dynamically discoverable services that can be utilized by applications to improve their functionality and quality of service (QoS). Thus, application adaptation decisions not only depend on context properties, but also on service availability and QoS-properties. In this chapter we present a novel comprehensive modeling approach that facilitates the model-driven development of such applications. Our focus is on modeling concepts which align the description of services and their QoS-properties with the context modeling approach. We provide a harmonized view on context and service properties, bridging the syntactical and semantic differences through an ontology. We also consider related aspects like semantic service discovery and service level agreements.},
  doi       = {10.1007/978-3-642-02161-9_8},
  file      = {:download_papers/Geihs-2009-ModelingContextAware.pdf:PDF},
  groups    = {Model-based, expert_search},
}

@InCollection{Gerostathopoulos2015MetaAdaptationStrategies,
  author    = {Ilias Gerostathopoulos and Tomas Bures and Petr Hnetynka and Adam Hujecek and Frantisek Plasil and Dominik Skoda},
  booktitle = {Software Architecture},
  publisher = {Springer International Publishing},
  title     = {Meta-Adaptation Strategies for Adaptation in Cyber-Physical Systems},
  year      = {2015},
  pages     = {45--52},
  abstract  = {Modern Cyber-Physical Systems (CPS) not only need to be dependable, but also resilient to and able to adapt to changing situations in their environment. When developing such CPS, however, it is often impossible to anticipate all potential situations upfront and provide corresponding tactics. Situations that lie out of this “envelope of adaptability” can lead to problems that range from single component malfunctioning to complete system failure. The existing approaches to self-adaptation cannot typically cope with such situations as they still rely on a fixed set of tactics, which in case of complex systems does not guarantee achieving correct functionality. To alleviate this problem, we propose the concept of meta-adaptation strategies, which extends the limits of adaptability of a system by constructing new tactics at runtime to reflect the changes in the environment. The approach is demonstrated on an existing architecture-based self-adaptation method and exemplified by two concrete meta-adaptation strategies.},
  doi       = {10.1007/978-3-319-23727-5_4},
  file      = {:download_papers/Gerostathopoulos-2015-Meta-Adaptation Strategies for Adaptation.pdf:PDF},
  groups    = {Architectural-based, expert_search},
}

@Article{Hallsteinsen2012developmentframeworkmethodology,
  author    = {S. Hallsteinsen and K. Geihs and N. Paspallis and F. Eliassen and G. Horn and J. Lorenzo and A. Mamelli and G.A. Papadopoulos},
  journal   = {Journal of Systems and Software},
  title     = {A development framework and methodology for self-adapting applications in ubiquitous computing environments},
  year      = {2012},
  month     = {dec},
  number    = {12},
  pages     = {2840--2859},
  volume    = {85},
  abstract  = {Today software is the main enabler of many of the appliances and devices omnipresent in our daily life and important for our well being and work satisfaction. It is expected that the software works as intended, and that the software always and everywhere provides us with the best possible utility. This paper discusses the motivation, technical approach, and innovative results of the MUSIC project. MUSIC provides a comprehensive software development framework for applications that operate in ubiquitous and dynamic computing environments and adapt to context changes. Context is understood as any information about the user needs and operating environment which vary dynamically and have an impact on design choices. MUSIC supports several adaptation mechanisms and offers a model-driven application development approach supported by a sophisticated middleware that facilitates the dynamic and automatic adaptation of applications and services based on a clear separation of business logic, context awareness and adaptation concerns. The main contribution of this paper is a holistic, coherent presentation of the motivation, design, implementation, and evaluation of the MUSIC development framework and methodology.},
  doi       = {10.1016/j.jss.2012.07.052},
  file      = {:download_papers/Hallsteinsen-2012-A development framework and methodology for self-adapting.pdf:PDF},
  groups    = {Model-based, expert_search},
  publisher = {Elsevier {BV}},
}

@Article{Sama2010ContextAwareAdaptive,
  author    = {Michele Sama and Sebastian Elbaum and Franco Raimondi and David S. Rosenblum and Zhimin Wang},
  journal   = {{IEEE} Transactions on Software Engineering},
  title     = {Context-Aware Adaptive Applications: Fault Patterns and Their Automated Identification},
  year      = {2010},
  month     = {sep},
  number    = {5},
  pages     = {644--661},
  volume    = {36},
  abstract  = {Applications running on mobile devices are intensely context-aware and adaptive. Streams of context values continuously drive these applications, making them very powerful but, at the same time, susceptible to undesired configurations. Such configurations are not easily exposed by existing validation techniques, thereby leading to new analysis and testing challenges. In this paper, we address some of these challenges by defining and applying a new model of adaptive behavior called an Adaptation Finite-State Machine (A-FSM) to enable the detection of faults caused by both erroneous adaptation logic and asynchronous updating of context information, with the latter leading to inconsistencies between the external physical context and its internal representation within an application. We identify a number of adaptation fault patterns, each describing a class of faulty behaviors. Finally, we describe three classes of algorithms to detect such faults automatically via analysis of the A-FSM. We evaluate our approach and the trade-offs between the classes of algorithms on a set of synthetically generated Context-Aware Adaptive Applications (CAAAs) and on a simple but realistic application in which a cell phone's configuration profile changes automatically as a result of changes to the user's location, speed, and surrounding environment. Our evaluation describes the faults our algorithms are able to detect and compares the algorithms in terms of their performance and storage requirements.},
  doi       = {10.1109/tse.2010.35},
  file      = {:download_papers/Sama-2010-Context-Aware Adaptive Applications Fault Patterns.pdf:PDF},
  groups    = {Formal-method, expert_search},
  publisher = {Institute of Electrical and Electronics Engineers ({IEEE})},
}

@Article{Seceleanu2006Developingadaptivesystems,
  author    = {Tiberiu Seceleanu and David Garlan},
  journal   = {Journal of Systems and Software},
  title     = {Developing adaptive systems with synchronized architectures},
  year      = {2006},
  month     = {nov},
  number    = {11},
  pages     = {1514--1526},
  volume    = {79},
  abstract  = {In this paper we show how to specify and refine self-adapting systems, by employing the state-based formalism called action systems. Assuming a fixed set of possible configurations, we use a recently-introduced synchronization operator to achieve separation of concerns between adaptation policy, fault tolerance and steady-state system execution. Using action systems allows us to apply standard refinement techniques, aimed for correct implementations of higher-level models. We illustrate this idea by applying it to the problem of coping with dynamically-varying user requirements and possible fault situations.},
  doi       = {10.1016/j.jss.2006.03.047},
  file      = {:download_papers/Seceleanu-2006-Developing adaptive systems with synchronized architectures.pdf:PDF},
  groups    = {Formal-method, expert_search},
  publisher = {Elsevier {BV}},
}

@InProceedings{Sykes2013Learningrevisedmodels,
  author    = {Daniel Sykes and Domenico Corapi and Jeff Magee and Jeff Kramer and Alessandra Russo and Katsumi Inoue},
  booktitle = {2013 35th International Conference on Software Engineering ({ICSE})},
  title     = {Learning revised models for planning in adaptive systems},
  year      = {2013},
  month     = {may},
  publisher = {{IEEE}},
  abstract  = {Environment domain models are a key part of the information used by adaptive systems to determine their behaviour. These models can be incomplete or inaccurate. In addition, since adaptive systems generally operate in environments which are subject to change, these models are often also out of date. To update and correct these models, the system should observe how the environment responds to its actions, and compare these responses to those predicted by the model. In this paper, we use a probabilistic rule learning approach, NoMPRoL, to update models using feedback from the running system in the form of execution traces. NoMPRoL is a technique for nonmonotonic probabilistic rule learning based on a transformation of an inductive logic programming task into an equivalent abductive one. In essence, it exploits consistent observations by finding general rules which explain observations in terms of the conditions under which they occur. The updated models are then used to generate new behaviour with a greater chance of success in the actual environment encountered.},
  doi       = {10.1109/icse.2013.6606552},
  file      = {:download_papers/Sykes-2013-Learning Revised Models for Planning.pdf:PDF},
  groups    = {Learning, expert_search},
}

@InProceedings{Zhang2006Modelbaseddevelopment,
  author    = {Ji Zhang and Betty H. C. Cheng},
  booktitle = {Proceeding of the 28th international conference on Software engineering - {ICSE} {\textquotesingle}06},
  title     = {Model-based development of dynamically adaptive software},
  year      = {2006},
  publisher = {{ACM} Press},
  abstract  = {Increasingly, software should dynamically adapt its behavior at run-time in response to changing conditions in the supporting computing and communication infrastructure, and in the surrounding physical environment. In order for an adaptive program to be trusted, it is important to have mechanisms to ensure that the program functions correctly during and after adaptations. Adaptive programs are generally more difficult to specify, verify, and validate due to their high complexity. Particularly, when involving multi-threaded adaptations, the program behavior is the result of the collaborative behavior of multiple threads and software components. This paper introduces an approach to create formal models for the behavior of adaptive programs. Our approach separates the adaptation behavior and non-adaptive behavior specifications of adaptive programs, making the models easier to specify and more amenable to automated analysis and visual inspection. We introduce a process to construct adaptation models, automatically generate adaptive programs from the models, and verify and validate the models. We illustrate our approach through the development of an adaptive GSM-oriented audio streaming protocol for a mobile computing application.},
  doi       = {10.1145/1134285.1134337},
  file      = {:download_papers/Zhang-2006-Model-Based Development of Dynamically Adaptive.pdf:PDF},
  groups    = {Model-based, expert_search},
}

@InProceedings{Zhao2017ReinforcementLearningBased,
  author    = {Tianqi Zhao and Wei Zhang and Haiyan Zhao and Zhi Jin},
  booktitle = {2017 {IEEE} International Conference on Autonomic Computing ({ICAC})},
  title     = {A Reinforcement Learning-Based Framework for the Generation and Evolution of Adaptation Rules},
  year      = {2017},
  month     = {jul},
  publisher = {{IEEE}},
  abstract  = {One of the challenges in self-adaptive systems concerns how to make adaptation to themselves at runtime in response to possible and even unexpected changes from the environment and/or user goals. A feasible solution to this challenge is rule-based adaptation, in which, adaptation decisions are made according to predefined rules that specify what particular actions should be performed to react to different changing events from the environment. Although it has the characteristic of highly- efficient decision making for adaptation, rule-based adaptation has two limitations: 1. no guarantee that those predefined rules will lead to optimal or nearly-optimal adaptation results; 2. weak support to evolve these rules to cope with non-stationary environment and changeable user goals at runtime. In this paper, we propose a reinforcement learning-based framework to the generation and evolution of software adaptation rules. This framework manifests two key capabilities for self-adaptation: 1. the capability of automatically learning adaptation rules from different goal settings at the offline phase; 2. the capability of automatically evolving adaptation rules from real-time information about the environment and user goals at the online phase. The two capabilities are built on the combination of reinforcement learning and case-based reasoning techniques. This framework improves the existing rule-based adaptation from two points: the flexibility of adaptation logic, and the quality of adaptation rules. We evaluate this framework through a case study of an E-commerce web application, which shows that this framework improves both the efficiency and effectiveness of self-adaptation.},
  doi       = {10.1109/icac.2017.47},
  file      = {:download_papers/Zhao-2017-A Reinforcement Learning - based Framework for the Generation.pdf:PDF},
  groups    = {Learning, expert_search},
}

@InProceedings{Angelopoulos2016,
  author    = {Angelopoulos, Konstantinos and Papadopoulos, Alessandro V. and Silva Souza, V\'{\i}tor E. and Mylopoulos, John},
  booktitle = {Proceedings of the 11th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Model Predictive Control for Software Systems with CobRA},
  year      = {2016},
  address   = {New York, NY, USA},
  pages     = {35–46},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS ’16},
  abstract  = {Self-adaptive software systems monitor their operation and adapt when their requirements fail due to unexpected phenomena in their environment. This paper examines the case where the environment changes dynamically over time and the chosen adaptation has to take into account such changes. In control theory, this type of adaptation is known as Model Predictive Control and comes with a well-developed theory and myriads of successful applications. The paper focuses on modelling the dynamic relationship between requirements and possible adaptations. It then proposes a controller that exploits this relationship to optimize the satisfaction of requirements relative to a cost-function. This is accomplished through a model-based framework for designing self-adaptive software systems that can guarantee a certain level of requirements satisfaction over time, by dynamically composing adaptation strategies when necessary. The proposed framework is illustrated and evaluated through a simulation of the Meeting-Scheduling System exemplar.},
  doi       = {10.1145/2897053.2897054},
  file      = {:download_papers/Angelopoulos-2016- Model predictive control for software systems with CobRA.pdf:PDF},
  groups    = {acm, systematic_search},
  isbn      = {9781450341875},
  keywords  = {self-adaptive systems, awareness requirements, model predictive control},
  location  = {Austin, Texas},
  numpages  = {12},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2897053.2897054},
}

@InProceedings{Arcaini2015a,
  author    = {P. {Arcaini} and E. {Riccobene} and P. {Scandurra}},
  booktitle = {2015 IEEE/ACM 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Modeling and Analyzing MAPE-K Feedback Loops for Self-Adaptation},
  year      = {2015},
  month     = {May},
  pages     = {13-23},
  publisher = {{IEEE}},
  abstract  = {The MAPE-K (Monitor-Analyze-Plan-Execute over a shared Knowledge) feedback loop is the most influential reference control model for autonomic and self-adaptive systems. This paper presents a conceptual and methodological framework for formal modeling, validating, and verifying distributed self-adaptive systems. We show how MAPE-K loops for self adaptation can be naturally specified in an abstract stateful language like Abstract State Machines. In particular, we exploit the concept of multi-agent Abstract State Machines to specify decentralized adaptation control by using MAPE computations. We support techniques for validating and verifying adaptation scenarios, and getting feedback of the correctness of the adaptation logic as implemented by the MAPE-K loops. In particular, a verification technique based on meta-properties is proposed to allow discovering unwanted interferences between MAPE-K loops at the early stages of the system design. As a proof-of concepts, we model and analyze a traffic monitoring system.},
  doi       = {10.1109/SEAMS.2015.10},
  file      = {:download_papers/Arcaini-2015-Modeling and analyzing MAPE-K feedback loops for self-adaptation.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  issn      = {2157-2321},
  keywords  = {decentralised control;finite state machines;formal logic;formal specification;multi-agent systems;program verification;software fault tolerance;MAPE-K feedback loop;Monitor-analyze-plan-execute over a shared knowledge;distributed self-adaptive system verification;autonomic systems;formal modeling;self-adaptation;abstract stateful language;multiagent abstract state machines;decentralized adaptation control specification;adaptation logic;meta properties;traffic monitoring system;Adaptation models;Monitoring;Cameras;Unified modeling language;Computational modeling;Analytical models;Organizations;self-adaptation;MAPE-K;formal modeling;validation & verification;Abstract State Machines},
}

@InProceedings{Balasubramaniam2004Supportfeedbackchange,
  author    = {Balasubramaniam, Dharini and Morrison, Ron and Mickan, Kath and Kirby, Graham and Warboys, Brian and Robertson, Ian and Snowdon, Bob and Greenwood, R. Mark and Seet, Wykeen},
  booktitle = {Proceedings of the 1st ACM SIGSOFT Workshop on Self-Managed Systems},
  title     = {Support for Feedback and Change in Self-Adaptive Systems},
  year      = {2004},
  address   = {New York, NY, USA},
  pages     = {18–22},
  publisher = {Association for Computing Machinery},
  series    = {WOSS ’04},
  abstract  = {Self-adaptive systems modify their own behaviour in response to stimuli from their operating environments. The major policy considerations for such systems are determining what, when and how adaptations should be carried out. This paper presents mechanisms for feedback and change that support policy decisions for self-adaptation within a computationally complete architecture description language based on the π-calculus. Our contribution is support for feedback through software-encoded probes, gauges and an event distribution network together with support for change through decomposition, reification, reflection, recomposition and hyper-code.},
  doi       = {10.1145/1075405.1075409},
  file      = {:download_papers/Balasubramaniam-2004-Support for feedback and change in self-adaptive systems.pdf:PDF},
  groups    = {acm, expert_search},
  isbn      = {1581139896},
  keywords  = {recomposition, composition, adaptation, self-adaptive systems, feedback, hyper-code, software architectures, reflection, policy, constraints, reification, probes, decomposition, mechanism, autonomics},
  location  = {Newport Beach, California},
  numpages  = {5},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1075405.1075409},
}

@InProceedings{Ballagny2009,
  author    = {C. {Ballagny} and N. {Hameurlain} and F. {Barbier}},
  booktitle = {2009 Third IEEE International Conference on Self-Adaptive and Self-Organizing Systems},
  title     = {MOCAS: A State-Based Component Model for Self-Adaptation},
  year      = {2009},
  month     = {Sep.},
  pages     = {206-215},
  publisher = {{IEEE}},
  abstract  = {This paper introduces MOCAS (model of components for adaptive systems), a generic state-based component model which enables the self-adaptation of software components together with their coordination. MOCAS relies on behavioral adaptation instead of structural adaptation and uses the United Modeling Language (UML). Each component embeds a UML state machine to realize its behavior at runtime. It is installed in a container managing the adaptation process and ensuring its consistency. Adaptation is triggered when invariants related to the components business properties are violated. The component supports updates of its specification while it is running. This component model is illustrated through the GridStix case study.},
  doi       = {10.1109/SASO.2009.11},
  file      = {:download_papers/Ballagny-2009-MOCAS a State-Based Component Model for.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  issn      = {1949-3681},
  keywords  = {formal specification;object-oriented programming;Unified Modeling Language;state-based component model;model of components for adaptive systems;software component;behavioral adaptation;United Modeling Language state machine;component specification;GridStix;Unified modeling language;Power system modeling;Runtime;Containers;Predictive models;Adaptive systems;Software systems;Humans;Model driven engineering;Buildings;Self-Adaptation;Component Model;UML State Machine},
}

@InProceedings{Camara2009,
  author    = {J. {Camara} and C. {Canal} and G. {Salaun}},
  booktitle = {2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Behavioural self-adaptation of services in ubiquitous computing environments},
  year      = {2009},
  month     = {May},
  pages     = {28-37},
  publisher = {{IEEE}},
  abstract  = {Self-adaptive software systems are those able to manage changing operating conditions dynamically and autonomously. Currently, most proposals in this field rely on an explicit representation of the constituent elements and goals of the system. This approach is suitable for systems where constituent elements are well known at design time. However, in systems where new elements may dynamically enter or leave the execution environment, it is not possible to obtain a predefined description of the system's architecture nor a complete specification of its goals. Paradigmatic examples of such systems can be found in ubiquitous computing, or dynamic web service discovery and composition, where new adaptability problems arise, such as the (dis)connection of unforeseen elements to an already running system, or ensuring properties of the composition among services, which cannot be addressed at static verification time since the state space of the system is not closed anymore. In this paper, we present our approach for the composition and resolution of interface mismatch among services in ubiquitous computing environments, dynamically reconfiguring the system as new services are integrated or disconnected.},
  doi       = {10.1109/SEAMS.2009.5069071},
  file      = {:download_papers/Camara-2009-Behavioural self-adaptation of services in ubiquitous.pdf:PDF},
  groups    = {ieee, systematic_search},
  issn      = {2157-2321},
  keywords  = {software architecture;ubiquitous computing;Web services;services behavioural self-adaptation;ubiquitous computing environments;self-adaptive software systems;system architecture;dynamic Web service discovery;interface mismatch;Ubiquitous computing;Web services;Airports;Protocols;Quality of service;Software quality;Software systems;Availability;Context-aware services;Handheld computers},
}

@InProceedings{Dustdar2009SelfAdaptationTechniques,
  author    = {S. {Dustdar} and K. M. {Goeschka} and H. {Truong} and U. {Zdun}},
  booktitle = {2009 Fifth International Conference on Next Generation Web Services Practices},
  title     = {Self-Adaptation Techniques for Complex Service-oriented Systems},
  year      = {2009},
  month     = {Sep.},
  pages     = {37-43},
  publisher = {{IEEE}},
  abstract  = {Complex service-oriented systems comprise humans and software services spanning multiple organizations. These systems are highly dynamic, because services, processes, and teams are not only diverse but they also constantly evolve. Therefore, these systems introduce a variety of challenges on how to adapt services, processes, and teams to changing situations. We contribute with our approach to address these challenges, comprising model-driven compliance support, run-time interaction mining, run-time management of requirements, and an explicit control-loop architecture. We conclude with remaining issues the software and service engineering research community should address.},
  doi       = {10.1109/NWeSP.2009.12},
  file      = {:download_papers/Dustdar-2009-Self-Adaptation Techniques for Complex Service-oriented Systems.pdf:PDF},
  groups    = {ieee, expert_search},
  keywords  = {software architecture;self-adaptation techniques;complex service-oriented systems;control-loop architecture;software services;model-driven compliance support;run-time interaction mining;Runtime;Humans;Web services;Monitoring;Computer architecture;Collaboration;Unified modeling language;Service oriented architecture;Adaptive systems;Plasma welding;self-adaptation;service-oriented architectures;interaction-mining;model-driven compliance},
}

@InProceedings{Elkhodary2010,
  author        = {Elkhodary, Ahmed and Esfahani, Naeem and Malek, Sam},
  booktitle     = {Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering},
  title         = {FUSION: A Framework for Engineering Self-Tuning Self-Adaptive Software Systems},
  year          = {2010},
  address       = {New York, NY, USA},
  note          = {cited By 114},
  pages         = {7–16},
  publisher     = {Association for Computing Machinery},
  series        = {FSE ’10},
  abstract      = {Self-adaptive software systems are capable of adjusting their behavior at run-time to achieve certain objectives. Such systems typically employ analytical models specified at design-time to assess their characteristics at run-time and make the appropriate adaptation decisions. However, prior to system's deployment, engineers often cannot foresee the changes in the environment, requirements, and system's operational profile. Therefore, any analytical model used in this setting relies on underlying assumptions that if not held at run-time make the analysis and hence the adaptation decisions inaccurate. We present and evaluate FeatUre-oriented Self-adaptatION (FUSION) framework, which aims to solve this problem by learning the impact of adaptation decisions on the system's goals. The framework (1) allows for automatic online fine-tuning of the adaptation logic to unanticipated conditions, (2) reduces the upfront effort required for building such systems, and (3) makes the run-time analysis of such systems very efficient. © 2010 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/1882291.1882296},
  file          = {:download_papers/Elkhodary-2010-FUSION a framework for engineering self-tuning self-adaptive.pdf:PDF},
  groups        = {acm, wiley, expert_search, systematic_search},
  isbn          = {9781605587912},
  journal       = {Proceedings of the ACM SIGSOFT Symposium on the Foundations of Software Engineering},
  keywords      = {self-adaptation, learning, qos analysis, feature-orientation},
  location      = {Santa Fe, New Mexico, USA},
  numpages      = {10},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/1882291.1882296},
}

@InProceedings{Esfahani2011,
  author        = {Esfahani, Naeem and Kouroshfar, Ehsan and Malek, Sam},
  booktitle     = {Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering},
  title         = {Taming Uncertainty in Self-Adaptive Software},
  year          = {2011},
  address       = {New York, NY, USA},
  note          = {cited By 90},
  pages         = {234–244},
  publisher     = {Association for Computing Machinery},
  series        = {ESEC/FSE ’11},
  abstract      = {Self-adaptation endows a software system with the ability to satisfy certain objectives by automatically modifying its behavior. While many promising approaches for the construction of self-adaptive software systems have been developed, the majority of them ignore the uncertainty underlying the adaptation decisions. This has been one of the key obstacles to wide-spread adoption of self-adaption techniques in risk-averse real-world settings. In this paper, we describe an approach, called POssIbilistic SElf-aDaptation (POISED), for tackling the challenge posed by uncertainty in making adaptation decisions. POISED builds on possibility theory to assess both the positive and negative consequences of uncertainty. It makes adaptation decisions that result in the best range of potential behavior. We demonstrate POISED's application to the problem of improving a software system's quality of service via runtime reconfiguration of its customizable software components. We have extensively evaluated POISED using a prototype of a robotic software system. © 2011 ACM.},
  document_type = {Conference Paper},
  doi           = {10.1145/2025113.2025147},
  file          = {:download_papers/Esfahani-2011-Taming uncertainty in self-adaptive software.pdf:PDF},
  groups        = {acm, wiley, expert_search, systematic_search},
  isbn          = {9781450304436},
  journal       = {SIGSOFT/FSE 2011 - Proceedings of the 19th ACM SIGSOFT Symposium on Foundations of Software Engineering},
  keywords      = {software architecture, uncertainty, self-adaptation},
  location      = {Szeged, Hungary},
  numpages      = {11},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2025113.2025147},
}

@InProceedings{Filieri2011Selfadaptivesoftware,
  author        = {A. {Filieri} and C. {Ghezzi} and A. {Leva} and M. {Maggio}},
  booktitle     = {2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011)},
  title         = {Self-adaptive software meets control theory: A preliminary approach supporting reliability requirements},
  year          = {2011},
  month         = {Nov},
  note          = {cited By 57},
  pages         = {283-292},
  publisher     = {{IEEE}},
  abstract      = {This paper investigates a novel approach to derive self-adaptive software by automatically modifying the model of the application using a control-theoretical approach. Self adaptation is achieved at the model level to assure that the model-which lives alongside the application at run-time- continues to satisfy its reliability requirements, despite changes in the environment that might lead to a violation. We assume that the model is given in terms of a Discrete Time Markov Chain (DTMC). DTMCs can express reliability concerns by modeling possible failures through transitions to failure states. Reliability requirements may be expressed as reachability properties that constrain the probability to reach certain states, denoted as failure states. We assume that DTMCs describe possible variant behaviors of the adaptive system through transitions exiting a given state that represent alternative choices, made according to certain probabilities. Viewed from a control-theory standpoint, these probabilities correspond to the input variables of a controlled system-i.e., in the control theory lexicon, "control variables". Adopting the same lexicon, such variables are continuously modified at run-time by a feedback controller so as to ensure continuous satisfaction of the requirements despite disturbances, i.e., changes in the environment. Changes at the model level may then be automatically transferred to changes in the running implementation. The approach is methodologically described by providing a translation scheme from DTMCs to discrete-time dynamic systems, the formalism in which the controllers are derived. An initial empirical assessment is described for a case study. Conjectures for extensions to other models and other requirements.},
  art_number    = {6100064},
  document_type = {Conference Paper},
  doi           = {10.1109/ASE.2011.6100064},
  file          = {:download_papers/Filieri-2011-Self-Adaptive Software Meets Control Theory A Preliminary Approach.pdf:PDF},
  groups        = {ieee, wiley, expert_search},
  issn          = {1938-4300},
  journal       = {2011 26th IEEE/ACM International Conference on Automated Software Engineering, ASE 2011, Proceedings},
  keywords      = {discrete time systems;feedback;formal verification;Markov processes;probability;reachability analysis;self-adjusting systems;software reliability;self-adaptive software;reliability requirement;discrete time Markov chain;failure modeling;reachability properties;probability;DTMC;control theory lexicon;control variable;feedback controller;discrete time dynamic system;Software;Mathematical model;Control systems;Adaptation models;Software reliability;Equations;Adaptive software;control theory;dynamic systems;non-functional requirements;reliability;run-time verification},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84855465057&doi=10.1109%2fASE.2011.6100064&partnerID=40&md5=ce3262c1f3cfce6e1c55f8aafd8eb0b5},
}

@Article{Franco2016,
  author        = {Franco, J.M. and Correia, F. and Barbosa, R. and Zenha-Rela, M. and Schmerl, B. and Garlan, D.},
  journal       = {Journal of Systems and Software},
  title         = {Improving self-adaptation planning through software architecture-based stochastic modeling},
  year          = {2016},
  month         = {may},
  note          = {cited By 11},
  pages         = {42-60},
  volume        = {115},
  abstract      = {The ever-growing complexity of software systems makes it increasingly challenging to foresee at design time all interactions between a system and its environment. Most self-adaptive systems trigger adaptations through operators that are statically configured for specific environment and system conditions. However, in the occurrence of uncertain conditions, self-adaptive decisions may not be effective and might lead to a disruption of the desired non-functional attributes. To address this, we propose an approach that improves the planning stage by predicting the outcome of each strategy. In detail, we automatically derive a stochastic model from a formal architecture description of the managed system with the changes imposed by each strategy. Such information is used to optimize the self-adaptation decisions to fulfill the desired quality goals. To assess the effectiveness of our approach we apply it to a cloud-based news system and predicted the reliability for each possible adaptation strategy. The results obtained from our approach are compared to a representative static planning algorithm as well as to an oracle that always makes the ideal decision. Experiments show that our method improves both availability and cost when compared to the static planning algorithm, while being close to the oracle. Our approach may therefore be used to optimize self-adaptation planning. © 2016 Elsevier Inc. All rights reserved.},
  document_type = {Article},
  doi           = {10.1016/j.jss.2016.01.026},
  file          = {:download_papers/Franco-2016-Improving self-adaptation planning through software.pdf:PDF},
  groups        = {scopus, systematic_search},
  publisher     = {Elsevier {BV}},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84960942679&doi=10.1016%2fj.jss.2016.01.026&partnerID=40&md5=275865cce6d4972bf19cba0b12db9079},
}

@Article{Garlan2004a,
  author    = {D. {Garlan} and S. -. {Cheng} and A. -. {Huang} and B. {Schmerl} and P. {Steenkiste}},
  journal   = {Computer},
  title     = {Rainbow: architecture-based self-adaptation with reusable infrastructure},
  year      = {2004},
  issn      = {1558-0814},
  month     = {Oct},
  number    = {10},
  pages     = {46-54},
  volume    = {37},
  abstract  = {While attractive in principle, architecture-based self-adaptation raises a number of research and engineering challenges. First, the ability to handle a wide variety of systems must be addressed. Second, the need to reduce costs in adding external control to a system must be addressed. Our rainbow framework attempts to address both problems. By adopting an architecture-based approach, it provides reusable infrastructure together with mechanisms for specializing that infrastructure to the needs of specific systems. The specialization mechanisms let the developer of self-adaptation capabilities choose what aspects of the system to model and monitor, what conditions should trigger adaptation, and how to adapt the system.},
  doi       = {10.1109/MC.2004.175},
  file      = {:download_papers/Garlan-2004-Architecture-based self-adaptation with reusable infrastructure.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  keywords  = {software architecture;software reusability;client-server systems;open systems;system monitoring;Rainbow architecture-based self-adaptation;reusable infrastructure;system variety handling;cost reduction;specialization mechanisms;adaptation triggering;client-server system software architecture;Software architecture;Monitoring;Computer architecture;Costs;Protocols;Control systems;Software systems;Computer interfaces;Environmental management;Computer languages},
  publisher = {Institute of Electrical and Electronics Engineers ({IEEE})},
}

@Article{Gerostathopoulos2016a,
  author        = {Gerostathopoulos, I. and Skoda, D. and Plasil, F. and Bures, T. and Knauss, A.},
  journal       = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
  title         = {Architectural homeostasis in self-adaptive software-intensive cyber-physical systems},
  year          = {2016},
  note          = {cited By 13},
  pages         = {113-128},
  volume        = {9839 LNCS},
  abstract      = {Self-adaptive software-intensive cyber-physical systems (sasiCPS) encounter a high level of run-time uncertainty. State-of-the-art architecturebased self-adaptation approaches assume designing against a fixed set of situations that warrant self-adaptation; as a result, failures may appear when sasiCPS operate in environment conditions they are not specifically designed for. In response, we propose to increase the homeostasis of sasiCPS, i.e., the capacity to maintain an operational state despite run-time uncertainty, by introducing run-time changes to the architecture-based self-adaptation strategies according to environment stimuli. In addition to articulating the main idea of architectural homeostasis, we describe three mechanisms that reify the idea: (i) collaborative sensing, (ii) faulty component isolation from adaptation, and (iii) enhancing mode switching. Moreover, our experimental evaluation of the three mechanisms confirms that allowing a complex system to change its self-adaptation strategies helps the system recover from runtime errors and abnormalities and keep it in an operational state. © Springer International Publishing AG 2016.},
  booktitle     = {Software Architecture},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-319-48992-6_8},
  file          = {:download_papers/Gerostathopoulos-2016-Architectural Homeostasis in Self-Adaptive.pdf:PDF},
  groups        = {scopus, expert_search, systematic_search},
  publisher     = {Springer International Publishing},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84998893291&doi=10.1007%2f978-3-319-48992-6_8&partnerID=40&md5=8b4e02c6c518398537d1dc5dd285335b},
}

@InProceedings{Haesevoets2009,
  author    = {R. {Haesevoets} and D. {Weyns} and T. {Holvoet} and W. {Joosen}},
  booktitle = {2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {A formal model for self-adaptive and self-healing organizations},
  year      = {2009},
  month     = {May},
  pages     = {116-125},
  publisher = {{IEEE}},
  abstract  = {Multi-agent systems typically consist of autonomous entities, capable of adapting their behavior and interaction patterns in dynamic environments, making them an interesting approach for modeling self-adaptive systems. The interactions among agents, a key challenge in engineering multi-agent systems, are often structured and managed by means of organizations. In previous work we have built a prototype of an organization middleware, which encapsulates the management of dynamic organizations as a reusable service and offers organizations as first-class programming abstractions to application developers. To develop a mature middleware, we face two key challenges: realizing the integration of the middleware with the rest of the system in a disciplined way and assuring properties, such as self-adaptivity and self- healing, of services offered by the middleware. This paper presents a formal specification of an organization and management model for dynamic organizations, a first step in facing these challenges. Both models contribute to the integration of the middleware with the rest of the system. The organization model rigorously describes the main programming abstractions to which application developers have to conform, while the management model can be used to derive specific monitoring and control points required by the middleware to realize self-* properties. In addition, the management model offers a foundation to reason about self- * properties.},
  doi       = {10.1109/SEAMS.2009.5069080},
  file      = {:download_papers/Haesevoets-2009-A formal model for self-adaptive and self-healing organizations.pdf:PDF},
  groups    = {ieee, expert_search},
  issn      = {2157-2321},
  keywords  = {fault tolerant computing;formal specification;middleware;multi-agent systems;software agents;software development management;system monitoring;formal model;self-healing organization;self-adaptive organization;multi agent system;autonomous entity;formal specification;dynamic organization management model;middleware;self-* property;interaction pattern;behavior pattern;dynamic environment;programming abstraction;application developer;Middleware;Formal specifications;Monitoring;Multiagent systems;Telecommunication traffic;Cameras;Prototypes;Dynamic programming;Collaborative work;Traffic control},
}

@InProceedings{Iftikhar2014a,
  author    = {Iftikhar, M. Usman and Weyns, Danny},
  booktitle = {Proceedings of the 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {ActivFORMS: Active Formal Models for Self-Adaptation},
  year      = {2014},
  address   = {New York, NY, USA},
  pages     = {125–134},
  publisher = {Association for Computing Machinery},
  series    = {SEAMS 2014},
  abstract  = {Self-adaptation enables a software system to deal autonomously with uncertainties, such as dynamic operating conditions that are difficult to predict or changing goals. A common approach to realize self-adaptation is with a MAPE-K feedback loop that consists of four adaptation components: Monitor, Analyze, Plan, and Execute. These components share Knowledge models of the managed system, its goals and environment. To provide guarantees of the adaptation goals, state of the art approaches propose using formal models of the knowledge. However, less attention is given to the formalization of the adaptation components themselves, which is important to provide guarantees of correctness of the adaptation behavior (e.g., does the execute component execute the plan correctly?). We propose Active FORmal Models for Self-adaptation (ActivFORMS) that uses an integrated formal model of the adaptation components and knowledge models. The formal model is directly executed by a virtual machine to realize adaptation, hence active model. The contributions of ActivFORMS are: (1) the approach assures that the adaptation goals that are verified offline are guaranteed at runtime, and (2) it supports dynamic adaptation of the active model to support changing goals. We show how we have applied ActivFORMS for a small-scale robotic system.},
  doi       = {10.1145/2593929.2593944},
  file      = {:download_papers/Iftikhar-2014-ActivFORMS Active Formal Models for Self-Adaptation.pdf:PDF},
  groups    = {acm, expert_search, systematic_search},
  isbn      = {9781450328647},
  keywords  = {verification, formal models at runtime, Self-adaptive systems},
  location  = {Hyderabad, India},
  numpages  = {10},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2593929.2593944},
}

@InProceedings{Moreno2015Proactiveselfadaptation,
  author    = {Moreno, Gabriel A. and C\'{a}mara, Javier and Garlan, David and Schmerl, Bradley},
  booktitle = {Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering},
  title     = {Proactive Self-Adaptation under Uncertainty: A Probabilistic Model Checking Approach},
  year      = {2015},
  address   = {New York, NY, USA},
  pages     = {1–12},
  publisher = {Association for Computing Machinery},
  series    = {ESEC/FSE 2015},
  abstract  = {Self-adaptive systems tend to be reactive and myopic, adapting in response to changes without anticipating what the subsequent adaptation needs will be. Adapting reactively can result in inefficiencies due to the system performing a suboptimal sequence of adaptations. Furthermore, when adaptations have latency, and take some time to produce their effect, they have to be started with sufficient lead time so that they complete by the time their effect is needed. Proactive latency-aware adaptation addresses these issues by making adaptation decisions with a look-ahead horizon and taking adaptation latency into account. In this paper we present an approach for proactive latency-aware adaptation under uncertainty that uses probabilistic model checking for adaptation decisions. The key idea is to use a formal model of the adaptive system in which the adaptation decision is left underspecified through nondeterminism, and have the model checker resolve the nondeterministic choices so that the accumulated utility over the horizon is maximized. The adaptation decision is optimal over the horizon, and takes into account the inherent uncertainty of the environment predictions needed for looking ahead. Our results show that the decision based on a look-ahead horizon, and the factoring of both tactic latency and environment uncertainty, considerably improve the effectiveness of adaptation decisions.},
  doi       = {10.1145/2786805.2786853},
  file      = {:download_papers/Moreno-2015-Proactive Self-Adaptation under Uncertainty A Probabilistic Model.pdf:PDF},
  groups    = {acm, expert_search},
  isbn      = {9781450336758},
  keywords  = {Latency-aware, probabilistic model checking, self-adaptation, proactive},
  location  = {Bergamo, Italy},
  numpages  = {12},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/2786805.2786853},
}

@InProceedings{Nakagawa2008,
  author    = {H. {Nakagawa} and A. {Ohsuga} and S. {Honiden}},
  booktitle = {2008 Second IEEE International Conference on Self-Adaptive and Self-Organizing Systems Workshops},
  title     = {Constructing Self-Adaptive Systems Using a KAOS Model},
  year      = {2008},
  month     = {Oct},
  pages     = {132-137},
  publisher = {{IEEE}},
  abstract  = {Self-adaptive systems have recently attracted attention as flexible software because they can change their own behaviors to react to changes in their environments. Such systems have also attracted attention in the field of pervasive computing. This paper describes our approach to developing self-adaptive systems utilizing a requirements model to build the system architecture. This paper also discusses the implementation style we used using the acquired architecture model, and our evaluation of the feasibility of our development process through a case study.},
  doi       = {10.1109/SASOW.2008.35},
  file      = {:download_papers/Nakagawa-2008-Constructing Self-Adaptive Systems Using a KAOS Model.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  keywords  = {software architecture;ubiquitous computing;self-adaptive systems;KAOS model;flexible software;pervasive computing;requirements model;Computer architecture;Cleaning;Robots;Conferences;Informatics;Pervasive computing;Software architecture;Software systems;Programming;Guidelines;self-adaptive systems;requirements analysis;software architecture},
}

@Article{Oreizy1999,
  author        = {P. {Oreizy} and M. M. {Gorlick} and R. N. {Taylor} and D. {Heimhigner} and G. {Johnson} and N. {Medvidovic} and A. {Quilici} and D. S. {Rosenblum} and A. L. {Wolf}},
  journal       = {IEEE Intelligent Systems and their Applications},
  title         = {An architecture-based approach to self-adaptive software},
  year          = {1999},
  issn          = {2374-9423},
  month         = {May},
  note          = {cited By 628},
  number        = {3},
  pages         = {54-62},
  volume        = {14},
  abstract      = {Self-adaptive software requires high dependability robustness, adaptability, and availability. The article describes an infrastructure supporting two simultaneous processes in self-adaptive software: system evolution, the consistent application of change over time, and system adaptation, the cycle of detecting changing circumstances and planning and deploying responsive modifications.},
  document_type = {Article},
  doi           = {10.1109/5254.769885},
  file          = {:download_papers/Oreizy-1999-An architecture-based approach to self-adaptive software.pdf:PDF},
  groups        = {ieee, wiley, expert_search, systematic_search},
  keywords      = {software fault tolerance;adaptive systems;management of change;software architecture;architecture based approach;self-adaptive software;dependability robustness;adaptability;availability;simultaneous processes;system evolution;system adaptation;changing circumstances;responsive modifications;change management;Application software;Monitoring;Costs;Unmanned aerial vehicles;Sensor systems;Software systems;Runtime;Traffic control;Disaster management;Environmental management},
  publisher     = {Institute of Electrical and Electronics Engineers ({IEEE})},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0032665183&doi=10.1109%2f5254.769885&partnerID=40&md5=1bcfd2cbd5c86bb5c12a2078a32194c1},
}

@InProceedings{Pilgerstorfer2017,
  author    = {P. {Pilgerstorfer} and E. {Pournaras}},
  booktitle = {2017 IEEE/ACM 12th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Self-Adaptive Learning in Decentralized Combinatorial Optimization - A Design Paradigm for Sharing Economies},
  year      = {2017},
  month     = {May},
  pages     = {54-64},
  publisher = {{IEEE}},
  abstract  = {The democratization of Internet of Things and ubiquitous computing equips citizens with phenomenal new ways for online participation and decision-making in application domains of smart grids and smart cities. When agents autonomously self-determine the options from which they make choices, while these choices collectively have an overall system-wide impact, an optimal decision-making turns into a combinatorial optimization problem known to be NP-hard. This paper contributes a new generic self-adaptive learning algorithm for a fully decentralized combinatorial optimization: I-EPOS, the Iterative Economic Planning and Optimized Selections. In contrast to related algorithms that simply parallelize computations or big data and deep learning systems that often require personal data and overtake of control with implication on privacy-preservation and autonomy, I-EPOS relies on coordinated local decision-making via structured interactions over tree topologies that involve the exchange of entirely local and aggregated information. Strikingly, the cost-effectiveness of I-EPOS in regards to performance vs. computational and communication cost highly outperforms other related algorithms that involve non-local brute-force operations or exchange of full information. The algorithm is also evaluated using real-world data from two state-of-the-art pilot projects of participatory sharing economies: (i) energy management and (ii) bicycle sharing. The contribution of an I-EPOS open source software suite implemented as a paradigmatic artifact for community aspires to settle a knowledge exchange for the design of new algorithms and application scenarios of sharing economies towards highly participatory and sustainable digital societies.},
  doi       = {10.1109/SEAMS.2017.8},
  file      = {:download_papers/Pilgerstorfer-2017-Self-Adaptive Learning in Decentralized Combinatorial.pdf:PDF},
  groups    = {ieee, systematic_search},
  keywords  = {Big Data;combinatorial mathematics;computational complexity;Internet of Things;iterative methods;learning (artificial intelligence);optimisation;power engineering computing;power system economics;power system planning;smart power grids;fully decentralized combinatorial optimization;economy sharing;Internet of Things democratization;smart grid;smart cities;optimal decision-making;NP-hard problem;generic self-adaptive learning algorithm;iterative economic planning and optimized selections;Big Data;deep learning system;energy management;bicycle sharing;I-EPOS open source software suite;paradigmatic artifact;knowledge exchange;Decision making;Bicycles;Topology;Algorithm design and analysis;Cost function;Smart grids;learning;adaptation;optimization;decentralized system;network;sharing economy;smart grid;smart city},
}

@InProceedings{Tan2006,
  author    = {L. {Tan}},
  booktitle = {2006 Sixth International Conference on Quality Software (QSIC'06)},
  title     = {Model-Based Self-Adaptive Embedded Programs with Temporal Logic Specifications},
  year      = {2006},
  month     = {Oct},
  pages     = {151-158},
  publisher = {{IEEE}},
  abstract  = {We propose a model-based framework for developing a self-adaptive embedded program, which monitors its own execution and reconfigures itself at runtime to avoid failure and improve performance. Our approach uses formal methods at different design stages to reduce the complexity of developing a self-adaptive embedded program. In our framework system requirement is rigidly encoded in temporal logics, and the original embedded system behavior is captured in a hybrid automaton-based model. We introduce the reconfiguration specification language REDL to specify reconfiguration requirements, and define a formal semantics of reconfiguration in context of hybrid automaton. Using formal methods also helps automate design and implementation: we use model-based runtime verification techniques introduced by Tan et al. (2001) to extend a system model to a self-monitoring model based on its temporal logic requirements; we then extend the self-monitoring model with a reconfiguration mechanism based on its REDL specification. Our approach works with models, and hence it may be incorporated into existing model-based design workflow: the resulting self-adaptive model can be analyzed using an existing model simulator and may be used to generate a self-adaptive embedded program for targeted platform},
  doi       = {10.1109/QSIC.2006.41},
  file      = {:download_papers/Tan-2005-Model-Based Self-Monitoring Embedded Programs With Temporal Logic.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  issn      = {2332-662X},
  keywords  = {adaptive systems;automata theory;configuration management;embedded systems;formal specification;program verification;temporal logic;model-based self-adaptive embedded program;temporal logic specifications;self reconfiguration;formal method;system requirement;hybrid automaton-based model;reconfiguration specification;REDL language;reconfiguration requirements;formal semantics;runtime verification;self-monitoring model;Runtime;Embedded system;Embedded software;Reconfigurable logic;Analytical models;Application software;Unmanned aerial vehicles;Design methodology;Specification languages;Automata},
}

@Article{Villegas2013DYNAMICOReferenceModel,
  author        = {Villegas, N.M. and Tamura, G. and Müller, H.A. and Duchien, L. and Casallas, R.},
  journal       = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
  title         = {DYNAMICO: A reference model for governing control objectives and context relevance in self-adaptive software systems},
  year          = {2013},
  note          = {cited By 42},
  pages         = {265-293},
  volume        = {7475 LNCS},
  abstract      = {Despite the valuable contributions on self-adaptation, most implemented approaches assume adaptation goals and monitoring infrastructures as non-mutable, thus constraining their applicability to systems whose context awareness is restricted to static monitors. Therefore, separation of concerns, dynamic monitoring, and runtime requirements variability are critical for satisfying system goals under highly changing environments. In this chapter we present DYNAMICO, a reference model for engineering adaptive software that helps guaranteeing the coherence of (i) adaptation mechanisms with respect to changes in adaptation goals; and (ii) monitoring mechanisms with respect to changes in both adaptation goals and adaptation mechanisms. DYNAMICO improves the engineering of self-adaptive systems by addressing (i) the management of adaptation properties and goals as control objectives; (ii) the separation of concerns among feedback loops required to address control objectives over time; and (iii) the management of dynamic context as an independent control function to preserve context-awareness in the adaptation mechanism. © 2013 Springer-Verlag.},
  booktitle     = {Software Engineering for Self-Adaptive Systems {II}},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-642-35813-5_11},
  file          = {:download_papers/Villegas-2012-A reference model for governing control objectives.pdf:PDF},
  groups        = {scopus, expert_search},
  publisher     = {Springer Berlin Heidelberg},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-84883567578&doi=10.1007%2f978-3-642-35813-5_11&partnerID=40&md5=99d4a63a7e5fa35c417739fb504ab23f},
}

@Article{Vogel2014,
  author        = {Vogel, Thomas and Giese, Holger},
  journal       = {ACM Trans. Auton. Adapt. Syst.},
  title         = {Model-Driven Engineering of Self-Adaptive Software with EUREMA},
  year          = {2014},
  issn          = {1556-4665},
  month         = jan,
  note          = {cited By 81},
  number        = {4},
  pages         = {1--33},
  volume        = {8},
  abstract      = {The development of self-adaptive software requires the engineering of an adaptation engine that controls the underlying adaptable software by feedback loops. The engine often describes the adaptation by runtime models representing the adaptable software and by activities such as analysis and planning that use these models. To systematically address the interplay between runtime models and adaptation activities, runtime megamodels have been proposed. A runtime megamodel is a specific model capturing runtime models and adaptation activities. In this article, we go one step further and present an executable modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that eases the development of adaptation engines by following a model-driven engineering approach. We provide a domain-specific modeling language and a runtime interpreter for adaptation engines, in particular feedback loops. Megamodels are kept alive at runtime and by interpreting them, they are directly executed to run feedback loops. Additionally, they can be dynamically adjusted to adapt feedback loops. Thus, EUREMA supports development by making feedback loops explicit at a higher level of abstraction and it enables solutions where multiple feedback loops interact or operate on top of each other and self-adaptation co-exists with offline adaptation for evolution. © 2014 ACM.},
  address       = {New York, NY, USA},
  art_number    = {18},
  articleno     = {18},
  document_type = {Conference Paper},
  doi           = {10.1145/2555612},
  file          = {:download_papers/Vogel-2014-Model-Driven Engineering of Self-Adaptive Software with EUREMA.pdf:PDF},
  groups        = {acm, wiley, expert_search, systematic_search},
  issue_date    = {January 2014},
  keywords      = {Model-driven engineering, model interpreter, modeling language, software evolution, layered architecture, feedback loops, self-adaptive software, models at runtime},
  numpages      = {33},
  publisher     = {Association for Computing Machinery},
  source        = {Scopus},
  url           = {https://doi-org.eaccess.ub.tum.de/10.1145/2555612},
}

@InProceedings{Weiss2011,
  author    = {G. {Weiss} and K. {Becker} and B. {Kamphausen} and A. {Radermacher} and S. {Gerard}},
  booktitle = {2011 37th EUROMICRO Conference on Software Engineering and Advanced Applications},
  title     = {Model-Driven Development of Self-Describing Components for Self-Adaptive Distributed Embedded Systems},
  year      = {2011},
  month     = {Aug},
  pages     = {477-484},
  publisher = {{IEEE}},
  abstract  = {Today's distributed embedded systems comprise various fields of application. Increasingly they are deployed in complex scenarios and must be able to adapt to changing environments and internal system changes. Such self-adaptive embedded systems pose great advantages in terms of flexibility, resource utilization, energy efficiency and robustness. The realization of these systems require enhanced development methods to incorporate the adaptation in the design. We introduce a novel concept for the model-driven development of self-adaptive embedded systems. The focus of our work is the definition and transfer of the information needed for the adaptation at runtime. This is preserved as so-called self-description of the components. We present our self-x profile, a modeling extension for describing the adaptation, and the respective design flow with built-in transformations. Furthermore, we outline the applicability of our methodology in an automotive use case.},
  doi       = {10.1109/SEAA.2011.78},
  file      = {:download_papers/Weiss-2011-Model-Driven Development of Self-Describing Components.pdf:PDF},
  groups    = {ieee, expert_search, systematic_search},
  issn      = {2376-9505},
  keywords  = {automotive engineering;distributed processing;embedded systems;resource allocation;model driven development;self describing components;self adaptive distributed embedded systems;internal system changes;resource utilization;energy efficiency;self-x profile;modeling extension;automotive use case;Adaptation models;Unified modeling language;Runtime;Embedded systems;Automotive engineering;Containers;self-adaptation;self-adaptive;self-description;model-driven development;automotive},
}

@InProceedings{Weyns2010,
  author    = {Weyns, Danny and Malek, Sam and Andersson, Jesper},
  booktitle = {Proceedings of the 7th International Conference on Autonomic Computing},
  title     = {FORMS: A Formal Reference Model for Self-Adaptation},
  year      = {2010},
  address   = {New York, NY, USA},
  pages     = {205–214},
  publisher = {Association for Computing Machinery},
  series    = {ICAC ’10},
  abstract  = {Self-adaptive software systems are an emerging class of systems that adjust their behavior at runtime to achieve certain functional or quality of service objectives. The construction of such systems has shown to be significantly more challenging than traditional systems, partly because researchers and practitioners have been struggling with the lack of a precise method of describing, comparing, and evaluating alternative architectural choices. In this paper, we introduce a reference model, entitled FOrmal Reference Model for Self-adaptation (FORMS), which intends to alleviate this pressing issue. FORMS consists of a small number of formally specified modeling primitives that correspond to the key variation points within self-adaptive software systems, and a set of relationships that guide their composition. We present our experiences with applying FORMS to several existing systems, which not only demonstrates its ability to precisely illuminate their underlying characteristics, but also its potential as a method of rigorously specifying architectural patterns for this domain.},
  doi       = {10.1145/1809049.1809078},
  file      = {:download_papers/Weyns-2010-FORMS a formal reference model for self-adaptation.pdf:PDF},
  groups    = {acm, expert_search, systematic_search},
  isbn      = {9781450300742},
  keywords  = {z specification, reference model, self-adaptive systems},
  location  = {Washington, DC, USA},
  numpages  = {10},
  url       = {https://doi-org.eaccess.ub.tum.de/10.1145/1809049.1809078},
}

@Article{Weyns2012,
  author     = {Weyns, Danny and Malek, Sam and Andersson, Jesper},
  journal    = {ACM Trans. Auton. Adapt. Syst.},
  title      = {FORMS: Unifying Reference Model for Formal Specification of Distributed Self-Adaptive Systems},
  year       = {2012},
  issn       = {1556-4665},
  month      = may,
  number     = {1},
  pages      = {1--61},
  volume     = {7},
  abstract   = {The challenges of pervasive and mobile computing environments, which are highly dynamic and unpredictable, have motivated the development of self-adaptive software systems. Although noteworthy successes have been achieved on many fronts, the construction of such systems remains significantly more challenging than traditional systems. We argue this is partially because researchers and practitioners have been struggling with the lack of a precise vocabulary for describing and reasoning about the key architectural characteristics of self-adaptive systems. Further exacerbating the situation is the fact that existing frameworks and guidelines do not provide an encompassing perspective of the different types of concerns in this setting. In this article, we present a comprehensive reference model, entitled FOrmal Reference Model for Self-adaptation (FORMS), that targets both issues. FORMS provides rigor in the manner such systems can be described and reasoned about. It consists of a small number of formally specified modeling elements that correspond to the key concerns in the design of self-adaptive software systems, and a set of relationships that guide their composition. We demonstrate FORMS's ability to precisely describe and reason about the architectural characteristics of distributed self-adaptive software systems through its application to several existing systems. FORMS's expressive power gives it a potential for documenting reusable architectural solutions (e.g., architectural patterns) to commonly encountered problems in this area.},
  address    = {New York, NY, USA},
  articleno  = {8},
  doi        = {10.1145/2168260.2168268},
  file       = {:download_papers/Weyns-2012-FORMS - Unifying reference model for formal specification.pdf:PDF},
  groups     = {acm, expert_search, systematic_search},
  issue_date = {April 2012},
  keywords   = {self-adaptation, autonomic computing, Formal methods},
  numpages   = {61},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi-org.eaccess.ub.tum.de/10.1145/2168260.2168268},
}

@InProceedings{Qureshi2011,
  author       = {Qureshi, Nauman A and Jureta, Ivan J and Perini, Anna},
  booktitle    = {International Conference on Advanced Information Systems Engineering},
  title        = {Requirements engineering for self-adaptive systems: Core ontology and problem statement},
  year         = {2011},
  organization = {Springer},
  pages        = {33--47},
  file         = {:download_papers/Qureshi-2011-RequirementsEngineeringforSAS.pdf:PDF},
  groups       = {expert_search, systematic_search},
}

@Article{Calinescu2012,
  author    = {Calinescu, Radu and Ghezzi, Carlo and Kwiatkowska, Marta and Mirandola, Raffaela},
  journal   = {Communications of the ACM},
  title     = {Self-adaptive software needs quantitative verification at runtime},
  year      = {2012},
  number    = {9},
  pages     = {69--77},
  volume    = {55},
  file      = {:download_papers/Calinescu-2012-Self-adaptive software needs quantitative verification at runtime.pdf:PDF},
  groups    = {systematic_search},
  publisher = {ACM New York, NY, USA},
}

@InProceedings{camara2014a,
  author    = {C{\'a}mara, Javier and Correia, Pedro and de Lemos, Rog{\'e}rio and Vieira, Marco},
  booktitle = {Proceedings of the 10th international ACM Sigsoft conference on Quality of software architectures},
  title     = {Empirical resilience evaluation of an architecture-based self-adaptive software system},
  year      = {2014},
  pages     = {63--72},
  file      = {:download_papers/Camara-2014-Empirical resilience evaluation of an architecture-based.pdf:PDF},
  groups    = {systematic_search},
}

@InProceedings{rammig2014designing,
  author       = {Rammig, Franz J and Gr{\"o}sbrink, Stefan and Stahl, Katharina and Zhao, Yuhong},
  booktitle    = {2014 Brazilian Symposium on Computing Systems Engineering},
  title        = {Designing Self-Adaptive Embedded Real-Time Software--Towards System Engineering of Self-Adaptation},
  year         = {2014},
  organization = {IEEE},
  pages        = {37--42},
  file         = {:download_papers/Ramming-2014-Designing Self-Adaptive Embedded Real-Time Software.pdf:PDF},
  groups       = {systematic_search},
}

@Article{Calinescu2018a,
  author    = {Calinescu, Radu and Weyns, Danny and Gerasimou, Simos and Iftikhar, Muhammad Usman and Habli, Ibrahim and Kelly, Tim},
  journal   = {IEEE Transactions on Software Engineering},
  title     = {Engineering trustworthy self-adaptive software with dynamic assurance cases},
  year      = {2018},
  number    = {11},
  pages     = {1039--1069},
  volume    = {44},
  file      = {:download_papers/Calinescu-2018-Engineering Trustworthy Self-Adaptive Software.pdf:PDF},
  groups    = {systematic_search},
  publisher = {IEEE},
}

@InProceedings{Broy2009formalizing,
  author    = {Broy, Manfred and Leuxner, Christian and Sitou, Wassiou and Spanfelner, Bernd and Winter, Sebastian},
  booktitle = {Proceedings of the 2009 ACM symposium on Applied Computing},
  title     = {Formalizing the notion of adaptive system behavior},
  year      = {2009},
  pages     = {1029--1033},
  file      = {:download_papers/Broy - 2009 - Formalizing the notion of adaptive system behavior.pdf:PDF},
  groups    = {expert_search},
}

@InProceedings{Bruni2012conceptual,
  author       = {Bruni, Roberto and Corradini, Andrea and Gadducci, Fabio and Lafuente, Alberto Lluch and Vandin, Andrea},
  booktitle    = {International Conference on Fundamental Approaches to Software Engineering},
  title        = {A conceptual framework for adaptation},
  year         = {2012},
  organization = {Springer},
  pages        = {240--254},
  file         = {:download_papers/Bruni - 2012 - A Conceptual Framework for Adaptation.pdf:PDF},
  groups       = {expert_search},
}

@InCollection{Bucchiarone2019ten,
  author    = {Bucchiarone, Antonio and Mongiello, Marina},
  booktitle = {From Software Engineering to Formal Methods and Tools, and Back},
  publisher = {Springer},
  title     = {Ten years of self-adaptive systems: From dynamic ensembles to collective adaptive systems},
  year      = {2019},
  pages     = {19--39},
  file      = {:download_papers/Bucchiarone - 2019 - Ten Years Of Self-adaptive Systems.pdf:PDF},
  groups    = {expert_search},
}

@Article{ARCELLI2020a,
  author   = {Davide Arcelli},
  journal  = {Procedia Computer Science},
  title    = {Exploiting Queuing Networks to Model and Assess the Performance of Self-Adaptive Software Systems: A Survey},
  year     = {2020},
  issn     = {1877-0509},
  note     = {The 11th International Conference on Ambient Systems, Networks and Technologies (ANT) / The 3rd International Conference on Emerging Data and Industry 4.0 (EDI40) / Affiliated Workshops},
  pages    = {498-505},
  volume   = {170},
  abstract = {Self-adaptation has emerged as a primary concern in the context of modern software systems, due to the high dynamicity of the environments where they operate, which implies the need for such systems to properly face significant degrees of uncertainty. To this aim, much work has been done, mainly by coupling autonomic managers to the managed subsystem which perceives and affects the environment through its sensors and actuators, respectively. Such coupling often results into MAPE-K feedback loop(s), i.e. a Knowledge (K)-based architectural model that divides the adaptation process into four activities, namely Monitor (M), Analyze (A), Plan (P) and Execute (E). Performance modeling notations, analysis methods and tools, have been exploited and coupled to other kinds of techniques (e.g. control theory, machine learning) for modeling and assessing the performance of autonomic managers, possibly aimed at supporting the identification of more convenient architectural alternatives. Since moving in such a big arena is not trivial and it is easy to be overwhelmed, in this literature survey, we focus on a particular performance modeling paradigm, namely Queuing Networks, with the aim of clarifying the state-of-art in exploiting such a notation to model and assess performance of Self-Adaptive Software Systems. We conclude by bringing out some research opportunities that may be worth exploring in the near future.},
  doi      = {https://doi.org/10.1016/j.procs.2020.03.108},
  groups   = {systematic_search},
  keywords = {Self-Adaptive Software Systems, Software Architectures, Autonomous Systems, Performance Engineering, Queuing Networks},
  url      = {https://www.sciencedirect.com/science/article/pii/S1877050920305469},
}

@Article{ZAVALA2020,
  author   = {Edith Zavala and Xavier Franch and Jordi Marco and Christian Berger},
  journal  = {Future Generation Computer Systems},
  title    = {HAFLoop: An architecture for supporting Highly Adaptive Feedback Loops in self-adaptive systems},
  year     = {2020},
  issn     = {0167-739X},
  pages    = {607-630},
  volume   = {105},
  abstract = {Most of the current self-adaptive systems (SASs) rely on static feedback loops such as the IBM’s MAPE-K loop for managing their adaptation process. Static loops do not allow SASs to react to runtime events such as changing adaptation requirements or MAPE-K elements’ faults. In order to address this issue, some solutions have emerged for manually or automatically perform changes on SASs’ feedback loops. However, from the software engineering perspective, most of the proposals cannot be reused or extended by other SASs. In this paper, we present HAFLoop (Highly Adaptive Feedback control Loop), a generic architectural proposal that aims at easing and fastening the design and implementation of adaptive feedback loops in modern SASs. Our solution enables both structural and parameter adaptation of the loop elements. Moreover, it provides a highly modular design that allows SASs’ owners to support a variety of feedback loop settings from centralized to fully decentralized. In this work, HAFLoop has been implemented as a framework for Java-based systems and evaluated in two emerging software application domains: self-driving vehicles and IoT networks. Results demonstrate that our proposal easies and accelerates the development of adaptive feedback loops as well as how it could help to address some of the most relevant challenges of self-driving vehicles and IoT applications. Concretely, HAFLoop has demonstrated to improve SASs’ feedback loops’ runtime availability and operation.},
  doi      = {https://doi.org/10.1016/j.future.2019.12.026},
  groups   = {systematic_search},
  keywords = {Self-adaptive system, Smart vehicle, IoT system, Adaptive monitoring, Adaptive feedback loop, Self-improvement},
  url      = {https://www.sciencedirect.com/science/article/pii/S0167739X19318448},
}

@InProceedings{Alkhabbas2020,
  author    = {Alkhabbas, Fahed and Murturi, Ilir and Spalazzese, Romina and Davidsson, Paul and Dustdar, Schahram},
  booktitle = {2020 IEEE International Conference on Software Architecture (ICSA)},
  title     = {A Goal-Driven Approach for Deploying Self-Adaptive IoT Systems},
  year      = {2020},
  month     = {March},
  pages     = {146-156},
  abstract  = {Engineering Internet of Things (IoT) systems is a challenging task partly due to the dynamicity and uncertainty of the environment including the involvement of the human in the loop. Users should be able to achieve their goals seamlessly in different environments, and IoT systems should be able to cope with dynamic changes. Several approaches have been proposed to enable the automated formation, enactment, and self-adaptation of goal-driven IoT systems. However, they do not address deployment issues. In this paper, we propose a goal-driven approach for deploying self-adaptive IoT systems in the Edge-Cloud continuum. Our approach supports the systems to cope with the dynamicity and uncertainty of the environment including changes in their deployment topologies, i.e., the deployment nodes and their interconnections. We describe the architecture and processes of the approach and the simulations that we conducted to validate its feasibility. The results of the simulations show that the approach scales well when generating and adapting the deployment topologies of goal-driven IoT systems in smart homes and smart buildings.},
  doi       = {10.1109/ICSA47634.2020.00022},
  groups    = {systematic_search},
  keywords  = {Topology;Cloud computing;Computer architecture;Internet of Things;Buildings;Adaptation models;Software;Deploying Self adaptive IoT Systems;Goal driven IoT Systems;Edge-Cloud Continuum;Software Architecture},
}

@Article{Han2020,
  author        = {Han, D.-S. and Yang, Q.-L. and Xing, J.-C. and Ma, G.-L.},
  journal       = {Journal of Computer Science and Technology},
  title         = {EasyModel: A Refinement-Based Modeling and Verification Approach for Self-Adaptive Software},
  year          = {2020},
  note          = {cited By 0},
  number        = {5},
  pages         = {1016-1046},
  volume        = {35},
  document_type = {Article},
  doi           = {10.1007/s11390-020-0499-x},
  groups        = {systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85094646667&doi=10.1007%2fs11390-020-0499-x&partnerID=40&md5=cbba00d65fa994c2741fc6877331aaf5},
}

@Conference{Kluge2020120,
  author        = {Kluge, T.},
  title         = {A role-based architecture for self-adaptive cyber-physical systems},
  year          = {2020},
  note          = {cited By 2},
  pages         = {120-124},
  document_type = {Conference Paper},
  doi           = {10.1145/3387939.3391601},
  groups        = {systematic_search},
  journal       = {Proceedings - 2020 IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2020},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85091534613&doi=10.1145%2f3387939.3391601&partnerID=40&md5=56976219d543d047b43b71a24d09f59f},
}

@Conference{Petrovska2020,
  author        = {Petrovska, A. and Quijano, S. and Gerostathopoulos, I. and Pretschner, A.},
  title         = {Knowledge aggregation with subjective logic in multi-agent self-adaptive cyber-physical systems},
  year          = {2020},
  note          = {cited By 4},
  pages         = {149-155},
  document_type = {Conference Paper},
  doi           = {10.1145/3387939.3391600},
  groups        = {systematic_search},
  journal       = {Proceedings - 2020 IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2020},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85093122120&doi=10.1145%2f3387939.3391600&partnerID=40&md5=32e797ce1b92c2d4e0514c9018136b14},
}

@Article{Krupitzer2020,
  author   = {Krupitzer, Christian and Temizer, Timur and Prantl, Thomas and Raibulet, Claudia},
  journal  = {IEEE Access},
  title    = {An Overview of Design Patterns for Self-Adaptive Systems in the Context of the Internet of Things},
  year     = {2020},
  issn     = {2169-3536},
  pages    = {187384-187399},
  volume   = {8},
  abstract = {The Internet of Things (IoT) requires the integration of all available, highly specialized, and heterogeneous devices, ranging from embedded sensor nodes to servers in the cloud. The self-adaptive research domain provides adaptive capabilities that can support the integration in IoT systems. However, developing such systems is a challenging, error-prone, and time-consuming task. In this context, design patterns propose already used and optimized solutions to specific problems in various contexts. Applying design patterns might help to reuse existing knowledge about similar development issues. However, so far, there is a lack of taxonomies on design patterns for self-adaptive systems. To tackle this issue, in this paper, we provide a taxonomy on design patterns for self-adaptive systems that can be transferred to support adaptivity in IoT systems. Besides describing the taxonomy and the design patterns, we discuss their applicability in an Industrial IoT case study.},
  doi      = {10.1109/ACCESS.2020.3031189},
  groups   = {systematic_search},
  keywords = {Synthetic aperture sonar;Software;Internet of Things;Monitoring;Taxonomy;Uncertainty;Software engineering;Design patterns;Internet of Things;IoT;self-adaptive systems;software engineering},
}

@Article{Zhou2020,
  author   = {Zhou, Peng and Zuo, Decheng and Hou, Kunmean and Zhang, Zhan and Dong, Jian},
  journal  = {IEEE Transactions on Reliability},
  title    = {Improving the Dependability of Self-Adaptive Cyber Physical System With Formal Compositional Contract},
  year     = {2020},
  issn     = {1558-1721},
  month    = {Sep.},
  number   = {3},
  pages    = {1130-1146},
  volume   = {69},
  abstract = {To adapt to the uncertain environment smartly and timely, cyber physical systems (CPSs) have to interact with the physical world in a decentralized but rigorous, organized way. Guaranteeing the timing reliability is key to achieve consensus on the order of distributed events, as well as dependable cooperative decision processing. Based on our hierarchically decentralized compositional self-adaptive framework, we propose a formal compositional reliability-contract-based solution to guarantee the timing reliability of event observation and decision processing in a large-scale, geographically distributed CPS. As the prophetic decision may not fit the local situation well because of the uncertainties, we propose a gradual contract optimization solution to refine the dependability, timeliness, and energy consumption. Following the seven proposed composition schemes, we employ the nondominated sorting genetic algorithm II (NSGA-II) algorithm to optimize arrangement of decision. Moreover, a topology-aware time reserving solution is applied to improve the resilience of processing time and to tolerance timing failures. Both simulation results and real-world testing are introduced to evaluate the efficacy of our proposal. We believe that the formal compositional contract will be a competitive CPS solution to analyze requirements and optimize the self-adaptation decision at runtime.},
  doi      = {10.1109/TR.2019.2930009},
  groups   = {systematic_search},
  keywords = {Contracts;Timing;Actuators;Sensors;Runtime;Redundancy;Compositional contract;cyber physical systems (CPSs);model@run.time;NSGA-II;self-adaptation;timing reliability},
}

@Conference{Suresh2020,
  author        = {Suresh, G.M. and Madhavu, M.L.},
  title         = {AI Based Intrusion Detection System Using Self-Adaptive Energy Efficient BAT Algorithm for Software Defined IoT Networks},
  year          = {2020},
  note          = {cited By 0},
  art_number    = {9225415},
  document_type = {Conference Paper},
  doi           = {10.1109/ICCCNT49239.2020.9225415},
  groups        = {systematic_search},
  journal       = {2020 11th International Conference on Computing, Communication and Networking Technologies, ICCCNT 2020},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85096616316&doi=10.1109%2fICCCNT49239.2020.9225415&partnerID=40&md5=1986c4a1f8515e0297342369fb73052d},
}

@Conference{Kluge2020,
  author        = {Kluge, T.},
  title         = {A role-based architecture for self-adaptive cyber-physical systems},
  year          = {2020},
  note          = {cited By 2},
  pages         = {120-124},
  document_type = {Conference Paper},
  doi           = {10.1145/3387939.3391601},
  groups        = {systematic_search},
  journal       = {Proceedings - 2020 IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2020},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85091534613&doi=10.1145%2f3387939.3391601&partnerID=40&md5=56976219d543d047b43b71a24d09f59f},
}

@Article{Flammini2020,
  author   = {Francesco Flammini and Stefano Marrone and Roberto Nardone and Mauro Caporuscio and Mirko D’Angelo},
  journal  = {Future Generation Computer Systems},
  title    = {Safety integrity through self-adaptation for multi-sensor event detection: Methodology and case-study},
  year     = {2020},
  issn     = {0167-739X},
  pages    = {965-981},
  volume   = {112},
  abstract = {Traditional safety-critical systems are engineered in a way to be predictable in all operating conditions. They are common in industrial automation and transport applications where uncertainties (e.g., fault occurrence rates) can be modeled and precisely evaluated. Furthermore, they use high-cost hardware components to increase system reliability. On the contrary, future systems are increasingly required to be “smart” (or “intelligent”) that is to adapt to new scenarios, learn and react to unknown situations, possibly using low-cost hardware components. In order to move a step forward to fulfilling those new expectations, in this paper we address run-time stochastic evaluation of quantitative safety targets, like hazard rate, in self-adaptive event detection systems by using Bayesian Networks and their extensions. Self-adaptation allows changing correlation schemes on diverse detectors based on their reputation, which is continuously updated to account for performance degradation as well as modifications in environmental conditions. To that aim, we introduce a specific methodology and show its application to a case-study of vehicle detection with multiple sensors for which a real-world data-set is available from a previous study. Besides providing a proof-of-concept of our approach, the results of this paper pave the way to the introduction of new paradigms in the dynamic safety assessment of smart systems.},
  doi      = {https://doi.org/10.1016/j.future.2020.06.036},
  groups   = {systematic_search},
  keywords = {Decision fusion, Performance evaluation, Run-time models, Bayesian networks, Cyber–physical systems, Intelligent transportation},
  url      = {https://www.sciencedirect.com/science/article/pii/S0167739X19333734},
}

@Article{BALLESTEROS2020,
  author   = {Joaquin Ballesteros and Inmaculada Ayala and Juan Rafael Caro-Romero and Mercedes Amor and Lidia Fuentes},
  journal  = {Journal of Biomedical Informatics},
  title    = {Evolving dynamic self-adaptation policies of mHealth systems for long-term monitoring},
  year     = {2020},
  issn     = {1532-0464},
  pages    = {103494},
  volume   = {108},
  abstract = {Tele-rehabilitation can complement traditional rehabilitation therapies by providing valuable information that can help in the evaluation, monitoring, and treatment of patients. Many patient tele-monitoring systems that integrate wearable technology are emerging as an effective tool for the long-term surveillance of rehabilitation progression, enabling continuous sampling of patient real-time movement in a non-invasive way, without affecting the normal daily activity of the outpatient, who, therefore, will not need to make frequent clinic visits. One of the main challenges of tele-rehabilitation systems is to pay special attention to the diversity of dysfunctions in patients by offering devices with customized behaviours adaptable to the physical conditions of each patient at the different stages of the rehabilitation therapy. Long-term monitoring systems need an adaptation policy to autonomously reconfigure their behaviour according to vital signs read during the physical activity of the patient, the remaining battery level, or the required accuracy of collected data. However, it would alsobe desirable to adjust such adaptation policies over time, according to the patient’s evolution. This work presents a wearable patient-monitoring system for tele-rehabilitation that is able to dynamically self-configure its internal behaviour to the current context of the outpatient according to a set of adaptation policies that optimize battery consumption, taking into account other QoS parameters at the same time. Our system is also able to self-adapt its internal adaptation policies as a patient’s condition improves, while maintaining the system’s efficiency. We illustrate our proposal with a real mHealth case study. The results of the experiments show that the system updates the adaptation policies, taking into account specific indicators of the disease. The validation results show that the evolution of the self-adaptation policies correlates with the progression of different patients.},
  doi      = {https://doi.org/10.1016/j.jbi.2020.103494},
  groups   = {systematic_search},
  keywords = {Context awareness, Fuzzy systems, Mobile applications, Reconfigurable architectures, Internet of Things, Activity recognition, Wearable computers, Ubiquitous computing, Software product lines, Adaptive systems, Assistive technology},
  url      = {https://www.sciencedirect.com/science/article/pii/S1532046420301222},
}

@InProceedings{cheng2020,
  author    = {Cheng, Betty HC and Clark, Robert Jared and Fleck, Jonathon Emil and Langford, Michael Austin and McKinley, Philip K},
  booktitle = {Proceedings of the 23rd ACM/IEEE International Conference on Model Driven Engineering Languages and Systems},
  title     = {AC-ROS: assurance case driven adaptation for the robot operating system},
  year      = {2020},
  pages     = {102--113},
  groups    = {systematic_search},
}

@InProceedings{legaard2020rapid,
  author    = {Legaard, Christian M{\o}ldrup and Gomes, Cl{\'a}udio and Larsen, Peter Gorm and Foldager, Frederik Forchhammer},
  booktitle = {Proceedings of the 2020 Summer Simulation Conference},
  title     = {Rapid prototyping of self-adaptive-systems using python functional mockup units},
  year      = {2020},
  pages     = {1--12},
  groups    = {systematic_search},
}

@InProceedings{camara2020towards,
  author    = {C{\'a}mara, Javier and Papadopoulos, Alessandro V and Vogel, Thomas and Weyns, Danny and Garlan, David and Huang, Shihong and Tei, Kenji},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Towards bridging the gap between control and self-adaptive system properties},
  year      = {2020},
  pages     = {78--84},
  groups    = {systematic_search},
}

@InProceedings{caldas2020hybrid,
  author    = {Caldas, Ricardo Diniz and Rodrigues, Arthur and Gil, Eric Bernd and Rodrigues, Gena{\'\i}na Nunes and Vogel, Thomas and Pelliccione, Patrizio},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {A hybrid approach combining control theory and AI for engineering self-adaptive systems},
  year      = {2020},
  pages     = {9--19},
  groups    = {systematic_search},
}

@InProceedings{liu2020leveraging,
  author    = {Liu, Kun and Zhang, Xiaoyi and Arcaini, Paolo and Ishikawa, Fuyuki and Jiao, Wenpin},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Leveraging test logs for building a self-adaptive path planner},
  year      = {2020},
  pages     = {57--63},
  groups    = {systematic_search},
}

@InProceedings{van2020applying,
  author    = {Van Der Donckt, Jeroen and Weyns, Danny and Quin, Federico and Van Der Donckt, Jonas and Michiels, Sam},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Applying deep learning to reduce large adaptation spaces of self-adaptive systems with multiple types of goals},
  year      = {2020},
  pages     = {20--30},
  groups    = {systematic_search},
}

@InProceedings{shmelkin2020monitoring,
  author    = {Shmelkin, Ilja},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Monitoring for control in role-oriented self-adaptive systems},
  year      = {2020},
  pages     = {115--119},
  groups    = {systematic_search},
}

@InProceedings{kumar2020datesso,
  author    = {Kumar, Satish and Chen, Tao and Bahsoon, Rami and Buyya, Rajkumar},
  booktitle = {Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
  title     = {Datesso: Self-adapting service composition with debt-aware two levels constraint reasoning},
  year      = {2020},
  pages     = {96--107},
  groups    = {systematic_search},
}

@InProceedings{stevens2020reducing,
  author       = {Stevens, Clay and Bagheri, Hamid},
  booktitle    = {2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE)},
  title        = {Reducing run-time adaptation space via analysis of possible utility bounds},
  year         = {2020},
  organization = {IEEE},
  pages        = {1522--1534},
  groups       = {systematic_search},
}

@InProceedings{Petrovska2021,
  author    = {Petrovska, Ana and Neuss, Malte and Gerostathopoulos, Ilias and Pretschner, Alexander},
  booktitle = {2021 International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Run-time Reasoning from Uncertain Observations with Subjective Logic in Multi-Agent Self-Adaptive Cyber-Physical Systems},
  year      = {2021},
  month     = {May},
  pages     = {130-141},
  abstract  = {Modern society has become increasingly reliant on the omnipresent cyber-physical systems (CPSs), making it paramount that the contemporary autonomous and decentralized CPSs (e.g., robots, drones and self-driving cars) act reliably despite their exposure to a variety of run-time uncertainties. The sources of uncertainties could be internal, i. e., originating from the systems themselves, or external-unpredictable environments. Self-adaptive CPSs (SACPSs) modify their behavior or structure at run-time in response to the uncertainties mentioned above. The adaptation relies on gained knowledge from the observations that the SACPSs make during their operation. As a result, to build the knowledge, the need for run-time observations aggregation and reasoning emerges since the observations made by decentralized CPSs are uncertain, partial, and potentially conflicting. In response, in this paper, we propose a novel methodological approach for deriving or aggregating knowledge from uncertain observations in SACPSs utilizing the Subjective Logic. The effectiveness of the proposed approach is demonstrated through extensive evaluation on an in-house, multi-agent system from the robotics domain.},
  doi       = {10.1109/SEAMS51251.2021.00026},
  groups    = {systematic_search},
  issn      = {2157-2321},
  keywords  = {Uncertainty;Cyber-physical systems;Cognition;Autonomous automobiles;Reliability;Robots;Software engineering;uncertainties;subjective logic;knowledge aggregation;self-adaptive systems;cyber-physical systems},
}

@InProceedings{Narayanankutty2021,
  author    = {Narayanankutty, Hrishikesh},
  booktitle = {2021 IEEE 18th International Conference on Software Architecture Companion (ICSA-C)},
  title     = {Self-Adapting Model-Based SDSec For IoT Networks Using Machine Learning},
  year      = {2021},
  month     = {March},
  pages     = {92-93},
  abstract  = {IoT networks today face a myriad of security vulnerabilities in their infrastructure due to its wide attack surface. Large-scale networks are increasingly adopting a Software-Defined Networking approach, it allows for simplified network control and management through network virtualization. Since traditional security mechanisms are incapable of handling virtualized environments, SDSec or Software-Defined Security is introduced as a solution to support virtualized infrastructure, specifically aimed at providing security solutions to SDN frameworks. To further aid large scale design and development of SDN frameworks, Model-Driven Engineering (MDE) has been proposed to be used at the design phase, since abstraction, automation and analysis are inherently key aspects of MDE. This provides an efficient approach to reducing large problems through models that abstract away the complex technicality of the total system. Making adaptations to these models to address security issues faced in IoT networks, largely reduces cost and improves efficiency. These models can be simulated, analysed and supports architecture model adaptation; model changes are then reflected back to the real system. We propose a model-driven security approach for SDSec networks that can self-adapt using machine learning to mitigate security threats. The overall design time changes can be monitored at run time through machine learning techniques (e.g. deep, reinforcement learning) for real time analysis. This approach can be tested in IoT simulation environments, for instance using the CAPS IoT modeling and simulation framework. Using self-adaptation of models and advanced machine learning for data analysis would ensure that the SDSec architecture adapts and improves over time. This largely reduces the overall attack surface to achieve improved end-to-end security in IoT environments.},
  doi       = {10.1109/ICSA-C52384.2021.00023},
  groups    = {systematic_search},
  keywords  = {Adaptation models;Analytical models;Software architecture;Computer architecture;Reinforcement learning;Real-time systems;Model driven engineering;Model-Driven Engineering;SDN;SDSec;IoT;Self-Adaptation;Machine Learning;Security},
}

@InProceedings{Petrovska2021a,
  author    = {Petrovska, Ana and Weick, Julian},
  booktitle = {2021 IEEE International Conference on Autonomic Computing and Self-Organizing Systems Companion (ACSOS-C)},
  title     = {Bayesian Optimization-Based Analysis and Planning Approach for Self-Adaptive Cyber-Physical Systems},
  year      = {2021},
  month     = {Sep.},
  pages     = {293-294},
  abstract  = {Modern cyber-physical systems (CPSs) operate in dynamic and uncertain environments or operational contexts. Therefore, it is necessary to design systems that self-adapt according to context changes at run-time. However, making a decision on the optimal adaptation in a changing and uncertain context is a complex task. This paper proposes a modular approach for analysis and planning, which generates the optimal system adaptations based on individual sub-decisions. Each sub-decision corresponds to a model @ RT that deals with specific aspects of the context relevant for the concrete adaptation. As a proof-of-concept, we introduce a multi-robot use case to show the possible performance gains of the suggested approach compared with non-adaptive analysis and planning.},
  doi       = {10.1109/ACSOS-C52956.2021.00077},
  groups    = {systematic_search},
  keywords  = {Adaptation models;Computational modeling;Conferences;Cyber-physical systems;Performance gain;Planning;Bayes methods;models@RT;context;analysis and planning;Bayesian optimization;robotics system},
}

@InProceedings{Zhang2021,
  author    = {Zhang, Mingyue},
  booktitle = {2021 IEEE/ACM 43rd International Conference on Software Engineering: Companion Proceedings (ICSE-Companion)},
  title     = {System Component-Level Self-Adaptations for Security via Bayesian Games},
  year      = {2021},
  month     = {May},
  pages     = {102-104},
  abstract  = {Security attacks present unique challenges to self-adaptive system design due to the adversarial nature of the environment. However, modeling the system as a single player, as done in prior works in security domain, is insufficient for the system under partial compromise and for the design of fine-grained defensive strategies where the rest of the system with autonomy can cooperate to mitigate the impact of attacks. To deal with such issues, we propose a new self-adaptive framework incorporating Bayesian game and model the defender (i.e., the system) at the granularity of components in system architecture. The system architecture model is translated into a Bayesian multi-player game, where each component is modeled as an independent player while security attacks are encoded as variant types for the components. The defensive strategy for the system is dynamically computed by solving the pure equilibrium to achieve the best possible system utility, improving the resiliency of the system against security attacks.},
  doi       = {10.1109/ICSE-Companion52605.2021.00047},
  groups    = {systematic_search},
  issn      = {2574-1926},
  keywords  = {Computational modeling;Systems architecture;Games;Bayes methods;Security;System analysis and design;Software engineering;Self-adaptation;Bayesian game;Security},
}

@InProceedings{Riaz2021,
  author    = {Riaz, Abdur Rehman and Rauf, Asma and Gilani, Syed Mushhad M. and Bashir, Muhammad Bilal},
  booktitle = {2021 4th International Conference on Computing Information Sciences (ICCIS)},
  title     = {Techniques and Methodologies of Self-Adaptive Software and its Architecture: A Survey},
  year      = {2021},
  month     = {Nov},
  pages     = {1-5},
  abstract  = {Nowadays, due to the continuously changing en-vironment, modern software systems can work in a dynamic environment. But many changes occur at runtime so, to handle the changes self-adaptive mechanism plays an important role. To encounter the requirement of rapid application development adaptive software is used widely. Adaptive software architecture is based on three steps speculate, collaborate, learn. There are a lot of techniques for adaptive software architecture most appropriate technique is selected by comparing them. In this paper, we perform a survey on different research papers related to the self-adaptive system and self-adaptive architecture. After studied the techniques gaps in the literature are identified and compare those techniques. Different common parameters are identified and considered by studying literature. Then these parameters are used to analyze survey techniques which is helpful for researchers and future directions in this area.},
  doi       = {10.1109/ICCIS54243.2021.9676190},
  groups    = {systematic_search},
  keywords  = {Adaptive systems;Runtime;Software architecture;Computer architecture;Software systems;Adaptive system;Adaptive Software;Software Architecture;Self-Adaptation;Dynamically adaptive systems},
}

@InProceedings{Junior2021,
  author    = {Junior, Evilasio Costa and de Castro Andrade, Rossana Maria and Rocha, Leonardo Sampaio},
  booktitle = {2021 IEEE 9th International Conference on Healthcare Informatics (ICHI)},
  title     = {Development Process for Self-adaptive Applications of the Internet of Health Things based on Movement Patterns},
  year      = {2021},
  month     = {Aug},
  pages     = {437-438},
  abstract  = {This study proposes a development process for self-adaptive IoHT applications based on movement pattern data for mobile devices. The proposed process adapts the component reuse-oriented development process by adding elements related to the construction of self-adaptive systems. Also, we propose five artifacts to support this process: a taxonomy relating data from sensors and health status to assist; a correlation graph between sensor data, movement features, and health situations, to assist the choice of components and serving as a knowledge base for self-adaptive application; a template for building adaptation rules; a model based on the MAPE-K adaptation cycle; and a framework based on the model, for assisting the implementation phase. The evaluation of the proposed process will be done using proofs of concept and an experiment.},
  doi       = {10.1109/ICHI52183.2021.00073},
  grooups   = {systematic_search},
  issn      = {2575-2634},
  keywords  = {Adaptation models;Taxonomy;Knowledge based systems;Medical services;Sensor phenomena and characterization;Data models;Software;Software Engineering;Internet of Health Things;Self-Adaptive Systems;Digital Health},
}

@InProceedings{Scheerer2021,
  author    = {Scheerer, Max and Reussner, Ralf},
  booktitle = {2021 International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
  title     = {Reliability Prediction of Self-Adaptive Systems Managing Uncertain AI Black-Box Components},
  year      = {2021},
  month     = {May},
  pages     = {111-117},
  abstract  = {Advances in Artificial Intelligence (AI) are associated with a growing complexity of AI models, at the expense of transparency and comprehensibility. The black-box nature of AI components is of particular concern in safety-critical applications, as it can not be guaranteed whether a prediction is correct or not. Incorrect predictions, however, can have serious consequences, e.g., fatal collisions in autonomous driving. Therefore, we propose a novel method for safeguarding AI black-box components based on monitoring input data by using Self-Adaptive Systems (SAS). The presented concepts serve not only as a starting point for runtime approaches (e.g., models at runtime), but also for design-time approaches. As second contribution, we propose an approach for the validation of reconfiguration strategies of SAS's managing uncertain AI black-box components w.r.t. reliability objectives at design-time. We demonstrate the applicability of our approach by a proof-of-concept.},
  doi       = {10.1109/SEAMS51251.2021.00024},
  groups    = {systematic_search},
  issn      = {2157-2321},
  keywords  = {Analytical models;Runtime;Predictive models;Reliability engineering;Software reliability;Complexity theory;Artificial intelligence;Self-adaptive systems;reliable machine learning;model-based reliability analysis;design-time analysis;AI black-box models},
}

@Article{Restrepo2021,
  author        = {Restrepo, L. and Aguilar, J. and Toro, M. and Suescún, E.},
  journal       = {Journal of Systems and Software},
  title         = {A sustainable-development approach for self-adaptive cyber–physical system's life cycle: A systematic mapping study},
  year          = {2021},
  note          = {cited By 0},
  volume        = {180},
  art_number    = {111010},
  document_type = {Article},
  doi           = {10.1016/j.jss.2021.111010},
  groups        = {systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85107766571&doi=10.1016%2fj.jss.2021.111010&partnerID=40&md5=d448645aacc3ff1b088bd1b3a1cb12db},
}

@Conference{Tong2021,
  author        = {Tong, Y. and Qin, Y. and Jiang, Y. and Xu, C. and Cao, C. and Ma, X.},
  title         = {Timely and accurate detection of model deviation in self-adaptive software-intensive systems},
  year          = {2021},
  note          = {cited By 0},
  pages         = {168-180},
  document_type = {Conference Paper},
  doi           = {10.1145/3468264.3468548},
  groups        = {systematic_search},
  journal       = {ESEC/FSE 2021 - Proceedings of the 29th ACM Joint Meeting European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85116204462&doi=10.1145%2f3468264.3468548&partnerID=40&md5=3c478f7321c8b34921ac8eaf67499150},
}

@InProceedings{Bellini2021,
  author    = {Bellini, Emanuele and Bagnoli, Franco and Caporuscio, Mauro and Damiani, Ernesto and Flammini, Francesco and Linkov, Igor and Liò, Pietro and Marrone, Stefano},
  booktitle = {2021 IEEE International Conference on Cyber Security and Resilience (CSR)},
  title     = {Resilience learning through self adaptation in digital twins of human-cyber-physical systems},
  year      = {2021},
  month     = {July},
  pages     = {168-173},
  abstract  = {Human-Cyber-Physical-Systems (HPCS), such as critical infrastructures in modern society, are subject to several systemic threats due to their complex interconnections and interdependencies. Management of systemic threats requires a paradigm shift from static risk assessment to holistic resilience modeling and evaluation using intelligent, data-driven and run-time approaches. In fact, the complexity and criticality of HCPS requires timely decisions considering many parameters and implications, which in turn require the adoption of advanced monitoring frameworks and evaluation tools. In order to tackle such challenge, we introduce those new paradigms in a framework named RESILTRON, envisioning Digital Twins (DT) to support decision making and improve resilience in HCPS under systemic stress. In order to represent possibly complex and heterogeneous HCPS, together with their environment and stressors, we leverage on multi-simulation approaches, combining multiple formalisms, data-driven approaches and Artificial Intelligence (AI) modelling paradigms, through a structured, modular and compositional framework. DT are used to provide an adaptive abstract representation of the system in terms of multi-layered spatially-embedded dynamic networks, and to apply self-adaptation to time-warped What-If analyses, in order to find the best sequence of decisions to ensure resilience under uncertainty and continuous HPCS evolution.},
  doi       = {10.1109/CSR51186.2021.9527913},
  groups    = {systematic_search},
  keywords  = {Adaptation models;Uncertainty;Digital twin;Decision making;Tools;Time factors;Artificial intelligence},
}

@Article{Raibulet2021,
  author        = {Raibulet, C. and Fontana, F.A. and Carettoni, S.},
  journal       = {Communications in Computer and Information Science},
  title         = {Internal Software Quality Evaluation of Self-adaptive Systems Using Metrics, Patterns, and Smells},
  year          = {2021},
  note          = {cited By 0},
  pages         = {386-419},
  volume        = {1375},
  document_type = {Conference Paper},
  doi           = {10.1007/978-3-030-70006-5_16},
  groups        = {systematic_search},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85103232322&doi=10.1007%2f978-3-030-70006-5_16&partnerID=40&md5=439aa434058cf2140dff9b0bcd2999fa},
}

@Article{AraujodeOliveira2021,
  author   = {Araújo-de-Oliveira, Patrícia and Durán, Francisco and Pimentel, Ernesto},
  journal  = {Software: Practice and Experience},
  title    = {A procedural and flexible approach for specification, modeling, definition, and analysis for self-adaptive systems},
  year     = {2021},
  number   = {6},
  pages    = {1387-1415},
  volume   = {51},
  abstract = {Abstract An adaptive system can modify its settings at runtime as a response to changes in its operational environment. To analyse this kind of systems at design time is a difficult task since it requires considering the system together with the adaptation operations, and taking into account how such adaptations act on the system. In order to use simulation-based techniques for the analysis of such systems, we not only need precise executable models of the systems to be analyzed, but also to capture the semantics of their adaptation mechanisms. Given the wide range and flexibility of adaptation operations, we need ways to allow the definition of new operations. We present a flexible approach for the definition and simulation-based analysis in design-time of adaptive component-based systems. Our approach combines an extension of the Palladio component model in e-Motions, a model of the adaptation mechanisms, and elastic requirements specification using the SYBL language. From the model of the system, its adaptation mechanisms, and its requirements, an executable Maude specification is generated for simulation. The application of the approach is illustrated on a use case that comprises some components and adaptations rules. The example is then analyzed using simulations. It is also shown that it is indeed possible to define additional metrics, specify adaptation requirements and rules which conduct simulations of the models in a more flexible way, and that the results of the simulation performed from these definitions can be used to carry on a valuable predictive performance analysis.},
  doi      = {https://doi.org/10.1002/spe.2962},
  eprint   = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.2962},
  groups   = {systematic_search},
  keywords = {adaptation specification, design-time analysis, modeling, self-adaptive behavior, self-adaptive models},
  url      = {https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.2962},
}

@Article{ALIDOOSTNIA2021,
  author   = {Mehran {Alidoost Nia} and Mehdi Kargahi and Alessandro Abate},
  journal  = {Journal of Systems Architecture},
  title    = {Resilient monitoring in self-adaptive systems through behavioral parameter estimation},
  year     = {2021},
  issn     = {1383-7621},
  pages    = {102177},
  volume   = {118},
  abstract = {Cyber-physical systems need self-adaptation as a mean to autonomously deal with changes. For runtime adaptation, a cyber-physical system repeatedly monitors the environment for detecting possible changes. Faults in the monitoring devices due to the dynamic and uncertain environment is very likely, necessitating resilient monitoring. In this paper, we discuss imperfect monitoring in self-adaptive systems, and propose a model-driven methodology to represent the self-adaptive system using a parametric Markov decision process, where the changes are reflected by a set of model parameters. Fault in the monitoring device may result in some parameter valuation miss. We propose a comprehensive framework for parameter estimation using behavioral patterns of the system implemented by a pattern-matching component. The proposed method simulates the current behavior of the system using random walk patterns, and matches it to a history of patterns for estimating the valuation of the omitted data. The results show that the accuracy of the framework is evaluated about 96% under imperfect monitoring. In addition, we elaborate a set of theoretical proofs to support rigorous error analysis, and determine a certain upper-bound of errors to guarantee an accurate decision-making outcome. We establish a logical connection between the error and the accuracy of decisions, and introduce tolerable error metric that is used to guarantee the accuracy of decisions under estimation.},
  doi      = {https://doi.org/10.1016/j.sysarc.2021.102177},
  groups   = {systematic_search},
  keywords = {Self-adaptive systems, Monitoring faults, Runtime verification, Pattern-matching, Parameter estimation},
  url      = {https://www.sciencedirect.com/science/article/pii/S1383762121001272},
}

@Article{AUDRITO2021,
  author   = {Giorgio Audrito and Roberto Casadei and Ferruccio Damiani and Volker Stolz and Mirko Viroli},
  journal  = {Journal of Systems and Software},
  title    = {Adaptive distributed monitors of spatial properties for cyber–physical systems},
  year     = {2021},
  issn     = {0164-1212},
  pages    = {110908},
  volume   = {175},
  abstract = {Cyber–physical systems increasingly feature highly-distributed and mobile deployments of devices spread over large physical environments: in these contexts, it is generally very difficult to engineer trustworthy critical services, mostly because formal methods generally hardly scale with the number of involved devices, especially when faults, continuous changes, and dynamic topologies are the norm. To start addressing this problem, in this paper we devise a formally correct and self-adaptive implementation of distributed monitors for spatial properties. We start from the Spatial Logic of Closure Spaces, and provide a compositional translation that takes a formula and yields a distributed program that provides runtime verification of its validity. Such programs are expressed in terms of the field calculus, a recently emerged computational model that focusses on global-level outcomes instead of single-device behaviour, and expresses distributed computations by pure functions and the functional composition mechanism. By reusing previous results and tools of the field calculus, we prove correctness of the translation, self-stabilisation of the derived monitors, and empirically evaluate adaptivity of such monitors in a realistic smart city scenario of safe crowd monitoring and control.},
  doi      = {https://doi.org/10.1016/j.jss.2021.110908},
  groups   = {systematic_search},
  keywords = {Spatial logics, Runtime verification, Self-adaptive systems, Field calculus},
  url      = {https://www.sciencedirect.com/science/article/pii/S0164121221000054},
}

@Article{pfannemuller2021react,
  author    = {Pfannem{\"u}ller, Martin and Breitbach, Martin and Weckesser, Markus and Becker, Christian and Schmerl, Bradley and Sch{\"u}rr, Andy and Krupitzer, Christian},
  journal   = {ACM Transactions on Autonomous and Adaptive Systems (TAAS)},
  title     = {REACT-ION: A model-based runtime environment for situation-aware adaptations},
  year      = {2021},
  number    = {4},
  pages     = {1--29},
  volume    = {15},
  groups    = {systematic_search},
  publisher = {ACM New York, NY},
}

@InProceedings{akiki2021towards,
  author    = {Akiki, Paul A},
  booktitle = {Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
  title     = {Towards an approach for resource-driven adaptation},
  year      = {2021},
  pages     = {1625--1629},
  groups    = {systematic_search},
}

@Article{grohmann2021sarde,
  author    = {Grohmann, Johannes and Eismann, Simon and Bauer, Andr{\'e} and Spinner, Simon and Blum, Johannes and Herbst, Nikolas and Kounev, Samuel},
  journal   = {ACM Transactions on Autonomous and Adaptive Systems (TAAS)},
  title     = {SARDE: A Framework for Continuous and Self-Adaptive Resource Demand Estimation},
  year      = {2021},
  number    = {2},
  pages     = {1--31},
  volume    = {15},
  groups    = {systematic_search},
  publisher = {ACM New York, NY, USA},
}

@Book{Shevtsov2019a,
  author        = {Shevtsov, S. and Weyns, D. and Maggio, M.},
  title         = {Self-adaptation of software using automatically generated control-theoretical solutions},
  year          = {2019},
  note          = {cited By 1},
  abstract      = {Control theory has contributed a set of foundational techniques to handle "change" at runtime in software applications. These techniques however have fundamental limitations as well: (i) they require the development and understanding of mathematical models; (ii) synthesizing solutions is often done on a per-problem basis, discouraging flexibility and generality. Software engineering, as a discipline, has always aimed at finding reusable and modular solutions. The combination of the desire to apply formally grounded control-theoretical principles and reuse existing solutions has motivated research on the topic of automatically generated control solutions. This research aims at designing control strategies in an automated way from data that qualifies the given problem at hand. This chapter provides an overview of the research topic of automatically generated control-theoretical solutions, explaining the key research contributions and paving the way for future research. © Springer Nature Singapore Pte Ltd. 2019. All Rights reserved.},
  document_type = {Book Chapter},
  doi           = {10.1007/978-981-13-2185-6_2},
  file          = {:download_papers/Shevtsov-2019-Self-adaptation of software using automatically.pdf:PDF},
  groups        = {scopus, systematic_search},
  journal       = {Engineering adaptive software systems: Communications of nii shonan meetings},
  pages         = {35-55},
  source        = {Scopus},
  url           = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-85078198507&doi=10.1007%2f978-981-13-2185-6_2&partnerID=40&md5=5d45aa59e7707e530add43ef907ee199},
}

@InProceedings{da2021catalog,
  author    = {da Silva, Maike Bezerra and Bezerra, Carla and Coutinho, Emanuel and Maia, Paulo Henrique},
  booktitle = {XX Brazilian Symposium on Software Quality},
  title     = {A Catalog of Performance Measures for Self-Adaptive Systems},
  year      = {2021},
  pages     = {1--10},
  groups    = {systematic_search},
}

@Article{rahimi2021q,
  author  = {Rahimi, Hamed and Trentin, Iago Felipe and Ramparany, Fano and Boissier, Olivier},
  journal = {arXiv preprint arXiv:2107.05949},
  title   = {Q-SMASH: Q-Learning-based Self-Adaptation of Human-Centered Internet of Things},
  year    = {2021},
  groups  = {systematic_search},
}

@Article{gheibi2021applying,
  author    = {Gheibi, Omid and Weyns, Danny and Quin, Federico},
  journal   = {ACM Transactions on Autonomous and Adaptive Systems (TAAS)},
  title     = {Applying machine learning in self-adaptive systems: A systematic literature review},
  year      = {2021},
  number    = {3},
  pages     = {1--37},
  volume    = {15},
  groups    = {systematic_search},
  publisher = {ACM New York, NY, USA},
}

@Comment{jabref-meta: databaseType:bibtex;}

@Comment{jabref-meta: grouping:
0 AllEntriesGroup:;
1 StaticGroup:systematic_search\;0\;1\;0x0000ffff\;\;papers gathered from systematic search from databases\;;
1 StaticGroup:expert_search\;0\;1\;0xffff00ff\;\;papers gathered from survey papers\;;
}