Search

Smart contracts are contracts made of executable code running on Blockchain platforms. DasContract was introduced in 2019-2020 as a domain-specific language (DSL) for smart contract modeling with the ability to generate code in a programming language (Solidity), yet its environment exhibits various limitations, both in technical and design aspects. In this work, we propose a user interface with improved usability that includes tools for syntax verification, develop a software prototype, demonstrate its usage with a case study, and identify future lines of research.

In recent years, we have been witnessing a rapid increase of research on exergames—i.e., computer games that require users to move during gameplay as a form of physical activity and rehabilitation. Properly balancing the need to develop an effective exercise activity with the requirements for a smooth interaction with the software system and an engaging game experience is a challenge. Model-driven software engineering enables the fast prototyping of multiple system variants, which can be very useful for exergame development. In this paper, we propose a framework, PhyDSLK, which eases the development process of personalized and engaging Kinect-based exergames for rehabilitation purposes, providing high-level tools that abstract the technical details of using the Kinect sensor and allows developers to focus on the game design and user experience. The system relies on model-driven software engineering technologies and is made of two main components: (i) an authoring environment relying on a domain-specific language to define the exergame model encapsulating the gameplay that the exergame designer has envisioned and (ii) a code generator that transforms the exergame model into executable code. To validate our approach, we performed a preliminary empirical evaluation addressing development effort and usability of the PhyDSLK framework. The results are promising and provide evidence that people with no experience in game development are able to create exergames with different complexity levels in one hour, after a less-than-two-hour training on PhyDSLK. Also, they consider PhyDSLK usable regardless of the exergame complexity.

Among the software engineering development phases, requirements engineering is the one that has the most impact on project success or failure. To be executed in various contexts, there is an important need for flexibility and efficient tool support. A flexible requirements engineering method should include several levels allowing for more or less completeness and precision. Some project contexts would need a lightweight activity using structured natural language but still being guided and grounded partly on professional standards. Some more advanced projects would need more complete requirements documents and would benefit from a description language based on scientific notions allowing for better precision for specific system operations. Some business or safety critical systems would need an approach allowing for requirements simulation and verification. Requirements engineering education is an important objective to prepare future engineers to understand those requirements engineering needs and be prepared for practice in a professional setting. In the last five years, we have developed a requirements engineering method called Messir with a tool Excalibur and experiments in academia have been made to see how it was solving actual software engineering problems focusing first on requirements engineering education. Messir components represent in themselves some improvements w.r.t. the state of the art of the “standard” theories, methods and tools, mainly by introducing an improved requirements engineering process, language and verification support based on executable requirements specifications. Furthermore, the Messir approach solves also some actual problems related to software engineering education by offering a product line framework for setting up or improving courses in computer science curricula. The main result being to contribute to develop the software engineering capabilities of engineers and scientists that feed the job market in industry, research or education.

Mit der zunehmenden Einführung von Industrie 4.0-Konzepten in Produktionssystemen entstehen neue Herausforderungen für die Steuerungssoftware. Hochgradig verteilte Steuerungen mit engen Echtzeitvorgaben und Sicherheitsvorschriften führen zu immer komplexerer Software. Die aktuelle Forschung konzentriert sich auf die Erhöhung der Abstraktion mit neuen Architekturen und die Modularisierung von Software. Die vorgestellte Dissertation befasst sich mit der Modellierung der Interaktionen zwischen Steuerungssoftwarekomponenten und des emergenten Verhaltens von mehreren Komponenten. Solche Verhaltensmodelle können die Implementierung vereinfachen und das (halb-)automatische Testen und Überwachen von Steuerungssoftware erleichtern. Schließlich kann die Visualisierung des Verhaltens in einem Modell die Verständlichkeit bestehender Steuerungssoftware verbessern, wenn Softwareentwickler nicht auf Implementierungsdetails angewiesen sind, um die Funktionalität höherer Hierarchieebenen abzuleiten. Diese Arbeit zielt darauf ab, den Nutzen von Verhaltensmodellen bei der Entwicklung von Steuerungssoftware zu optimieren: Die direkte Modellierung des erwarteten Verhaltens für neue Software ermöglicht deren Verwendung während des gesamten Software-Lebenszyklus. Bei bestehender Software wird der anfängliche Entwicklungsaufwand für Verhaltensmodelle durch die automatische Erfassung von Verhaltensmodellen aus der Implementierung reduziert. Der Ansatz wird in Fallstudien und Userstudien evaluiert, um Erfahrungen aus der Industrie in diese Forschung zur Softwareentwicklung zu integrieren. With the growing adoption of Industry 4.0 concepts in production systems, new challenges arise in engineering control software. Highly distributed control with tight real-time constraints and safety regulations results in increasingly complex software. Current research focuses on increasing the abstraction with new architectures and modularization of software. The presented PhD research addresses modeling of the interactions between control software components, and of the emergent behavior of these compositions. Such behavior models can support the initial implementation, and facilitate (semi-)automated testing and monitoring of control software. Finally, visualizing behavior in a model can enhance understandability of existing control software, when software developers need not access abstracted hierarchy levels to deduct their functionality. This work aims at optimizing the benefit of behavior models in developing control software: Modeling the expected behavior directly for new software will allow using them throughout the software life-cycle. For legacy software, the initial development effort of behavior models will be minimized by automatically capturing behavior models from the implementation. The approach is evaluated in case studies and user studies to integrate experiences from the industrial domain into this software engineering research. Accepted version

Model-Driven Software Product Line Engineering (MDPLE) is a discipline that bespeaks increased productivity when developing variability-intense software by combining the benefits of both disciplines, model-driven software engineering (MDSE) and software product line engineering (SPLE): SPLE grounds on the principles of organized reuse and explicit variability to build a (multi-variant) platform from which customized software products can be derived automatically. In contrast, MDSE raises the level of abstraction by employing models of different kinds throughout the development process and eventually represents the software system with executable models. Model transformations serve to create not only different model representations from a given model but also to derive executable source code automatically. While MDPLE should take advantage of the positive effects of each discipline when combining them, several problems, such as the following, threaten these effects: Annotative product lines build the multi-variant platform by superimposing single variants of the software. For deriving a customized product, developers map annotations onto elements of the platform and provide a configuration of the distinguishing features of the product line. These annotations are Boolean expressions over the common and distinguishing features of the product line. A filter mechanism will remove elements from the platform if their annotations are not satisfied by the configuration. Since multiple artifacts, such as models, build scripts, and source code, form the platform, still annotating each of these artifacts is a manual process which is tedious and prone to errors. Few approaches automate this task by manipulating the execution semantics of model transformations. This requires exclusive access and, in the worst case, to consider variability explicitly in the trans- formation which increases the level of cognitive complexity and may require to learn new syntax. Therefore, in this thesis we develop a solution which acknowledges the existing and mature technology of (single-variant) model transformations which automate the creation of new models or source code but are unaware of the variability present in form of annotations in multi-variant product line artifacts. In contrast to existing approaches, our contribution does not modify the execution semantics of existing model transformation languages but reuses them and their generated artifacts to propagate annotations generically (i.e., independent of the transformation language and of the transformed instances of metamodels) and automatically. Specifically, the thesis contributes the informal and formal concepts and implementation of 1) an a posteriori bytecode model analysis, 2) an a posteriori propagation of annotations based on transformation trace, as well as 3) a propagation during the execution based on a generic aspect. Furthermore, the thesis examines the strengths and weaknesses of employing a propagation DSL and model matching of instances of different metamodels to reconstruct trace information. The evaluation confirms a significant reduction in manual efforts to annotate the product line: We examine the trace-based propagation of annotations based on traces of different completeness-levels and the generic aspect in a controlled setting with small to medium academic product lines. The aspect-oriented approach assigns 95 − 100% of the annotations correctly. Furthermore, even if the trace completeness is insufficient and does not record all target elements, our approaches compute more than 90% of the annotations correctly whereas the propagation based on generation-complete traces determines all target annotations correctly. In summary, the thesis solves the problem of diminished productivity in MDPLE by providing the concepts, realization, and evaluation of automated techniques to propagate annotations in annotative product lines without the need to change established technologies.

