There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

Cyber-Physical-Human Systems (CPHSs) are the integration, mostly focused on the interactions, of cyber, physical and humans elements that work together towards the achievement of the objectives of the system. Users continuously rely on CPHSs to fulfil personal goals, thus becoming active, relevant, and necessary components of the designed system. The gap between humans and technology is getting smaller. Users are increasingly demanding smarter and personalized applications, capable of understanding and acting upon changing situations. However, humans are highly dynamic, their decisions might not always be predictable, and they expose themselves to unforeseeable situations that might impact their interactions with their physical and cyber elements. The problem addressed in this dissertation is the support of CPHSs' user-centric requirements at runtime. Therefore, this dissertation focuses on the investigation of runtime models and infrastructures for: (1) understanding users, their personal goals and changing situations, (2) causally connecting the cyber, physical and human components involved in the achievement of users' personal goals, and (3) supporting runtime adaptation to respond to relevant changes in the users' situations. Situation-awareness and runtime adaptation pose significant challenges for the engineering of user-centric CPHSs. There are three challenges associated with situation-awareness: first, the complexity and dynamism of users' changing situations require specifications that explicitly connect users with personal goals and relevant context. Second, the achievement of personal goals entails comprehensive representations of user's tasks and sequences and measurable outcomes. Third, situation-awareness implies the analysis of context towards an understanding of users' changing conditions. Therefore, there is a need for representations and reasoning techniques to infer emerging situations. There are three challenges associated with runtime adaptation: first, the dynamic nature of CPHSs and users require runtime models to make explicit the components of CPHSs and their interactions. Second, the definition of architectural and functional requirements of CPHSs to support runtime user-centric awareness and adaptation. Finally, the design and implementation of runtime adaptation techniques to support dynamic changes in the specification of the CPHSs' runtime models. The four contributions of this dissertation add to the body of knowledge for the development of smart applications centred around the achievement of users' personal goals. First, we propose a definition and architectural design for the implementation of user-centric smart cyber-physical-human applications (UCSAs). Our design proposes a context-aware self-adaptive system supported by a runtime infrastructure to manage CRUD operations. Second, we propose two models at runtime (MARTs): (1) our Galapagos Metamodel, which defines the concepts of a UCSA; and (2) our Galapagos Model, which supports the specification of evolving tasking goals, personal interactions, and the relevant contexts. Third, we propose our operational framework, which defines model equivalences between human-readable and machine-readable, available runtime operations and semantics, to manage runtime operations on MARTs. Finally, we propose our processing infrastructure for models at runtime (PRIMOR), which is a component-based system responsible for providing reading access from software components to the MARTs, executing model-related runtime operations, and managing the propagation of changes among interconnected MARTs and their realities. To evaluate our contributions, we conducted a literature review of models and performed a qualitative analysis to demonstrate the novelty of our approach by comparing it with related approaches. We demonstrated that our models satisfy MARTs characteristics, therefore making them proper models at runtime. Furthermore, we performed an experimental analysis based on our case study on online grocery shopping for the elderly. We focused our analysis on the runtime operations specified in the framework as supported by the corresponding MART (accuracy and scalability), and our infrastructure to manage runtime operation and growing MARTs (performance). / Graduate

Ubiquitous and Pervasive computing put forth a vision where environments are enriched with devices that provide users with services to serve them in their everyday lives. The building of such environments has the final objective of automating tedious routine tasks that users must perform every day. This automation is a very desirable challenge because it can considerably reduce resource consumption and improve users' quality of life by 1) making users' lives more comfortable, eficient, and productive, and 2) helping them to stop worrying and wasting time in performing tasks that need to be done and that they do not enjoy. However, the automation of user tasks is a complicated and delicate matter because it may bother users, interfere in their goals, or even be dangerous. To avoid this, tasks must be automated in a non-intrusive way by attending to users' desires and demands. This is the main goal of this thesis, that is, to automate the routine tasks that users want the way they want them. To achieve this, we propose two models of a high level of abstraction to specify the routines to be automated. These models provide abstract concepts that facilitate the participation of end-users in the model specification. In addition, these models are designed to be machine-processable and precise-enough to be executable models. Thus, we provide a software infrastructure that is capable of automating the specified routines by directly interpreting the models at runtime. Therefore, the routines to be automated are only represented in the models. This makes the models the primary means to understand, interact with, and modify the automated routines. This considerably facilitates the evolution of the routines over time to adapt them to changes in user behaviour. Without this adaptation, the automation of the routines may not only become useless for end-users but may also become a burden on them instead of being a help in their daily life. / Serral Asensio, E. (2011). Automating Routine Tasks in Smart Environments. A Context-aware Model-driven Approach [Tesis doctoral]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/11550

