CHAPTER ARCHITECTING SOFTWARE SYSTEMS FOR RUNTIME SELF-ADAPTATION: CONCEPTS, MODELS, AND CHALLENGES 2 N.M. Villegas*, G. Tamura*, H.A. M € uller † Universidad Icesi, Cali, Colombia * University of Victoria, Victoria, BC, Canada † 2.1 INTRODUCTION Self-adaptive software systems modify their own structure or behavior at runtime to regulate the sat- isfaction of functional and nonfunctional requirements that change over time, for instance when af- fected by changes in the system’s context of execution (e.g., when facing a sudden and unusually large increment of user requests that causes the agreed upon throughput to be violated) [1–5]. For mod- ifying the software structure or behavior, either at a coarse- or fine-grained level, and both at design time and runtime, most of the approaches rely on the structure or behavior determined by the software architecture. As a result, software architecture is among the most critical enablers for both adaptation and self-adaptation as a means to regulate requirements satisfaction, in particular of nonfunctional ones, under changing contexts of execution. In traditional software engineering, as summarized succinctly by the Software Engineering Institute (SEI) in 2006, architecture design usually starts from a set of architecturally significant requirements [6]. Designed as the footprint for the solution, the architecture is expected to guarantee requirements satisfaction, without special consideration of changes in context that can violate assumptions regarding the immutability of requirements. In contrast, from the self-adaptive software engineering point of view, even though architects depart also from functional and nonfunctional requirements, they focus precisely on context changes that could violate the satisfaction of these requirements at execution time, including the expected quality attributes. For systems facing this kind of context changes, the designed architecture must enable the software to be self-aware, that is, it must include components that enable the system to dynamically reconfigure its own structure or behavior at runtime. This implies, among others, to monitor its own behavior with respect to its current goals (e.g., nonfunctional requirements), and modify its own structure based on an internal, but explicit, representation of itself. This chapter discusses the meaning of software design-time adaptation, and runtime self- adaptation, and their implications for the task of architecting this kind of software systems. Of course, architecting software systems that are self-adaptive at runtime implies the understanding of the way the Managing Trade-offs in Adaptable Software Architectures. http://dx.doi.org/10.1016/B978-0-12-802855-1.00002-2 Copyright # 2017 Elsevier Inc. All rights reserved. 17