Human workers need to cope with complex production settings when handling and monitoring cyber-physical production systems. Assistive systems can provide situational step-by-step support for human behavior, e.g., when interacting with a machine or for manual assembly. These systems need to take personal knowledge, workers skills or personal restrictions into account and are therefore subject to privacy concerns. However, the engineering of such interactive assistive systems within the production domain is a complex task as they might support critical functionality in dangerous environments and have a high need for safety and privacy considerations due to processing personal data. We want to investigate how the software engineering process of assistive systems in production can be improved to achieve higher reusability. Current research focuses on specific use cases and implements systems specifically for those needs without reusability in mind. We suggest using behavior and context models in a generative approach, to create a reusable method to engineer assistive systems for production environments, either as own applications or as services integrated within digital twins. We have already applied model-driven methods for assistive systems in the smart home domain and discuss the opportunities and challenges of an application of these methods for the production domain. These methods can facilitate the engineering of assistive functionalities within applications in production while meeting privacy, adaptability, and context-sensitivity requirements.

Modellierung 2022 Satellite Events / J. Michael, J. Pfeiffer, A. Wortmann (Hrsg.) Modellierung, Hamburg, Germany, 27 Jun 2022 - 1 Jul 2022; Bonn : Gesellschaft für Informatik e.V. 150-153 (2022). doi:10.18420/modellierung2022ws-019, Published by Gesellschaft für Informatik e.V., Bonn

Modellierung 2022 : 27.06.-01.07.2022 Hamburg, Germany / Matthias Riebisch, Marina Tropmann-Frick (Hrsg.) ; Gesellschaft für Informatik e.V. (GI) Modellierung 2022, Hamburg, Germany, 27 Jun 2022 - 1 Jul 2022; Bonn : Gesellschaft für Informatik e.V., GI-Edition. Proceedings / Gesellschaft für Informatik P-324, 93-110 (2022). doi:10.18420/modellierung2022-014, Published by Gesellschaft für Informatik e.V., Bonn

Cloud Functions represent a new trend in cloud computing in which developers are allowed to install code in a Function-as-a-Service (FaaS) platform able to manage provisioning, execution, monitoring and automatic scaling. The underlying infrastructure in FaaS platforms is hidden from the developers and designers and, since the influence of the infrastructure is unknown, this makes it difficult to apply software performance engineering approaches on cloud functions, which could lead to wrong or inaccurate performance estimations. In this study, we explore the use of component-based modeling and simulation in order to generate performance estimations of an exemplar cloud function which was exercised using a variety of workloads. A cloud function was both implemented and instrumented to record in a log file performance data, associated with its invocations and, using the log file as an input, we extracted a performance model in a Palladio Component Model format suitable for running simulations to validate whether the generated model could explain the runtime behavior of the function. Using this approach and further tunings in the model, we were able to validate that the simulations could explain more than 95% of the function's behavior and that component-based modeling and simulation can be considered a serious option when trying to explain the behavior of a cloud function.

In recent years, the number of smartphone users has increased dramatically. These users download millions of apps and use them for various services. Due to the significant demand for mobile apps, developers often seek faster development methods and more effective tools and techniques to generate these apps. Many of these apps are location-based apps in which users receive services based on their geographical location. In this paper, we propose a model-driven approach for the automatic generation of Android location-based mobile apps. Our framework, called ALBA, consists of a domain-specific modeling language, a modeling tool, and a plugin which includes model to code transformations. The modeling tool enables a novice designer to model a location-based app. The model is validated against the predefined constraints and the editor prevents creating invalid models. The designer uses the plugin to generate the Android code of the app. The evaluation of our work is two fold. First, to evaluate the generalizability of the ALBA framework, we conducted an experiment which includes the generation of four industrial location-based apps. Second, to evaluate the usability and quality of both the framework and the generated apps, we conducted a case study consists of three experiments. The results of the evaluation are promising both in terms of the applicability of the framework and the quality of the generated apps.