The development of self-adaptive software requires the engineering of an adaptation engine that controls and adapts the underlying adaptable software by means of feedback loops. The adaptation engine often describes the adaptation by using runtime models representing relevant aspects of the adaptable software and particular activities such as analysis and planning that operate on these runtime models. To systematically address the interplay between runtime models and adaptation activities in adaptation engines, runtime megamodels have been proposed for self-adaptive software. A runtime megamodel is a specific runtime model whose elements are runtime models and adaptation activities. Thus, a megamodel captures the interplay between multiple models and between models and activities as well as the activation of the activities. In this article, we go one step further and present a modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that considerably 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 for feedback loops. Megamodels are kept explicit and 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, their runtime models, and adaptation activities explicit at a higher level of abstraction. Moreover, it enables complex solutions where multiple feedback loops interact or even operate on top of each other. Finally, it leverages the co-existence of self-adaptation and off-line adaptation for evolution. / Die Entwicklung selbst-adaptiver Software erfordert die Konstruktion einer sogenannten "Adaptation Engine", die mittels Feedbackschleifen die unterliegende Software steuert und anpasst. Die Anpassung selbst wird häufig mittels Laufzeitmodellen, die die laufende Software repräsentieren, und Aktivitäten wie beispielsweise Analyse und Planung, die diese Laufzeitmodelle nutzen, beschrieben. Um das Zusammenspiel zwischen Laufzeitmodellen und Aktivitäten systematisch zu erfassen, wurden Megamodelle zur Laufzeit für selbst-adaptive Software vorgeschlagen. Ein Megamodell zur Laufzeit ist ein spezielles Laufzeitmodell, dessen Elemente Aktivitäten und andere Laufzeitmodelle sind. Folglich erfasst ein Megamodell das Zusammenspiel zwischen verschiedenen Laufzeitmodellen und zwischen Aktivitäten und Laufzeitmodellen als auch die Aktivierung und Ausführung der Aktivitäten. Darauf aufbauend präsentieren wir in diesem Artikel eine Modellierungssprache für ausführbare Megamodelle zur Laufzeit, EUREMA genannt, die aufgrund eines modellgetriebenen Ansatzes die Entwicklung selbst-adaptiver Software erleichtert. Der Ansatz umfasst eine domänen-spezifische Modellierungssprache und einen Laufzeit-Interpreter für Adaptation Engines, insbesondere für Feedbackschleifen. EUREMA Megamodelle werden über die Spezifikationsphase hinaus explizit zur Laufzeit genutzt, um mittels Interpreter Feedbackschleifen direkt auszuführen. Zusätzlich können Megamodelle zur Laufzeit dynamisch geändert werden, um Feedbackschleifen anzupassen. Daher unterstützt EUREMA die Entwicklung selbst-adaptiver Software durch die explizite Spezifikation von Feedbackschleifen, der verwendeten Laufzeitmodelle, und Adaptionsaktivitäten auf einer höheren Abstraktionsebene. Darüber hinaus ermöglicht EUREMA komplexe Lösungskonzepte, die mehrere Feedbackschleifen und deren Interaktion wie auch die hierarchische Komposition von Feedbackschleifen umfassen. Dies unterstützt schließlich das integrierte Zusammenspiel von Selbst-Adaption und Wartung für die Evolution der Software.

