Software is becoming more and more part of our daily life and makes it easier, e.g., in the areas of communication and infrastructure. Model-driven software development forms the basis for the development of software through the use and combination of different models, which serve as central artifacts in the software development process. In this respect, model-driven software development comprises the process from requirement analysis through design to software implementation. This set of models with their relationships to each other forms a so-called megamodel. Due to the overlapping of the models, inconsistencies occur between the models, which must be removed. Therefore, round-trip engineering is a mechanism for synchronizing models and is the foundation for ensuring consistency between models. Most of the current approaches in this area, however, work with outdated batch-oriented transformation mechanisms, which no longer meet the requirements of more complex, long-living, and ever-changing software. In addition, the creation of megamodels is time-consuming and complex, and they represent unmanageable constructs for a single user. The aim of this thesis is to create a megamodel by means of easy-to-learn mechanisms and to achieve its consistency by removing redundancy on the one hand and by incrementally managing consistency relationships on the other hand. In addition, views must be created on the parts of the megamodel to extract them across internal model boundaries. To achieve these goals, the role concept of Kühn in 2014 is used in the context of model-driven software development, which was developed in the Research Training Group 'Role-based Software Infrastructures for continuous-context-sensitive Systems.' A contribution of this work is a role-based single underlying model approach, which enables the generation of views on heterogeneous models. Besides, an approach for the synchronization of different models has been developed, which enables the role-based single underlying model approach to be extended by new models. The combination of these two approaches creates a runtime-adaptive megamodel approach that can be used in model-driven software development. The resulting approaches will be evaluated based on an example from the literature, which covers all areas of the work. In addition, the model synchronization approach will be evaluated in connection with the Transformation Tool Contest Case from 2019.

<p>Denna rapport undersöker krav, tagna från ett ramverk för evaluering av CASE-verktyg i ett kontextuellt sammanhang, i två representativa CASE-verktyg. Ramverket utnyttjar en modell som föreslagits av Lundell och Lings för att extrahera både krav och förväntningar som en organisation (www.it.volvo.com) hade på vad ett CASE-verktyg är och kan utföra.</p><p>Ramverket extraherar krav i ett organisationell kontext, dvs. utvärderingen utfördes innan verktyget som evaluerades användes i organisationen. Detta indikerar på att kraven inte är knutna till ett specifikt verktyg, samt att CASE-verktyg inte säkert stödjer dessa krav.</p><p>Resultatet för denna rapport är att viss semantisk förlust uppstod vid transformering av kod och modeller.</p>

Architecture is a key factor to the success of the software product, but at least the state of art is not the state of practice. The connection between the completed system and the architecture has often been damaged after the original implementation. Reverse architecting is a method to recover the software architecture by analyzing the artifact. Since reverse architecting is not mature yet, the paper studies methods, tools, and major issues which hinder the person performing reverse architecting all together from knowing whether the reverse architecting method is repeatable and possible to apply on the different releases of the same product.

Denna rapport undersöker krav, tagna från ett ramverk för evaluering av CASE-verktyg i ett kontextuellt sammanhang, i två representativa CASE-verktyg. Ramverket utnyttjar en modell som föreslagits av Lundell och Lings för att extrahera både krav och förväntningar som en organisation (www.it.volvo.com) hade på vad ett CASE-verktyg är och kan utföra. Ramverket extraherar krav i ett organisationell kontext, dvs. utvärderingen utfördes innan verktyget som evaluerades användes i organisationen. Detta indikerar på att kraven inte är knutna till ett specifikt verktyg, samt att CASE-verktyg inte säkert stödjer dessa krav. Resultatet för denna rapport är att viss semantisk förlust uppstod vid transformering av kod och modeller.

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.

Traditionelle 3D-Anwendungsentwicklung für VR/AR verläuft in heterogenen Entwicklerteams unstrukturiert, ad hoc und ist fehlerbehaftet. Der präsentierte Roundtrip3D Entwicklungsprozess ermöglicht die iterativ inkrementelle 3D-Anwendungsentwicklung, wechselseitig auf Softwaremodell- und Implementierungsebene. Modelle fördern das gemeinsame Verständnis unter Projektbeteiligten und sichern durch generierte Schnittstellen gleichzeitiges Programmieren und 3D-Modellieren zu. Das Roundtrip3D Werkzeug ermittelt Inkonsistenzen zwischen vervollständigten 3D-Inhalten und Quelltexten auch für verschiedene Plattformen und visualisiert sie auf abstrakter Modellebene. Die gesamte Implementierung wird nicht simultan, sondern nach codegetriebener Entwicklung kontrolliert mit Softwaremodellen abgeglichen. Inkremente aus aktualisierten Softwaremodellen fließen in dann wieder zueinander konsistente Quelltexte und 3D-Inhalte ein. Der Roundtrip3D Entwicklungsprozess vereint dauerhaft Vorteile codegetriebener mit modellgetriebener 3D-Anwendungsentwicklung und fördert strukturiertes Vorgehen im agilen Umfeld.

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