Web-Content-Management-Systeme (WCMS) wie WordPress, Joomla oder Drupal haben sich als beliebte Plattformen für die Erstellung dynamischer Webanwendungen etabliert. Ein großer Vorteil von WCMS ist die funktionale Erweiterbarkeit durch installierbare Erweiterungspakete. Entwickler solcher Erweiterungen stehen jedoch vor der Herausforderung, sich mit großen Mengen an Boilerplate-Code, Abhängigkeiten zwischen Erweiterungen sowie Architekturanpassungen an der zugrunde liegenden WCMS-Plattform auseinanderzusetzen. Diese Herausforderungen treten in gängigen Entwicklungsszenarien auf, welche sowohl die Entwicklung und Wartung von neuen Erweiterungspaketen, als auch die Softwaremigration von bestehenden Erweiterungen auf neue WCMS Plattformen umfassen. Einen vielversprechenden Ansatz zur Bewältigung dieser Herausforderungen bietet der Einsatz von Model-Driven Engineering (MDE). MDE als Softwareentwicklungsmethode sieht vor, fachliche Softwareanforderungen innerhalb von wiederverwendbaren Modellen zu beschreiben, mit dem Ziel, technische Details über das Zielsystem weitestgehend zu abstrahieren. Die Verwendung solcher Modelle als Eingabe für plattformspezifische Codegeneratoren ermöglicht eine automatisierte Übersetzung in standardisierte Software von hoher Qualität. Allerdings hat MDE bei der Entwicklung von Erweiterungen in der WCMS-Domäne aufgrund fehlender Werkzeugunterstützung bisher wenig Akzeptanz erreicht. Während Ergebnisse empirischer Studien in anderen Domänen den Nutzen von MDE aufzeigen, fehlen derzeit empirische Belege für etwaige Vorteile im Kontext der Entwicklung von WCMS Erweiterungen. In dieser Arbeit werden die Konzepte sowie das Design einer MDE-Infrastruktur für die Entwicklung von WCMS-Erweiterungen vorgestellt. Die vorgestellte Infrastruktur umfasst eine domänenspezifische Modellierungssprache (DSL) für WCMS-Erweiterungen, Modelleditoren, sowie Werkzeuge zur Unterstützung von Forward- und Reverse-Engineering-Prozessen, bestehend aus einem Codegenerator, welcher Modellinstanzen der vorgestellten DSL verwendet, einem Werkzeug für die Code-Extraktion aus installierten WCMS-Erweiterungen, sowie einem Werkzeug zur Informationsgewinnung, welches basierend auf bestehenden Erweiterungspaketen Modellinstanzen der vorgestellten DSL generieren kann. Der Entwurf der gezeigten Infrastruktur befolgt folgenden Prozess: Zunächst wird die Repräsentativität gängiger Entwicklungsszenarien untersucht, indem Interviews mit Entwicklern aus der WCMS-Domäne durchführt werden. Als nächstes wird ein allgemeines Lösungskonzept für diese Szenarien vorgeschlagen, welches Rollen, Prozessschritte sowie notwendige MDE-Infrastrukturkomponenten umfasst. Daraufhin werden funktionale sowie nicht-funktionale Anforderungen an eine adäquate MDE-Infrastruktur gesammelt. Um die Anwendbarkeit der vorgestellten Konzepte zu zeigen, wird die JooMDD-Infrastruktur vorgestellt, welche die Entwicklung von Erweiterungen für das Joomla WCMS adressiert, welches im Vergleich populärer WCMS den anspruchsvollsten Erweiterungsmechanismus bietet. Um Belege für den positiven Einfluss von MDE während der Entwicklung von WCMS-Erweiterungen zu sammeln, werden die Ergebnisse empirischer Studien mit Erweiterungs-Entwicklern aus der Joomla-Community vorgestellt. Dabei werden zuerst Methode, Ergebnisse sowie Schlussfolgerungen eines kontrollierten Experiments mit Entwicklern aus dem akademischen sowie industriellen Bereich präsentiert, welches konventionelle Erweiterungs-Entwicklung mit dem MDE Ansatz vergleicht. Die Ergebnisse zeigen einen deutlichen Gewinn an Produktivität und Qualität durch den Einsatz der JooMDD-Infrastruktur. Weiterhin werden Design und Beobachtungen eines semi-kontrollierten Tutorials mit Entwicklern aus der Joomla-Community präsentiert. Unter Verwendung der JooMDD-Infrastruktur in mehreren Entwicklungsszenarien wurde qualitatives Feedback über die Akzeptanz, Nützlichkeit sowie offene Herausforderungen des vorgestellten MDE-Ansatzes gesammelt. Abschließend werden Lessons Learned sowie auftretende Validitätsgefährdungen der durchgeführten Studien präsentiert., Web content management systems (WCMSs) such as WordPress, Joomla or Drupal have established themselves as popular platforms for instantiating dynamic web applications. Using a WCMS instance allows developers to add additional functionality by implementing installable extension packages. However, extension developers are challenged by dealing with boilerplate code, dependencies between extensions and frequent architectural changes to the underlying WCMS platform. These challenges occur in frequent development scenarios that include initial development and maintenance of extensions as well as migration of existing extension code to new platforms. A promising approach to overcome these challenges is represented by model-driven engineering (MDE). Adopting MDE as development practice, allows developers to define software features within reusable models which abstract the technical knowledge of the targeted system. Using these models as input for platform-specific code generators enables a rapid transformation to standardized software of high quality. However, MDE has not found adoption during extension development in the WCMS domain, due to missing tool support. The results of empirical studies in different domains demonstrate the benefits of MDE. However, empirical evidence of these benefits in the WCMS domain is currently lacking. In this work, we present the concepts and design of an MDE infrastructure for the development and maintenance of WCMS extensions. This infrastructure provides a domain-specific modelling language (DSL) for WCMS extensions, as well as corresponding model editors. In addition, the MDE infrastructure facilitates a set of transformation tools to apply forward and reverse engineering steps. This includes a code generator that uses model instances of the introduced DSL, an extension extractor for code extraction of already deployed WCMS extensions, and a model extraction tool for the creation of model instances based on an existing extension package. To ensure adequacy of the provided MDE infrastructure, we follow a structured research methodology. First, we investigate the representativeness of common development scenarios by conducting interviews with industrial practitioners from the WCMS domain. Second, we propose a general solution concept for these scenarios including involved roles, process steps, and MDE infrastructure facilities. Third, we specify functional and non-functional requirements for an adequate MDE infrastructure, including the expectations of domain experts. To show the applicability of these concepts, we introduce JooMDD as infrastructure instantiation for the Joomla WCMS which provides the most sophisticated extension mechanism in the domain. To gather empirical evidence of the positive impact of MDE during WCMS extension development, we present a mixed-methods empirical investigation with extension developers from the Joomla community. First, we share the method, results and conclusions of a controlled experiment conducted with extension developers from academia and industry. The experiment compares conventional extension development with MDE using the JooMDD infrastructure, focusing on the development of dependent and independent extensions. The results show a clear gain in productivity and quality by using the JooMDD infrastructure. Second, we share the design and observations of a semi-controlled tutorial with four experienced developers who had to apply the JooMDD infrastructure during three scenarios of developing new (both independent and dependent) extensions and of migrating existing ones to a new major platform version. The aim of this study was to obtain direct qualitative feedback about acceptance, usefulness, and open challenges of our MDE approach. Finally, we share lessons learned and discuss the threats to validity of the conducted studies.

International audience; Over the last 2 decades, several dedicated languages have been proposed to support model management activities such as model validation, transformation, and code generation. As software systems become more complex, underlying system models grow proportionally in both size and complexity. To keep up, model management languages and their execution engines need to provide increasingly more sophisticated mechanisms for making the most efficient use of the available system resources. Efficiency is particularly important when model-driven technologies are used in the context of low-code platforms where all model processing happens in pay-per-use cloud resources. In this paper, we present our vision for an approach that leverages sophisticated static program analysis of model management programs to identify, load, process and transparently discard relevant model partitions-instead of naively loading the entire models into memory and keeping them loaded for the duration of the execution of the program. In this way, model management programs will be able to process system models faster with a reduced memory footprint, and resources will be freed that will allow them to accommodate even larger models. CCS CONCEPTS • Software and its engineering → Model-driven software engineering.

