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.

In recent years, the development of multi-core CPUs and GPUs with many cores has taken precedence over an increase in clock frequency. Therefore, writing parallel programs for multi-core and many-core systems becomes increasingly important. Due to the lack of inherently parallel language features in most programming languages, today many programs are written sequentially and then enhanced with special pragmas or framework calls hinting parallelizable parts of code. This hints are then used to modify and extend the code with parallel constructs in a preprocessing step. If it is crucial to optimize the run time of a program, the code generated by this step has to be inspected an manually tuned. To keep the original and the transformed code artifacts synchronized, an editor with a round-trip engineering (RTE) system can be used. RTE propagates changes made in the source artifacts to the generated artifacts and vice versa. One tool that can be used to expand pragmas to parallelized source code is the invasive software composition framework SkAT. SkAT-based tools use reference attribute grammars (RAGs) to compose code fragments according to a composition program written in Java. To facilitate the creation of SkAT-based tools, a minimal composition system framework SkAT/Minimal on to of the SkAT core contains mechanisms to enable the incremental building of such tools. The principle of island parsing is employed to be able to express just as much of a language as is necessary for composition. In this work, composition systems based on SkAT/Minimal are targeted. The task is split into two parts: first, approaches for RTE are analyzed and a concept for a RTE system is created. The focus lies on the analysis of features and requirements of existing RTE approaches and a thorough investigation of all relevant steps required to implement such a system for SkAT/Minimal. The second part of the task is the creation and evaluation of a prototypical implementation of the system.

In recent years, the development of multi-core CPUs and GPUs with many cores has taken precedence over an increase in clock frequency. Therefore, writing parallel programs for multi-core and many-core systems becomes increasingly important. Due to the lack of inherently parallel language features in most programming languages, today many programs are written sequentially and then enhanced with special pragmas or framework calls hinting parallelizable parts of code. This hints are then used to modify and extend the code with parallel constructs in a preprocessing step. If it is crucial to optimize the run time of a program, the code generated by this step has to be inspected an manually tuned. To keep the original and the transformed code artifacts synchronized, an editor with a round-trip engineering (RTE) system can be used. RTE propagates changes made in the source artifacts to the generated artifacts and vice versa. One tool that can be used to expand pragmas to parallelized source code is the invasive software composition framework SkAT. SkAT-based tools use reference attribute grammars (RAGs) to compose code fragments according to a composition program written in Java. To facilitate the creation of SkAT-based tools, a minimal composition system framework SkAT/Minimal on to of the SkAT core contains mechanisms to enable the incremental building of such tools. The principle of island parsing is employed to be able to express just as much of a language as is necessary for composition. In this work, composition systems based on SkAT/Minimal are targeted. The task is split into two parts: first, approaches for RTE are analyzed and a concept for a RTE system is created. The focus lies on the analysis of features and requirements of existing RTE approaches and a thorough investigation of all relevant steps required to implement such a system for SkAT/Minimal. The second part of the task is the creation and evaluation of a prototypical implementation of the system.:1 Introduction 1 1.1 Motivation 1 1.2 Scope 2 1.3 Contributions 2 1.4 Organization 2 2 Background 5 2.1 Fundamentals 6 2.1.1 Syntax Trees 6 2.1.2 Parsing and Unparsing 6 2.2 Attribute Grammars 9 2.2.1 Reference Attribute Grammars 10 2.2.2 Reference Attribute Grammars in SkAT 10 2.3 Composition Systems 12 2.3.1 Software Composition Systems 13 2.3.2 Invasive Software Composition 13 2.3.3 SkAT 15 2.3.4 Template-based Code Generation 16 2.4 Round-trip Engineering 17 2.4.1 Motivation For Round-trip Engineering 17 2.4.2 Concepts of RTE 18 3 Analysis of RTE Approaches 19 3.1 Automatic Round-trip Engineering 19 3.2 RTE In Aspect Weaving Systems 21 3.2.1 CST Graftings 21 3.2.2 Update Propagation in Aspect Weaving Systems 22 3.3 RTE in Invasive Software Composition Systems 23 3.3.1 Tracing Composition Program Execution 23 3.3.2 Backpropagation of Changes 24 3.3.3 Implementation in the Reuseware Framework 26 3.4 Managing Fragments in RTE 27 3.5 Evaluation of RTE Approaches 28 4 Tracing in SkAT 31 4.1 Requirements 31 4.1.1 Objectives 32 4.1.2 Functional and Nonfunctional Requirements 32 4.2 Concept 33 4.3 Implementation 34 5 Building an RTE-editor Prototype 37 5.1 Prerequisites 37 5.2 Requirements 39 5.3 Concept 40 5.3.1 AST Interface 41 5.3.2 Composer Interface 41 5.3.3 Generating the Output 41 5.3.4 The Prototype Skeleton 42 5.4 Implementation 43 6 Designing an RTE-editor 49 6.1 Replay 50 6.2 AST Modifications 50 6.2.1 Modification Types 51 6.2.2 Detecting Modification Types 52 6.3 Origin Inference 53 6.3.1 Inference for Updated Elements 53 6.3.2 Inference for Deleted Elements 54 6.3.3 Inference for Inserted Elements 54 6.4 Gap Edit Problem 54 6.4.1 Inference in SkAT 57 6.4.2 Multiple Source Fragments 57 6.5 Applying Modifications 58 6.5.1 Propagating Terminal Updates 60 6.5.2 Propagating Non-terminal Updates 61 6.5.3 Propagating Deletions 62 6.5.4 Propagating Insertions 62 6.5.5 Propagating Composed Modifications 62 6.6 Adapting SkAT Composition Programs 63 7 Evaluation and Outlook on Future Works 65 7.1 Fragment Versioning 65 7.2 Composition Program DSL 66 7.3 Structured Editors 68 7.4 SkAT RTE System 68 Appendices 71 List of Figures 73 List of Listings 75 List of Abbreviations 77 Bibliography 79 CD Content 83