Framework-specific modeling languages (FSMLs) help developers build applications based on object-oriented frameworks. FSMLs formalize abstractions and rules of the framework's application programming interfaces (APIs) and can express models of how applications use an API. Such models, referred to as framework-specific models, aid developers in understanding, creating, and evolving application code. We present the concept of FSMLs, propose a way of specifying their abstract syntax and semantics, and show how such language specifications can be interpreted to provide reverse, forward, and round-trip engineering of framework-specific models and framework-based application code. We present a method for engineering FSMLs that was extracted post-mortem from the experience of building four such languages. The method is driven by the use cases that the FSMLs under development are to support. We present the use cases, the overall process, and its instantiation for each language. The presentation focuses on providing concrete examples for engineering steps, outcomes, and challenges. It also provides strategies for making engineering decisions. The presented method and experience are aimed at framework developers and tool builders who are interested in engineering new FSMLs. Furthermore, the method represents a necessary step in the maturation of the FSML concept. Finally, the presented work offers a concrete example of software language engineering. FSML engineering formalizes existing domain knowledge that is not present in language form and makes a strong case for the benefits of such formalization. We evaluated the method and the exemplar languages. The evaluation is both empirical and analytical. The empirical evaluation involved measuring the precision and recall of reverse engineering and verifying the correctness or forward and round-trip engineering. The analytical evaluation focused on the generality of the method.

<p>Object-oriented frameworks are currently widely used in software application development. Unfortunately, they are known to be generally difficult to use because of the difficulty in understanding the concepts and constraints in different frameworks. With the formalization of framework concepts and constraints in domain-specific modeling languages called framework-specific modeling languages (FSMLs), previous works have shown that round-trip engineering between models of applications using frameworks and the application code is possible to aid framework application development.</p> <p>Framework-specific modeling languages only capture, however, framework concepts and constraints and hence, lack the expressiveness of general-purpose modeling languages. For this reason, the complete code for an entire framework application cannot be generated from the model in the model editor using round-trip engineering, and the user would need to switch to the code editor to program the application logic code. Also, since models are only abstractions of code, implementation details in code may be missing in models. Although default implementation details can be used when generating code from a model, the generated code might require further customization by the user, which would also require switching to the code editor.</p> <p>To reduce the need for the user to switch between the model editor and the code editor and to reduce the need to customize the generated code, this thesis presents a model-guided approach to providing code assistance for framework application development directly in the code editor, where additional implementation details can also be obtained. An approach to building a context-sensitive code assistant that aids the user in the implementation of framework concepts with the consideration of framework constraints is described. A prototype has further been implemented and applied on two widely popular frameworks. The evaluation in this thesis analyzes and characterizes framework concepts and shows that the framework-based code assistant can reduce the need to customize the generated code in the code editor when compared to code generation from the model editor.</p>

Framework-specific modeling languages (FSMLs) help developers build applications based on object-oriented frameworks. FSMLs formalize abstractions and rules of the framework's application programming interfaces (APIs) and can express models of how applications use an API. Such models, referred to as framework-specific models, aid developers in understanding, creating, and evolving application code. We present the concept of FSMLs, propose a way of specifying their abstract syntax and semantics, and show how such language specifications can be interpreted to provide reverse, forward, and round-trip engineering of framework-specific models and framework-based application code. We present a method for engineering FSMLs that was extracted post-mortem from the experience of building four such languages. The method is driven by the use cases that the FSMLs under development are to support. We present the use cases, the overall process, and its instantiation for each language. The presentation focuses on providing concrete examples for engineering steps, outcomes, and challenges. It also provides strategies for making engineering decisions. The presented method and experience are aimed at framework developers and tool builders who are interested in engineering new FSMLs. Furthermore, the method represents a necessary step in the maturation of the FSML concept. Finally, the presented work offers a concrete example of software language engineering. FSML engineering formalizes existing domain knowledge that is not present in language form and makes a strong case for the benefits of such formalization. We evaluated the method and the exemplar languages. The evaluation is both empirical and analytical. The empirical evaluation involved measuring the precision and recall of reverse engineering and verifying the correctness or forward and round-trip engineering. The analytical evaluation focused on the generality of the method.