Fuzzing or fuzz testing is an established technique that aims to discover unexpected program behavior (e.g., bugs, security vulnerabilities, or crashes) by feeding automatically generated data into a program under test. However, the application of fuzzing to test Model-Driven Software Engineering (MDSE) tools is still limited because of the difficulty of existing fuzzers to provide structured, well-typed inputs, namely models that conform to typing and consistency constraints induced by a given meta-model and underlying modeling framework. By drawing from recent advances on both fuzz testing and automated model generation, we present three different approaches for fuzzing MDSE tools: A graph grammar-based fuzzer and two variants of a coverage-guided mutation-based fuzzer working with different sets of model mutation operators. Our evaluation on a set of real-world MDSE tools shows that our approaches can outperform both standard fuzzers and model generators w.r.t. their fuzzing capabilities. Moreover, we found that each of our approaches comes with its own strengths and weaknesses in terms of fault finding capabilities and the ability to cover different aspects of the system under test. Thus the approaches complement each other, forming a fuzzer suite for testing MDSE tools.

Ein Softwaremodell ist mit gegebenen Spezifikationen (Specs) genau dann konsistent, wenn alle Spezifikationen von dem Softwaremodell eingehalten werden, d.h. alle Spezifikationen für das Softwaremodell wahr (korrekt) sind. Während der Softwareentwicklung ist die Konstruktion von konsistenten Softwaremodellen (z.B. Programmen oder Artefakten) essentiell. Dies gilt besonders im Bereich des Model-Driven Engineering (MDE), in welchem die Softwaremodelle in allen Phasen des Softwareentwicklungsprozesses (Analyse, Design, Implementierung und Test) verwendet werden. Softwaremodelle werden üblicherweise in domänenspezifischen Modellierungssprachen (DSMLs) verfasst und dienen der Beschreibung eines Domänenproblems oder eines Systems aus unterschiedlichen Perspektiven und auf unterschiedlichen Abstraktionsebenen. Wenn das Softwaremodell mit der Definition seiner DSML (gewöhnlich durch ein Meta-Modell und Integritätsbedingungen definiert) konform ist, gilt das Softwaremodell als konsistent. Modelltransformationen sind eine essentielle Technologie zur (semi)-automatisierten Manipulation von Softwaremodellen, inkl. z.B. des Refactorings und der Codegenerierung. Dabei wird oftmals ein wohldefiniertes Transformationsverhalten vorausgesetzt in dem Sinne, dass die resultierenden Softwaremodelle in Hinblick auf die Bedingungen konsistent sind. Inkonsistente Softwaremodelle beeinflussen die Anwendbarkeit von Modelltransformationen, wodurch die automatische Ausführung unzuverlässig und fehleranfällig werden kann. Die Konsistenz von Softwaremodellen und den Ergebnissen von Modelltransformationen trägt zur Qualität des gesamten modellierten Systems bei. Obwohl MDE bemerkenswerte Fortschritte gemacht hat und ein akzeptiertes Verfahren in vielen Anwendungsbereichen wie der Automobilindustrie sowie der Luft- und Raumfahrt darstellt, so gilt es immer noch deutliche Herausforderungen zu bewältigen, um die MDE-Vision in der Industrie umzusetzen. Die Herausforderungen bestehen dabei in dem Umgang und der Auflösung von Inkonsistenzen in Softwaremodellen (z.B. unvollständigen Softwaremodellen), der Sicherstellung und Erhaltung von Modellkonsistenz und Korrektheit während der Modellkonstruktion, der Erhöhung der Zuverlässigkeit von Modelltransformationen (z.B. durch die Sicherstellung der Modellkonsistenz nach Modelltransformationen), der Entwicklung von effizienten (automatisierten, standardisierten und zuverlässigen) domänenspezifischen Modellierungswerkzeugen und dem Umgang mit großen Softwaremodellen, was insgesamt die Notwendigkeit weiterer Forschung zeigt. In dieser Arbeit werden vier automatisierte und interaktive Techniken zur Sicherstellung der Konsistenz von Softwaremodellen und Modelltransformationsergebnissen innerhalb des Softwareentwicklungsprozesses vorgestellt. Die ersten beiden Beiträge erlauben die Konstruktion von konsistenten Softwaremodellen einer gegebenen DSML in einer automatisierten und interaktiven Weise. Die Konstruktion kann dabei mit einem potentiell inkonsistenten Softwaremodell beginnen. Da die Erweiterung von Transformationen zur Erfüllung von Bedingungen eine langwierige und fehleranfällige Aufgabe darstellt, welche hohe Fähigkeiten in Bezug auf die theoretischen Grundlagen voraussetzt, ergeben sich die weiteren Beiträge: Die vorgestellten Techniken stellen die Modellkonsistenz nach einer automatischen Erweiterung der Modelltransformation durch zusätzliche Anwendungsbedingungen (engl. Application Conditions - ACs) sicher. Diese resultierenden Anwendungsbedingungen steuern die Anwendbarkeit der Transformationen in Bezug auf eine Menge von Konsistenzbedingungen. Darüber hinaus werden zusätzlich Optimierungsstrategien bereitgestellt. Im Einzelnen wird folgendes präsentiert: Als Erstes wird eine automatische und interaktive Technik zur Reparatur von Softwaremodellen präsentiert. Dieser Ansatz leitet Modellierer beim Reparieren des gesamten Modells, indem alle Kardinalitätsverletzungen aufgelöst werden, und führt somit zu dem gewünschten konsistenten Softwaremodell. Zweitens wird eine Technik zur effizienten Generierung von großen, konsistenten und heterogenen Softwaremodellen eingeführt. Beide Techniken sind DSML-unabhängig, d.h. sie können für beliebige Meta-Modelle eingesetzt werden. Es werden Meta-Techniken für die Anwendung beider Ansätze auf einer gegebenen DSML präsentiert, da mittels Meta-Tools entsprechende DSML-Werkzeuge (Modellreparatur und Modellgeneration) auf Basis eines gegebenen Meta-Modells automatisch generierbar sind. Es wird die Korrektheit dieser Techniken sowie die Auswertung und Diskussion der Eigenschaften (z.B. Skalierbarkeit) gezeigt. Drittens ist ein Werkzeug entwickelt worden, basierend auf einem konstruktiven Ansatz zur Übersetzung von OCL Bedingungen in semantisch äquivalente Graphbedingungen, welches diese als gewährleistende Anwendungsbedingungen vollautomatisch in Transformationsregeln integriert. Eine bedingungsgewährleistende Anwendungsbedingung stellt sicher, dass eine Transformationsregel nur genau dann auf einem beliebigen Softwaremodell ausgeführt werden kann, wenn das resultierende Softwaremodell nach der Regelanwendung die Bedingung erfüllt. Viertens wurde ein konstruktiver Ansatz zur Optimierung von Anwendungsbedingungen für bedingungserhaltende Transformationsregeln entwickelt. Eine bedingungserhaltende Anwendungsbedingung stellt sicher, dass eine Regel erfolgreich auf ein konsistentes Softwaremodell, welches die Bedingung erfüllt, angewandt werden kann, genau dann, wenn das resultierende Softwaremodell nach der Regelanwendung immer noch konsistent mit der Bedingung ist. Es wird die Korrektheit der Techniken, die Einsatzfertigkeit der Werkzeuge, die Evaluation der Effizienz (Komplexität und Leistungsfähigkeit) beider Ansätze sowie die Bewertung des gesamten Ansatzes gezeigt. Die vier Techniken sind kompatibel zu dem Eclipse Modeling Framework (EMF), welches die Realisierung der OMG-Standard-Spezifikation in der Praxis darstellt. Daher sind die Interoperabilität und die Austauschbarkeit der Techniken sichergestellt. Die vorgestellten Techniken verbessern nicht nur die Qualität des modellierten Systems, sondern erhöhen auch die Produktivität durch die Bereitstellung von Meta-Tools zur Generierung von DSML-Werkzeugen, welche die Aufgabenbearbeitung durch Automatisierung beschleunigen., A model is consistent with given specifications (specs) if and only if all the specifications are held on the model, i.e., all the specs are true (correct) for the model. Constructing consistent models (e.g., programs or artifacts) is vital during software development, especially in Model-Driven Engineering (MDE), where models are employed throughout the life cycle of software development phases (analysis, design, implementation, and testing). Models are usually written using domain-specific modeling languages (DSMLs) and specified to describe a domain problem or a system from different perspectives and at several levels of abstraction. If a model conforms to the definition of its DSML (denoted usually by a meta-model and integrity constraints), the model is consistent. Model transformations are an essential technology for manipulating models, including, e.g., refactoring and code generation in a (semi)automated way. They are often supposed to have a well-defined behavior in the sense that their resulting models are consistent with regard to a set of constraints. Inconsistent models may affect their applicability and thus the automation becomes untrustworthy and error-prone. The consistency of the models and model transformation results contribute to the quality of the overall modeled system. Although MDE has significantly progressed and become an accepted best practice in many application domains such as automotive and aerospace, there are still several significant challenges that have to be tackled to realize the MDE vision in the industry. Challenges such as handling and resolving inconsistent models (e.g., incomplete models), enabling and enforcing model consistency/correctness during the construction, fostering the trust in and use of model transformations (e.g., by ensuring the resulting models are consistent), developing efficient (automated, standardized and reliable) domain-specific modeling tools, and dealing with large models are continually making the need for more research evident. In this thesis, we contribute four automated interactive techniques for ensuring the consistency of models and model transformation results during the construction process. The first two contributions construct consistent models of a given DSML in an automated and interactive way. The construction can start at a seed model being potentially inconsistent. Since enhancing a set of transformations to satisfy a set of constraints is a tedious and error-prone task and requires high skills related to the theoretical foundation, we present the other contributions. They ensure model consistency by enhancing the behavior of model transformations through automatically constructing application conditions. The resulting application conditions control the applicability of the transformations to respect a set of constraints. Moreover, we provide several optimizing strategies. Specifically, we present the following: First, we present a model repair technique for repairing models in an automated and interactive way. Our approach guides the modeler to repair the whole model by resolving all the cardinalities violations and thereby yields a desired, consistent model. Second, we introduce a model generation technique to efficiently generate large, consistent, and diverse models. Both techniques are DSML-agnostic, i.e., they can deal with any meta-models. We present meta-techniques to instantiate both approaches to a given DSML; namely, we develop meta-tools to generate the corresponding DSML tools (model repair and generation) for a given meta-model automatically. We present the soundness of our techniques and evaluate and discuss their features such as scalability. Third, we develop a tool based on a correct-by-construction technique for translating OCL constraints into semantically equivalent graph constraints and integrating them as guaranteeing application conditions into a transformation rule in a fully automated way. A constraint-guaranteeing application condition ensures that a rule applies successfully to a model if and only if the resulting model after the rule application satisfies the constraint. Fourth, we propose an optimizing-by-construction technique for application conditions for transformation rules that need to be constraint-preserving. A constraint-preserving application condition ensures that a rule applies successfully to a consistent model (w.r.t. the constraint) if and only if the resulting model after the rule application still satisfies the constraint. We show the soundness of our techniques, develop them as ready-to-use tools, evaluate the efficiency (complexity and performance) of both works, and assess the overall approach in general as well. All our four techniques are compliant with the Eclipse Modeling Framework (EMF), which is the realization of the OMG standard specification in practice. Thus, the interoperability and the interchangeability of the techniques are ensured. Our techniques not only improve the quality of the modeled system but also increase software productivity by providing meta-tools for generating the DSML tool supports and automating the tasks.