Submitted by Cássia Santos (cassia.bcufg@gmail.com) on 2015-10-26T10:10:03Z No. of bitstreams: 2 Dissertação - Paulo César Ferreira Melo - 2014.pdf: 3222791 bytes, checksum: f18cd58c678bb5d11f8bd0cabb32f099 (MD5) license_rdf: 23148 bytes, checksum: 9da0b6dfac957114c6a7714714b86306 (MD5) / Approved for entry into archive by Luciana Ferreira (lucgeral@gmail.com) on 2015-10-26T13:03:05Z (GMT) No. of bitstreams: 2 Dissertação - Paulo César Ferreira Melo - 2014.pdf: 3222791 bytes, checksum: f18cd58c678bb5d11f8bd0cabb32f099 (MD5) license_rdf: 23148 bytes, checksum: 9da0b6dfac957114c6a7714714b86306 (MD5) / Made available in DSpace on 2015-10-26T13:03:05Z (GMT). No. of bitstreams: 2 Dissertação - Paulo César Ferreira Melo - 2014.pdf: 3222791 bytes, checksum: f18cd58c678bb5d11f8bd0cabb32f099 (MD5) license_rdf: 23148 bytes, checksum: 9da0b6dfac957114c6a7714714b86306 (MD5) Previous issue date: 2014-10-15 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - CAPES / Recent advances in ubiquitous computing have contributed to the rise of an emerging category of mobile devices that have computational and sensing capabilities, such as smartphones and wearable devices. The widespread use of these devices connected by communication networks contribute to the evolution of the Internet of Things. The presence of these mobile devices increases the chance for the development of applications using the sensing ability of these devices to measure, and understand the environmental indicators. Furthemore, data sensed by these applications can be shared among different mobile devices, giving rise to a paradigm called mobile crowdsensing. The complexity of applications in this domain is associated with factors such as interoperability between different mobile devices, data identification and capture from these devices, and adaptation of their use in heterogeneous and dynamic environments. Software engineering approaches such as Model-Driven Engineering (MDE) and, more specifically, models at runtime are an effective way of dealing with this complexity. We propose the use of an approach based on models at runtime for creating and processing mobile crowdsensing queries.We show how this approach can be used by defining a domain-specific modeling language for the mobile crowdsensing domain, called CSML. We built and validated the CSML metamodel which captures the main aspects of the domain, and its execution environment, which consists of an execution engine for models described in CSML, called CSVM. This approach facilitates the specification of mobile crowdsensing queries, also enabling their dynamic change during their processing. / Recentes avanços na computação ubíqua colaboraram para a ascensão de uma categoria emergente de dispositivos móveis que apresentam capacidades computacionais e de sensoriamento, tais como smartphones e dispositivos vestíveis. A proliferação desses dispositivos e sua conexão por meio de redes de comunicação contribui para a evolução da Internet das Coisas. A presença desses dispositivos móveis aumenta a oportunidade para o desenvolvimento de aplicações que utilizam sua capacidade de sensoriamento a fim de medir, inferir e entender os indicadores do ambiente. Por sua vez, os dados sensoriados por essas aplicações podem ser compartilhados entre diferentes dispositivos móveis, dando origem ao paradigma denominado CrowdSensing móvel. A complexidade de aplicações pertencentes ao domínio de CrowdSensing móvel está associada a fatores como interoperabilidade entre diferentes dispositivos móveis, identificação e captação de dados provenientes desses dispositivos e adaptação de seu uso em ambientes heterogêneos e dinâmicos. Abordagens baseadas na Engenharia Dirigida por Modelos (MDE), como modelos em tempo de execução constituem uma forma de lidar com complexidade desse domínio de aplicações. Neste trabalho propomos o uso de uma abordagem dirigida por modelos em tempo de execução para criação e processamento de consultas de crowdsensing móvel que são um importante elemento de aplicações de crowdsensing. Mostramos como essa abordagem pode ser empregada por meio da definição de uma linguagem de modelagem específica para o domínio de crowdsensing móvel, denominada CSML. Neste sentido, construímos e validamos o metamodelo da CSML, que captura os principais aspectos do domínio e seu ambiente de execução, que consiste em uma máquina de execução de modelos descritos em CSML, denominada CSVM . Essa abordagem dirigida por modelos facilita a especificação de consultas de crowdsensing móvel, além de possibilitar a alteração dinâmica dessas consultas durante seu processamento.