This paper reports on industrial experimentations to develop a dedicated model-based framework (process and tool support) aimed at supporting a subset of an existing document-based engineering process involving different teams belonging to two main stakeholders. The process supported covers the design of security related products by a prime contractor, and the supervision of this work by the contracting authority. This paper provides more details on this process, the requirements for the model-based engineering framework, and the work achieved. It then discusses the first results obtained from those experimentations, the lessons learned, and provides feedback for future similar works. Those relate mainly around: the benefits of an explicit and detailed methodology; the customizability of a general modeling language such as SysML for the development of a specialized model-based framework; and the importance of the distinction and clear definition of the problem domain, which correspond to the semantics of the models, and the solution domain, which corresponds to the syntax of the models.

Software modernization for business applications is often driven by the need for supporting additional frontend channels such as web or mobile. At the same time, business logic encapsulated by services and the underlying persistence implementation should be reused. In contrast to writing new graphical user interfaces (GUI) utilizing the latest programming language or framework, we propose a model-driven software engineering (MDSE) approach for specifying the new graphical user interface. In addition, we utilize model-based reverse engineering (MBRE) to discover, transform and integrate existing services and their data types. By providing support for modeling an anti-corruption layer, existing services can be integrated into the new GUI model without exposing potential design flaws from the legacy system. The model of legacy services and data types combined with the newly modeled graphical user interfaces are processed by transformation and generation processes to create source code for user interface, anti-corruption layer and service calls. Thus, enabling efficient integration of existing services in new GUIs by model-based reverse engineering and ensuring flexibility to quickly adapt new graphical user interface technologies through model-driven engineering techniques in the future. First experience from real-world projects indicates that the introduced approach enables faster creation of new graphical user interfaces by relying on production-proven services and data types.

Software that is not aligned with the business values of the organization for which it was developed does not entirely fulfill its raison d’etre. Business values represent what is important in a company, or organization, and should influence the overall software system behavior, contributing to the overall success of the organization. However, approaches to derive a software architecture considering the business values exchanged between an organization and its market players are lacking. Our quest is to address this problem and investigate how to derive value-centered architectural models systematically. We used the Technology Research method to address this PhD research question. This methodological approach proposes three steps: problem analysis, innovation, and validation. The problem analysis was performed using systematic studies of the literature to obtain full coverage on the main themes of this work, particularly, business value modeling, software architecture methods, and software architecture derivation methods. Next, the innovation step was accomplished by creating a framework for the derivation of a software reference architecture model considering an organization’s business values. The resulting framework is composed of three core modules: Business Value Modeling, Agile Reference Architecture Modeling, and Goal-Driven SOA Architecture Modeling. While the Business value modeling module focuses on building a stakeholder-centric business specification, the Agile Reference Architecture Modeling and the Goal-Driven SOA Architecture Modeling modules concentrate on generating a software reference architecture aligned with the business value specification. Finally, the validation part of our framework is achieved through proof-of-concept prototypes for three new domain specific languages, case studies, and quasi-experiments, including a family of controlled experiments. The findings from our research show that the complexity and lack of rigor in the existing approaches to represent business values can be addressed by an early requirements specification method that represents the value exchanges of a business. Also, by using sophisticated model-driven engineering techniques (e.g., metamodels, model transformations, and model transformation languages), it was possible to obtain source generators to derive a software architecture model based on early requirements value models, while assuring traceability throughout the architectural derivation process. In conclusion, despite using sophisticated techniques, the derivation process of a software reference architecture is helped by simple to use methods supported by black box transformations and guidelines that facilitate the activities for the less experienced software architects. The experimental validation process used confirmed that our framework is feasible and perceived as easy to use and useful, also indicating that the participants of the experiments intend to use it in the future.

Despite the increasing importance of in silico experiments to the scientific discovery process, state-of-the-art software engineering practices are rarely adopted in computational science. To understand the underlying causes for this situation and to identify ways to improve it, we conducted a literature survey on software engineering practices in computational science. We identified recurring key characteristics of scientific software development that are the result of the nature of scientific challenges, the limitations of computers, and the cultural environment of scientific software development. Our findings allow us to point out shortcomings of existing approaches for bridging the gap between software engineering and computational science and to provide an outlook on promising research directions that could contribute to improving the current situation.

In recent years, we have witnessed an increase in the capabilities of smartphones. Not only are these portable communication devices becoming increasingly powerful, they are equipped with a growing number of sensors that allow them to measure the properties of the world around them. Applications running on these smartphones can benefit from these sensors if developers choose to make them context-aware. However, applications that are built to operate in a wide variety of situations have to be able to cope with and respond to any combination of measured context factors. Anticipation of these different contexts at design time is challenging. For certain domains the requirement for the application to behave exactly as anticipated at design time is key. One such domain is that of well-being. Problems predicting the run-time context may cause the application to behave in other ways than intended. Current research efforts primarily focus on adding features to traditional software development methods to deal with the complexity of the domain of context-awareness. They aim to define a full set of requirements and design an application that is to satisfy these requirements. Furthermore, there are research directions aiming to solve the technological problems of context-awareness without dealing with the user-centric elements needed for well-being systems. We see the field of well-being as consisting of variables and relations between them. To ease the documentation of the variables that the context relevant to the well-being application is made up of, we have designed a domain specific modeling language. In addition to variables, the models created in this language capture variable properties, such as their dimension and their normal range, and causal relations between them, modeling what happens to variable values if one variable in the context is increased or decreased. The modeling language is called the Dynamic Well-being Domain Model language and was developed to be user centric, allowing developers to model the objective well-being context of the user. Although it was designed with the well-being domain in mind, it can also be used in other domains where context variables play an important role. The contributions of this dissertation are threefold. Firstly, we present a reference model for the well-being domain, relating physical and mental well-being. This model was validated by experts from both fields. We discuss how this model was created. Secondly, we describe a model-driven process for the creation of context-aware well-being systems. This process uses models of the well-being context as an input, and is partially automated using model transformations. Finally, we describe a structured analysis method that can be used to predict the behavior of context-aware systems based on their domain models. This prediction can be made at design time, allowing designers to evaluate the utility of the application based on the model, and preventing run-time problems. This method was validated by analyzing three context-aware well-being applications. We find that the Dynamic Well-being Domain Model language can be understood by domain and technology experts alike. Its usage in a model-driven development process was deemed useful, and the ability to reason over future contexts was found to be both powerful and reliable for the cases used in the validation.

In recent years, we have witnessed an increase in the capabilities of smartphones. Not only are these portable communication devices becoming increasingly powerful, they are equipped with a growing number of sensors that allow them to measure the properties of the world around them. Applications running on these smartphones can benefit from these sensors if developers choose to make them context-aware. However, applications that are built to operate in a wide variety of situations have to be able to cope with and respond to any combination of measured context factors. Anticipation of these different contexts at design time is challenging. For certain domains the requirement for the application to behave exactly as anticipated at design time is key. One such domain is that of well-being. Problems predicting the run-time context may cause the application to behave in other ways than intended. Current research efforts primarily focus on adding features to traditional software development methods to deal with the complexity of the domain of context-awareness. They aim to define a full set of requirements and design an application that is to satisfy these requirements. Furthermore, there are research directions aiming to solve the technological problems of context-awareness without dealing with the user-centric elements needed for well-being systems. We see the field of well-being as consisting of variables and relations between them. To ease the documentation of the variables that the context relevant to the well-being application is made up of, we have designed a domain specific modeling language. In addition to variables, the models created in this language capture variable properties, such as their dimension and their normal range, and causal relations between them, modeling what happens to variable values if one variable in the context is increased or decreased. The modeling language is called the Dynamic Well-being Domain Model language and was developed to be user centric, allowing developers to model the objective well-being context of the user. Although it was designed with the well-being domain in mind, it can also be used in other domains where context variables play an important role. The contributions of this dissertation are threefold. Firstly, we present a reference model for the well-being domain, relating physical and mental well-being. This model was validated by experts from both fields. We discuss how this model was created. Secondly, we describe a model-driven process for the creation of context-aware well-being systems. This process uses models of the well-being context as an input, and is partially automated using model transformations. Finally, we describe a structured analysis method that can be used to predict the behavior of context-aware systems based on their domain models. This prediction can be made at design time, allowing designers to evaluate the utility of the application based on the model, and preventing run-time problems. This method was validated by analyzing three context-aware well-being applications. We find that the Dynamic Well-being Domain Model language can be understood by domain and technology experts alike. Its usage in a model-driven development process was deemed useful, and the ability to reason over future contexts was found to be both powerful and reliable for the cases used in the validation.

Robots are becoming more and more complex and heterogeneous; their abilities and domains of usage are increasing exponentially. Programming these robots requires special skills and usually does not follow standard software engineering methodologies. Adhering to modeldriven software engineering principles, definition of robot behaviour is abstracted and represented in models while robot-specific code is generated from these models using code generation. With a robot modelling framework, we can work on a higher abstraction level making the task of programming complex heterogeneous robots more efficient. In this paper, we present such a modelling framework and evaluate its flexibility by extending it with wireless communication functionalities Copyright (c) 2018 Authors. Published at http://ceur-ws.org/Vol-2245/morse_paper_1.pdf