La Computaci'on Ubicua plantea proveer de inteligencia a nuestros entornos ofreciendo servicios a los usuarios que permitan ayudarlos en su vida cotidiana. Con la inclusi'on de dispositivos ubicuos en nuestra vida (por ejemplo los dispositivos m'oviles), los usuarios hemos pasado a estar siempre conectados al entorno, pudiendo interactuar con el. Sin embargo, a diferencia de las interacciones de escritorio tradicionales donde los usuarios eran quienes ped'¿an informaci'on o introduc'¿an datos, las interacciones ubicuas tienen que lidiar con un entorno de los usuarios variable, demandando uno de los recursos mas valiosos para los usuarios: la atenci'on humana. De esta forma, un reto en el paradigma de computaci'on ubicua es regular las peticiones de atenci'on del usuario. Esto implica que las interacciones de los servicios deber'¿an comportarse de una manera ¿considerada¿ teniendo en cuenta el grado en que cada servicio se inmiscuye en la mente del usuario (el nivel de molestia). Partiendo de las bases de la Ingenier'¿a Dirigida por Modelos (MDE) y de los principios de la Computaci'on Considerada, esta tesis se orienta a dise¿nar y desarrollar servicios que sean capaces de adaptar sus interacciones de acuerdo a la atenci'on del usuario en cada momento. El principal objetivo de esta tesis es introducir capacidades de adaptaci'on considerada en los servicios ubicuos para proporcionar interacciones que no perturben al usuario. Esto lo conseguimos mediante un proceso de desarrollo que cubre desde el dise¿no de los servicios hasta su implementaci'on, centr'andose en los requisitos de adaptaci'on de la interacci'on particulares para cada usuario. Para el dise¿no del comportamiento de la interacci'on en base al nivel de molestia se han de¿nido unos modelos de intromisi'on e interacci'on independientes de la tecnolog'¿a. Estos modelos son los que posteriormente conducen la adaptaci'on de la interacci'on din'amicamente, por medio de una infraestructura aut'onoma que los usa en tiempo de ejecuci'on. Esta infraestructura es capaz de detectar cambios en la situaci'on del usuario (por ejemplo cambios en su localizaci'on, su actividad, etc.) y planear y ejecutar modi¿caciones en la interacci'on de los servicios. Cuando se detecta un cambio del contexto del usuario, los servicios se auto-adaptan para usar los componentes de interacci'on m'as apropiados de acuerdo a la nueva situaci'on y no molestar al usuario. Adem'as, como las necesidades y preferencias de los usuarios pueden cambiar con el tiempo, nuestra aproximaci'on utiliza la estrategia del aprendizaje por refuerzo para ajustar los modelos de dise¿no iniciales de forma que maximicemos la experiencia del usuario. El dise¿no inicial de la interacci'on basado en el nivel de molestia nos asegura un comportamiento inicial consistente con las necesidades de los usuarios en ese momento. Luego, este dise¿no se va re¿nando de acuerdo al comportamiento y preferencias de cada usuario por medio de su retroalimentaci'on a trav'es de la experiencia de uso. Adem'as, tambi'en proporcionamos una interfaz m'ovil que permite a los usuarios ¿nales personalizarse de forma manual los modelos en base a sus propias preferencias. El trabajo presentado en esta tesis se ha llevado a la pr'actica para su evaluaci'on desde el punto de vista de los dise¿nadores y de los usuarios ¿nales. Por una parte, el m'etodo de dise¿no se ha validado para comprobar que ayuda a los dise¿nadores a especi¿car este tipo de servicios. Pese a que el proceso de desarrollo no ofrece una automatizaci'on completa, las gu'¿as ofrecidas y la formalizaci'on de los conceptos implicados ha demostrado ser 'util a la hora de desarrollar servicios cuya interacci'on es no molesta. Por otra parte, la adaptaci'on de la interacci'on en base al nivel de molestia se ha puesto en pr'actica con usuarios para evaluar su satisfacci'on con el sistema y su experiencia de usuario. Esta validaci'on ha desvelado la importancia de considerar los aspectos de molestia en el proceso de adaptaci'on de la interacci'on para ayudar a mejorar la experiencia de usuario. / In Ubiquitous Computing environments, people are surrounded by a lot of embedded services. Since ubiquitous devices, such as mobile phones, have become a key part of our everyday life, they enable users to be always connected to the environment and interact with it. However, unlike traditional desktop interactions where users are used to request for information or input data, ubiquitous interactions have to face with variable user¿s environment, making demands on one of the most valuable resources of users: human attention. A challenge in the Ubiquitous Computing paradigm is regulating the request for user¿s attention. That is, service interactions should behave in a considerate manner by taking into account the degree in which each service intrudes the user¿s mind (i.e., the obtrusiveness degree). In order to prevent service behavior from becoming overwhelming, this work, based on Model Driven Engineering foundations and the Considerate Computing principles, is devoted to design and develop services that adapt their interactions according to user¿s attention. The main goal of the present thesis is to introduce considerate adaptation capabilities in ubiquitous services to provide non-disturbing interactions. We achieve this by means of a systematic method that covers from the services¿ design to their implementation and later adaptation of interaction at runtime / Gil Pascual, M. (2013). Adapting Interaction Obtrusiveness: Making Ubiquitous Interactions Less Obnoxious. A Model Driven Engineering approach [Tesis doctoral]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/31660

Over the last years, Web services have become increasingly popular. It is because they allow businesses to share data and business process (BP) logic through a programmatic interface across networks. In order to reach the full potential of Web services, they can be combined to achieve specifi c functionalities. Web services run in complex contexts where arising events may compromise the quality of the system (e.g. a sudden security attack). As a result, it is desirable to count on mechanisms to adapt Web service compositions (or simply called service compositions) according to problematic events in the context. Since critical systems may require prompt responses, manual adaptations are unfeasible in large and intricate service compositions. Thus, it is suitable to have autonomic mechanisms to guide their self-adaptation. One way to achieve this is by implementing variability constructs at the language level. However, this approach may become tedious, difficult to manage, and error-prone as the number of con figurations for the service composition grows. The goal of this thesis is to provide a model-driven framework to guide autonomic adjustments of context-aware service compositions. This framework spans over design time and runtime to face arising known and unknown context events (i.e., foreseen and unforeseen at design time) in the close and open worlds respectively. At design time, we propose a methodology for creating the models that guide autonomic changes. Since Service-Oriented Architecture (SOA) lacks support for systematic reuse of service operations, we represent service operations as Software Product Line (SPL) features in a variability model. As a result, our approach can support the construction of service composition families in mass production-environments. In order to reach optimum adaptations, the variability model and its possible con figurations are verifi ed at design time using Constraint Programming (CP). At runtime, when problematic events arise in the context, the variability model is leveraged for guiding autonomic changes of the service composition. The activation and deactivation of features in the variability model result in changes in a composition model that abstracts the underlying service composition. Changes in the variability model are refl ected into the service composition by adding or removing fragments of Business Process Execution Language (WS-BPEL) code, which are deployed at runtime. Model-driven strategies guide the safe migration of running service composition instances. Under the closed-world assumption, the possible context events are fully known at design time. These events will eventually trigger the dynamic adaptation of the service composition. Nevertheless, it is diffi cult to foresee all the possible situations arising in uncertain contexts where service compositions run. Therefore, we extend our framework to cover the dynamic evolution of service compositions to deal with unexpected events in the open world. If model adaptations cannot solve uncertainty, the supporting models self-evolve according to abstract tactics that preserve expected requirements. / Alférez Salinas, GH. (2013). Achieving Autonomic Web Service Compositions with Models at Runtime [Tesis doctoral]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/34672

Adaptation enables a reaction to a changing environment. For traditional software development, that means changing the design and implementation of the software in a potentially complex and expensive process. If requirements are not known until the runtime of a software system, this system must be able to cope with changes during its runtime. For this, self-adaptive systems (SAS) were created. They have internal knowledge about themselves and their environment to reason about changes and take appropriate actions. Many approaches aiming to build such systems have been published since the start of the research area at the beginning of the 21st century. However, it is difficult to find an appropriate approach, even when all requirements of a scenario the system should be built for are known. If no suitable approach can be found, software developers have to built a new system leading to high development costs and potentially inefficient solutions due to the complexity of the system. This thesis follows two goals: (1) To make approaches building SAS more comparable through a feature model describing features of SAS, and (2) to provide a novel way of specifying SAS concisely using reference attribute grammars (RAGs) providing efficient systems. RAGs originate from the research field of compiler construction and enable the concise description of parts of the internal knowledge mentioned above as well as of the computation of the actions to cope with recognised changes. To make RAGs fully usable, this thesis presents two extensions: Relational RAGs enable the efficient handling of relations required for knowledge graphs, and Connected RAGs let RAG-based system communicate with other external systems to both recognise changes and execute actions. To evaluate the novel approaches, a classification of 30 approaches for the feature model and several case studies in the areas smart home, robotics, and system orchestration were conducted. It can be shown, that significantly less code is required to specify SAS. To specify the computation, 14.5 % to 28.7 % less code was required, whereas in another case study only 6.3 % of the total code was manually written and the rest was generated. The efficiency is similar to the best comparable approaches for graph queries. Furthermore, using additional optimizations (incremental evaluation), the execution time can be shown to be faster by a factor of 167.88 less albeit being sometimes by 50.0 % slower for very small workloads and specific queries. In a more realistic, extrapolated experiment, using incremental evaluation creates speed-up factors between 6.63 and 44.93. With the contributions in this thesis, existing approaches can be selected more precisely, new approaches can classify themselves within the research area, and the development of self-adaptive systems is possible using RAG-based systems.