International audience; MegaM@Rt2 project is a collaborative initiative of the ECSEL Joint Undertaking under Horizon 2020 EU programme. The project regroups 26 partners from 6 different European countries who jointly address challenges of engineering modern cyberphysical systems by using model-based engineering methods. Since it is a model-based project, we adopted a similar approach for dealing with requirements analysis, architecture, design, roadmap planning and development status checking. In these tasks, document generation methods were particularly useful to create a set of “live” reference specifications and contractual reports. We believe that these methods perfectly demonstrate relevant benefits of the model-based approach and are applicable to many other contexts. Document generation has several challenges, since the produced documents should address several goals and target different audience. Hence, we describe this approach in detail in this paper in the form of an experience report.In essence, the MegaM@Rt2 project had a rather trivial task to document inception phase of the project. The challenge arises from the scale of the project, we had to deal with hundreds of requirements from completely different users, hundreds of features of 29 tools, which had to be mapped to those requirements in order to analyze a gap and devise a roadmap for a consistent tool chain. With limited resource on technical coordination we had to be extremely efficient and thus we adopted a model-based approach that we describe in this paper. The paper should be helpful to project managers and architects who wish to discuss on model-based approaches from a practical side.

Most innovative applications having robotic capabilities like self-driving cars are developed from scratch with little reuse of design or code artifacts from previous similar projects. As a result, work at times is duplicated adding time and economic costs. Absence of integrated tools is the real barrier that exists between early adopters of standardization efforts and early majority of research and industrial community. These software intensive systems are composed of distributed, heterogeneous software components interacting in a highly dynamic, uncertain environment. However, no significant systematic software development process is followed in robotics research. The process of developing robotic software frameworks and tools for designing robotic architectures is expensive both in terms of time and effort, and absence of systematic approach may result in ad hoc designs that are not flexible and reusable. Making architecture meta-framework a point of conformance opens new possibilities for interoperability and knowledge sharing in the architecture and framework communities. We tried to make a step in this direction by proposing a common model and by providing a systematic methodological approach that helps in specifying different aspects of software architecture development and their interplay in a framework., La plupart des applications robotiques, telles que les véhicules autonomes, sont développées à partir d’une page blanche avec quelques rares réutilisations de conceptions ou de codes issus d’anciens projets équivalents. Qui plus est, les systèmes robotiques deviennent de plus en plus critiques, dans la mesure où ils sont déployés dans des environnements peu structurés, et centrés sur l’humain. Ces systèmes à fort contenu logiciel qui utilisent des composants distribués et hétérogènes interagissent dans un environnement dynamique, et incertain. Or, il s’agit là d’étapes indispensables pour la mise en place de méthodes d’évaluation extensibles, ainsi que pour permettre la réutilisation de composants logiciels pré-existants. Le développement de structures logicielles et d’outils de conception d’architectures, orientés pour la robotique, coûte cher en termes de temps et d’effort, et l’absence d’une approche systématique pourrait conduire à la production de conceptions adhoc, peu flexibles et peu réutilisables. Faire de la meta-structure de l’architecture un point de convergence offre de nouvelles possibilités en termes d’interopérabilité, et de partage de la connaissance, au sein des communautés dédiées à la mise en place d’architectures et de structures. Nous suivons cette direction, en proposant un modèle commun, et en fournissant une approche méthodologique systématique aidant à spécifier les différents aspects du développement d’architectures logicielles, et leurs relations au sein d’une structure partagée.

Ensuring that an interactive application allows users to perform their activities and reach their goals is critical to the overall usability of the interactive application. Indeed, the effectiveness factor of usability directly refers to this capability. Assessing effectiveness is a real challenge for usability testing as usability tests only cover a very limited number of tasks and activities. This paper proposes an approach towards automated testing of effectiveness of interactive applications. To this end we resort to two main elements: an exhaustive description of users’ activities and goals using task models, and the generation of scenarios (from the task models) to be tested over the application. However, the number of scenarios can be very high (beyond the computing capabilities of machines) and we might end up testing multiple similar scenarios. In order to overcome these problems, we propose strategies based on task models manipulations (e.g., manipulating task nodes, operator nodes, information ...) resulting in a more intelligent test case generation approach. For each strategy, we investigate its relevance (both in terms of test case generation and in terms of validity compared to the original task models) and we illustrate it with a small example. Finally, the proposed strategies are applied on a real-size case study demonstrating their relevance and validity to test interactive applications., Work at HASLab was carried out in the context of project "NORTE-01-0145-FEDER-000016", financed by the North Portugal Regional Operational Programme (NORTE 2020), under the PORTUGAL 2020 Partnership Agreement, and through the European Regional Development Fund (ERDF)., info:eu-repo/semantics/publishedVersion

Software is so prevalent in all areas of life that one could expect we have come up with more simple and intuitive ways for its creation by now. However, software development is still too complicated to easily and efficiently cope with individual demands, customizations, and changes. Model-based approaches promise improvements through a more comprehensible layer of abstraction, but they are rarely fully embraced in practice. They are perceived as being overly complex, imposing additional work, and lacking the flexibility required in the real world. This thesis presents a novel approach to model-driven software engineering that focuses on simplicity through highly specialized tools. Domain experts are provided with development tools tailored to their individual needs, where they can easily specify the intent of the software using their known terms and concepts. This domain specificity (D) is a powerful mechanism to boil down the effort of defining a system to relevant aspects only. Many concepts are set upfront, which imposes a huge potential for automated generation. However, the full potential of domain-specific models can only unfold, if they are used as primary artifacts of development. The presented approach thus combines domain specificity with full generation (F) to achieve an overall pushbutton generation that does not require any round-trip engineering. Furthermore, service orientation (S) introduces a ‘just use’ philosophy of including arbitrarily complex functionality without needing to know their implementation, which also restores flexibility potentially sacrificed by the domain focus. The unique combination of these three DFS properties facilitates a focused, efficient, and flexible simplicity-driven way of software development. Key to the approach is a holistic solution that in particular also covers the simplicity-driven development of the required highly specialized DFS tools, as nothing would be gained if the costs of developing such tools outweighed the resulting benefits. This simplicity is achieved by applying the very same DFS concepts to the domain of tool development itself: DFS modeling tools are fully generated from models and services specialized to the (meta) domain of modeling tools. The presented Cinco meta tooling suite is a first implementation of such a meta DFS tool. It focuses on the generation of graphical modeling tools for graph structures comprising of various types of nodes and edges. Cinco has been very successfully applied to numerous industrial and academic projects, and thus also serves as a proof of concept for the DFS approach itself. The unique combination of the three DFS strategies and Cinco's meta-level approach towards their realization in practice lay the foundation for a new paradigm of software development that is strongly focused on simplicity.

Security assurance is a property that ensures that the application code behaves consistently with the access control policy specified at the design level. Security assurance proofs are valid as long as software engineers do not modify the generated code. This assumption does not hold in Round-Trip Engineering, since programmers may modify the generated code and the models are automatically re-generated. This paper proposes a round-trip engineering approach for access control that preserves security assurance both when generating code from models and vice versa. The approach is to extend programming [email protected]? typing mechanisms with additional rules that ensure consistency between models and code, even when code is arbitrarily modified by programmers. This paper presents a formal description of the solution and an initial sketch of the required proofs of correctness. Ongoing work is the development of a prototype to automate most of the process and its validation in a case study.

One of the problems of current software development lies on the existence of solutions to address properly the code portability for the increasing number of platforms. To build abstract models is one efficient and correct way to achieve this. The Model-Driven Software Engineering (MDSE) is a development methodology where models are the key for all project lifecycle, from requisites gathering, through modelling and to the development stage, as well as on testing. Pervasive computing demands the use of several technical specifications, such as wireless connections, advanced electronics, and the Internet, as well as it stresses the need to adjust the user interface layer to each one of the platforms. Using a model-driven approach it is possible to reuse software solutions between different targets, since models are not affected by the device diversity and its evolution. This paper reports on a tool, which is highly parameterizable and driven to support Model-2-Model and Model-2-Code transformations. Also, instead of using a predefined technology, the tool was built to be scalable and extensible for many different targets and also by addressing the user interface layer generation., This work is financed by the ERDF ? European Regional Development Fund through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme within projectPOCI-01-0145-FEDER-006961, and by National Funds through the FCT ? Fundação para a Ciência e a Tecnologia (Portuguese Foundation for Science and Technology) as part of project UID/EEA/50014/2013., info:eu-repo/semantics/publishedVersion

Model-Driven Engineering (MDE) ist ein Paradigma der Softwaretechnik, in dem es darum geht, das Abstrationsniveau und dadurch die Entwicklerproduktivität während der Softwareentwicklung zu erhöhen. Hierzu lässt man Software-Modellen eine wesentliche Rolle während Entwurf, Implementierung und Einführung eines Systems zukommen. In jüngerer Zeit wurde MDE verhäuft in industriellen Projekten hoher Komplexität und großen Umfangs eingesetzt – ein Trend, den wir als MDE im Großen bezeichnen. Wir betrachten drei Herausforderungen, die durch den Einsatz von MDE in solchen Szenarien entstehen: 1. Modelle werden an verteilten Standorten, durch Teams von Teams entwickelt. Dabei führt die Verwendung großer und unzureichend strukturierter Modelle zu erheblichen Problemen, etwa zu einer erhöhten Anfälligkeit für Editierkonflikte. 2. Große Systeme werden oft durch einen Verbund von Modellen spezifiziert, die auf domänenspezifischen Modellierungssprachen (DSMLs) basieren. Die Modelle heterogener DSMLs in systematischer Weise zu integrieren erfordert geeignete Modularisierungsstrategien. 3. Um die Entwicklung von Modellen systematisch zu beschreiben, spezifiziert man die dazu notwendigen Operationen durch Modelltransformationsregeln. Modelltransformationsregeln werden oft durch Klonierung erzeugt, also durch das Kopieren und Modifizieren vorhandener Regeln. Damit sind Nachteile für die Wartbarkeit und Performanz der erzeugten Regelsysteme verbunden. Im Rahmen dieser Arbeit präsentieren wir drei neue RefactoringVerfahren. Jedes dieser Verfahren zielt auf eine der benannten Herausforderungen ab: 1. Wir stellen ein Verfahren für das Aufsplitten eines monolithischen Modells in eine Menge von Teilmodellen vor. Dieses Verfahren ermöglicht die Umstrukturierung von Modellen hin zu einer Trennung der Belange. Bei der kollaborativen Entwicklung eines Systems können die beteiligten Entwickler somit auf Teilmodellen arbeiten, die für ihr aktuelles Arbeitspaket relevant sind. 2. Wir beschreiben ein Verfahren zur Kapselung von Modellkomponenten durch die Einführung von Schnittstellen in einem Verbund von Modellen. Dieses Verfahren ermöglicht es, in Modellen von heterogenen DSMLs Modularität einzuführen. 3. Wir präsentieren ein Verfahren, um Modelltransformationsregeln, die gemeinsame Anteile aufweisen, zu verschmelzen. Dieses Verfahren zielt darauf ab, die Wartbarkeit und Performanz in Modelltransformationssystemen zu verbessern. Das Verfahren erstellt variabiliätsbasierte Regeln, ein neuartiger Typ von Regeln, in dem Variabilität anhand von Annotationen spezifiziert wird. Die im Rahmen dieser Arbeit vorgestellten Verfahren ermöglichen es, den manuellen Aufwand während des Refactorings von Modellen und Modelltransformationsregeln erheblich zu reduzieren. In einer Reihe von realistischen Fallstudien zeigen wir, dass die erstellten Modelle und Regeln von vergleichbarer oder, im Fall von Regeln, teilweise sogar von zu bevorzugender Qualität gegenüber dem Ergebnis eines manuellen Refactorings sind. Wir versprechen uns daher eine hohe Relevanz der Beiträge für MDE im Kontext industrieller Softwareentwicklung., Model-Driven Engineering (MDE) is a software engineering paradigm that aims to increase the productivity of developers by raising the abstraction level of software development. It envisions the use of models as key artifacts during design, implementation and deployment. From the recent arrival of MDE in large-scale industrial software development – a trend we refer to as MDE in the large –, a set of challenges emerges: First, models are now developed at distributed locations, by teams of teams. In such highly collaborative settings, the presence of large monolithic models gives rise to certain issues, such as their proneness to editing conflicts. Second, in large-scale system development, models are created using various domain-specific modeling languages. Combining these models in a disciplined manner calls for adequate modularization mechanisms. Third, the development of models is handled systematically by expressing the involved operations using model transformation rules. Such rules are often created by cloning, a practice related to performance and maintainability issues. In this thesis, we contribute three refactoring techniques, each aiming to tackle one of these challenges. First, we propose a technique to split a large monolithic model into a set of sub-models. The aim of this technique is to enable a separation of concerns within models, promoting a concern-based collaboration style: Collaborators operate on the submodels relevant for their task at hand. Second, we suggest a technique to encapsulate model components by introducing modular interfaces in a set of related models. The goal of this technique is to establish modularity in these models. Third, we introduce a refactoring to merge a set of model transformation rules exhibiting a high degree of similarity. The aim of this technique is to improve maintainability and performance by eliminating the drawbacks associated with cloning. The refactoring creates variability-based rules, a novel type of rule allowing to capture variability by using annotations. The refactoring techniques contributed in this work help to reduce the manual effort during the refactoring of models and transformation rules to a large extent. As indicated in a series of realistic case studies, the output produced by the techniques is comparable or, in the case of transformation rules, partly even preferable to the result of manual refactoring, yielding a promising outlook on the applicability in real-world settings.