Search

In this paper, we present a transition journey of automotive software architecture design from using legacy approaches and toolchains to employing new modeling capabilities in the recent releases of Matlab/Simulink (M/S). We present the seamless approach that we have employed for the software architecture modeling of a mixed-critical electric powertrain controller which runs on a multi-core hardware platform. With our approach, we can achieve bidirectional traceability along with a powerful authoring process, implement a detailed model-based software architecture design of AUTOSAR system including a detailed data dictionary, and carry out umpteen number of proof-of-concept studies, what-if scenario simulations and performance tuning of safety software. In this context, we discuss an industrial case study employing valuable lessons learned, our experience reports providing novel insights and best practices followed.

Model transformations are the key technique in Model-Driven Engineering (MDE) to manipulate and construct models. As a consequence, the correctness of software systems built with MDE approaches relies mainly on the correctness of model transformations, and thus, detecting and locating bugs in model transformations have been popular research topics in recent years. This surge of work has led to a vast literature on model transformation testing and debugging, which makes it challenging to gain a comprehensive view of the current state of the art. This is an obstacle for newcomers to this topic and MDE practitioners to apply these approaches. This paper presents a survey on testing and debugging model transformations based on the analysis of \nPapers~papers on the topics. We explore the trends, advances, and evolution over the years, bringing together previously disparate streams of work and providing a comprehensive view of these thriving areas. In addition, we present a conceptual framework to understand and categorise the different proposals. Finally, we identify several open research challenges and propose specific action points for the model transformation community. This work is partially supported by the European Commission (FEDER) and Junta de Andalucia under projects APOLO (US-1264651) and EKIPMENT-PLUS (P18-FR-2895), by the Spanish Government (FEDER/Ministerio de Ciencia e Innovación – Agencia Estatal de Investigación) under projects HORATIO (RTI2018-101204-B-C21), COSCA (PGC2018-094905-B-I00) and LOCOSS (PID2020-114615RB-I00), by the Austrian Science Fund (P 28519-N31, P 30525-N31), and by the Austrian Federal Ministry for Digital and Economic Affairs and the National Foundation for Research, Technology and Development (CDG)

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

Domain-Specific Languages (DSLs) are tailored to a specific domain which requires them to provide domain-specific concepts and a sophisticated tooling for their engineering; aspects which we address with the language workbench MontiCore. As we use MontiCore for research and teaching, we are interested in reducing the entry barrier to use and engineer MontiCore DSLs. While there are approaches for ready-to-use learning environments such as web-based editors, only a few provide a tailored solution for specific DSLs. Within this paper, we present our experiences using JupyterLab in combination with the infrastructure of MontiCore for teaching the use and engineering of DSLs in an interactive manner. We have realized three practical courses and one conference tutorial applying this technical approach. The front-end provides immediate feedback and includes supporting explanations in an integrated manner. Initial feedback indicates that this approach can lower the entry barrier for DSL use and engineering for students and practitioners.

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.

This article reports on the Design Science engineering cycle for implementing a modeling method to support model-driven, process-centric API management. The BPMN standard was hereby enriched on semantic, syntactic and tool levels in order to provide a viable solution for integrating API requests with diagrammatic business process models in order to facilitate the documentation or testing of REST API calls directly in a modeling environment. The method can be implemented by stakeholders that need to map and manage their API ecosystem, thus gaining more API management agility and improving their software engineering productivity. By assimilating API ecosystem conceptualization in the modeling environment, the proposal differs from both RPA (which typically employs non-BPMN process diagramming e.g., in UIPath) and BPM Systems (which typically isolate all API-related semantics outside the process modeling language to keep the diagrammatic representation standard-compliant).

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

Program analyses are an important tool to check if a system fulfills its specification. A typical implementation strategy for program analyses is to use an imperative, general-purpose language like Java; and access the program to be analyzed through libraries for manipulating intermediate code, such as ASM for Java bytecode. We show that this hampers composability, interoperability and reuse of analysis implementations. We propose a complete Ecore-metamodel for Java bytecode as a common basis for program analysis implementations, as well as an Eclipse plug-in to create bytecode metamodel instances from Java bytecode and vice versa. Code analyses can be defined as model transformations in a declarative, domain-specific language. As a consequence, the implementations of program analyses become more composable and more modular in general. We demonstrate the effectiveness of this approach with a case study.

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.

One of the main challenges in developing a software system is to assure that its properties fulfill the specifications. In the context of this paper, we are especially interested in timing properties. Model-based software verification is one of the approaches to achieve this. However, model-based verification requires expressive models of software systems and deriving such models is not a trivial task. Although there are a few model derivation tool proposals for the purpose of model-checking timing properties, these are dedicated tools supporting a selected set of verification techniques and as such they are not explicitly designed for coping with new demands. This paper presents a framework that derives models from Java programs in an automated way for analyzing timing properties. The framework has the following properties that are not provided by the previous proposals: (1) Efficiency in model development, (2) consistency of models with software, (3) expressiveness of models, (4) scalability and (5) extensibility of the model derivation process.

One of the main challenges in developing a software system is to assure that its properties fulfill the specifications. In the context of this paper, we are especially interested in timing properties. Model-based software verification is one of the approaches to achieve this. However, model-based verification requires expressive models of software systems and deriving such models is not a trivial task. Although there are a few model derivation tool proposals for the purpose of model-checking timing properties, these are dedicated tools supporting a selected set of verification techniques and as such they are not explicitly designed for coping with new demands. This paper presents a framework that derives models from Java programs in an automated way for analyzing timing properties. The framework has the following properties that are not provided by the previous proposals: (1) Efficiency in model development, (2) consistency of models with software, (3) expressiveness of models, (4) scalability and (5) extensibility of the model derivation process.

Model transformations, together with models, form the principal artifacts in model-driven software development. Industrial practitioners report that transformations on larger models quickly get sufficiently large and complex themselves. To alleviate entailed maintenance efforts, this thesis presents a modularity concept with explicit interfaces, complemented by software visualization and clustering techniques. All three approaches are tailored to the specific needs of the transformation domain.

Model-Driven Engineering (MDE) is becoming a widely accepted paradigm for the design and development of complex distributed applications. MDE advocates the use of models and model transformations as key artefacts in all phases of the software process, from system specification and analysis, to design, development and testing. Each model usually addresses one concern, independently from the rest of the issues involved in the construction of the system. Thus, the basic functionality of the system can be separated from its final implementation, and the business logic can be separated from the underlying platform technology, etc. Transformations between models enable the automated implementation of a system from the different models defined for it., Facultad de Informática

Reengineering is one of the key concepts in software maintenance and evolution. It generally includes some form of reverse engineering followed by some form of forward engineering or restructuring. In the paper we focus on database reverse engineering. Model-driven software engineering promotes the idea of abstracting implementation details by focusing on: models as first class entities and automated generation of models or code from other models. In the approach meta-models are used to define the modeling languages. A database reverse engineering process can benefit of integrating meta-modeling and meta-models in the process. The plethora of models related to databases points out to the need and importance of model-to-model transformations between these models at different abstraction levels. These transformations are based on meta-models that are conformed by the source and target models of the transformations. A database reverse engineering process can be performed through a chain of model-to-model transformations based on a set of meta-models. In the paper we discuss the importance of meta-modeling in the context of database reverse engineering and present a case study illustrating an approach to database reverse engineering.

Capacity management is a core activity when designing and operating distributed software systems. It comprises the provisioning of data center resources and the deployment of software components to these resources. The goal is to continuously provide adequate capacity, i.e., service level agreements should be satisfied while keeping investment and operating costs reasonably low. Traditional capacity management strategies are rather static and pessimistic: resources are provisioned for anticipated peak workload levels. Particularly, enterprise application systems are exposed to highly varying workloads, leading to unnecessarily high total cost of ownership due to poor resource usage efficiency caused by the aforementioned static capacity management approach. During the past years, technologies emerged that enable dynamic data center infrastructures, e. g., leveraged by cloud computing products. These technologies build the foundation for elastic online capacity management, i.e., adapting the provided capacity to workload demands based on a short-term horizon. Because manual online capacity management is not an option, automatic control approaches have been proposed. However, most of these approaches focus on coarse-grained adaptation actions and adaptation decisions are based on aggregated system-level measures. Architectural information about the controlled software system is rarely considered. This thesis introduces a model-driven online capacity management approach for distributed component-based software systems, called SLAstic. The core contributions of this approach are a) modeling languages to capture relevant architectural information about a controlled software system, b) an architecture-based online capacity management framework based on the common MAPE-K control loop architecture, c) model-driven techniques supporting the automation of the approach, d) architectural runtime reconfiguration operations for controlling a system’s capacity, e) as well as an integration of the Palladio Component Model. A qualitative and quantitative evaluation of the approach is performed by case studies, lab experiments, and simulation.

International audience; As every-day mobile devices can easily be equipped with multiple sensing capabilities, ubiquitous applications are expected to exploit the richness of the context information that can be collected by these devices in order to provide the service that is the most appropriate to the situation of the user. However, the design and implementation of such context-aware ubiquitous appplications remain challenging as there exist very few models and tools to guide application designers and developers in mastering the complexity of context information. This becomes even more crucial as context is by nature imperfect. One way to address this issue is to associate to context information meta-data representing its quality. We propose a generic and extensible design process for context-aware applications taking into account the quality of context (QoC). We demonstrate its use on a prototype application for sending flash sale offers to mobile users. We present extensive performance results in terms of memory and processing time of both elementary context management operations and the whole context policy implementing the Flash sale application. The cost of adding QoC management is also measured and appears to be limited to a few milliseconds. We show that a context policy with 120 QoC-aware nodes can be processed in less than 100 ms on a mobile phone. Moreover, a policy of almost 3000 nodes can be instantiated before exhausting the resources of the phone. This enables very rich application scenarios enhancing the user experience and will favor the development of new ubiquitous applications.

Scientific workflows are one important means in the context of data-intensive science for reliable and efficient scientific data processing in distributed computing infrastructures such as Grids. A common trend is to adapt existing and established business workflow technologies instead of developing own technologies from scratch. This thesis provides a model-driven approach for scientific workflow engineering, in which domain-specific languages (DSLs) tailored for a certain scientific domain are used for scientific workflow modeling, and automated mapping techniques for technical execution are developed and evaluated. The Business Process Model and Notation (BPMN) is thereby used at the domain-specific layer and the Web Services Business Process Execution Language (BPEL) at the technical layer. The implementation uses the Eclipse Modeling Framework (EMf) and is evaluated in three application scenarios.

The growth of the Internet and the evolution of communicating devices have allow the integration of the computer world and the real world, paving the way for developing new types of applications such as pervasive and ubiquitous ones. These applications must run in heterogeneous, distributed and open environments that evolve constantly. In such environments, the availability of services and devices, the preferences and location of users may change at any time during the execution of applications. The variability of the execution context makes the execution of an application dependent on the available services and devices. Building applications capable of evolving dynamically to their execution context is a challenging task. In fact, the architecture of such an application cannot be fully known nor statically specified at design, development or deployment times. It is then needed to redefine the concept of dynamic application in order to cover the design, development, execution and management phases, and to enable thus the dynamic construction and evolution of applications. In this dissertation, we propose a model-driven approach for the design, development and execution of dynamic applications. We defined a component service model that considers dynamic properties within a component model. This model allows defining an application by its intention (its goal) through a set of composition properties, constraints and preferences. An application is thus specified in an abstract way, which allows controlling its gradual composition during development and execution times. Our approach aims to blur the boundary between development-time and runtime. Thus, the same model and the same composition mechanisms are used from design to runtime. At runtime, the composition process considers also the services available in the execution platform in order to compose applications opportunistically; and the variability of the execution context in order to adapt compositions dynamically. We implemented our approach through a prototype named COMPASS, which relies on the CADSE platform for building software design and development environments, and on the APAM platform for building an execution environment for dynamic service-based applications.; L'essor de l'Internet et l'évolution des dispositifs communicants ont permis l'intégration du monde informatique et du monde réel, ouvrant ainsi la voie à de nouveaux types d'applications, tels que les applications ubiquitaires et pervasives. Ces applications doivent s'exécuter dans des contextes hétérogènes, distribués et ouverts qui sont en constante évolution. Dans de tels contextes, la disponibilité des services et des dispositifs, les préférences et la localisation des utilisateurs peuvent varier à tout moment pendant l'exécution des applications. La variabilité des contextes d'exécution fait que l'exécution d'une application dépend, par exemple, des services disponibles ou des dispositifs accessibles à l'exécution. En conséquence, l'architecture d'une telle application ne peut pas être connue statiquement à la conception, au développement ou au déploiement, ce qui impose de redéfinir ce qu'est une application dynamique : comment la concevoir, la développer, l'exécuter et la gérer à l'exécution. Dans cette thèse, nous proposons une approche dirigée par les modèles pour la conception, le développement et l'exécution d'applications dynamiques. Pour cela, nous avons défini un modèle de composants à services permettant d'introduire des propriétés de dynamisme au sein d'un modèle de composants. Ce modèle permet de définir une application en intention, via un ensemble de propriétés, de contraintes et de préférences de composition. Une application est ainsi spécifiée de façon abstraite ce qui permet de contrôler la composition graduelle de l'application lors de son développement et de son exécution. Notre approche vise à effacer la frontière entre les activités effectuées avant et pendant l'exécution des applications. Pour ce faire, le même modèle et les mêmes mécanismes de composition sont utilisés de la conception jusqu'à l'exécution des applications. A l'exécution, le processus de composition considère, en plus, les services disponibles dans la plate-forme d'exécution permettant la composition opportuniste des applications ; ainsi que la variabilité du contexte d'exécution permettant l'adaptation dynamique des compositions. Nous avons mis en œuvre notre approche via un prototype nommé COMPASS, qui s'appuie sur les plates-formes CADSE pour la réalisation d'environnements logiciels de conception et de développement, et APAM pour la réalisation d'un environnement d'exécution d'applications à services dynamiques.

The growth of the Internet and the evolution of communicating devices have allow the integration of the computer world and the real world, paving the way for developing new types of applications such as pervasive and ubiquitous ones. These applications must run in heterogeneous, distributed and open environments that evolve constantly. In such environments, the availability of services and devices, the preferences and location of users may change at any time during the execution of applications. The variability of the execution context makes the execution of an application dependent on the available services and devices. Building applications capable of evolving dynamically to their execution context is a challenging task. In fact, the architecture of such an application cannot be fully known nor statically specified at design, development or deployment times. It is then needed to redefine the concept of dynamic application in order to cover the design, development, execution and management phases, and to enable thus the dynamic construction and evolution of applications. In this dissertation, we propose a model-driven approach for the design, development and execution of dynamic applications. We defined a component service model that considers dynamic properties within a component model. This model allows defining an application by its intention (its goal) through a set of composition properties, constraints and preferences. An application is thus specified in an abstract way, which allows controlling its gradual composition during development and execution times. Our approach aims to blur the boundary between development-time and runtime. Thus, the same model and the same composition mechanisms are used from design to runtime. At runtime, the composition process considers also the services available in the execution platform in order to compose applications opportunistically; and the variability of the execution context in order to adapt compositions dynamically. We implemented our approach through a prototype named COMPASS, which relies on the CADSE platform for building software design and development environments, and on the APAM platform for building an execution environment for dynamic service-based applications.; L'essor de l'Internet et l'évolution des dispositifs communicants ont permis l'intégration du monde informatique et du monde réel, ouvrant ainsi la voie à de nouveaux types d'applications, tels que les applications ubiquitaires et pervasives. Ces applications doivent s'exécuter dans des contextes hétérogènes, distribués et ouverts qui sont en constante évolution. Dans de tels contextes, la disponibilité des services et des dispositifs, les préférences et la localisation des utilisateurs peuvent varier à tout moment pendant l'exécution des applications. La variabilité des contextes d'exécution fait que l'exécution d'une application dépend, par exemple, des services disponibles ou des dispositifs accessibles à l'exécution. En conséquence, l'architecture d'une telle application ne peut pas être connue statiquement à la conception, au développement ou au déploiement, ce qui impose de redéfinir ce qu'est une application dynamique : comment la concevoir, la développer, l'exécuter et la gérer à l'exécution. Dans cette thèse, nous proposons une approche dirigée par les modèles pour la conception, le développement et l'exécution d'applications dynamiques. Pour cela, nous avons défini un modèle de composants à services permettant d'introduire des propriétés de dynamisme au sein d'un modèle de composants. Ce modèle permet de définir une application en intention, par un ensemble de propriétés, de contraintes et de préférences de composition. Une application est ainsi spécifiée de façon abstraite ce qui permet de contrôler la composition graduelle de l'application lors de son développement et de son exécution. Notre approche vise à effacer la frontière entre les activités effectuées avant et pendant l'exécution des applications. Pour ce faire, le même modèle et les mêmes mécanismes de composition sont utilisés de la conception jusqu'à l'exécution des applications. A l'exécution, le processus de composition considère, en plus, les services disponibles dans la plate-forme d'exécution permettant la composition opportuniste des applications ; ainsi que la variabilité du contexte d'exécution permettant l'adaptation dynamique des compositions. Nous avons mis en oeuvre notre approche à travers le prototype nommé COMPASS, qui s'appuie sur les plates-formes CADSE pour la réalisation d'environnements logiciels de conception et de développement, et APAM pour la réalisation d'un environnement d'exécution d'applications à services dynamiques.

The growth of the Internet and the evolution of communicating devices have allow the integration of the computer world and the real world, paving the way for developing new types of applications such as pervasive and ubiquitous ones. These applications must run in heterogeneous, distributed and open environments that evolve constantly. In such environments, the availability of services and devices, the preferences and location of users may change at any time during the execution of applications. The variability of the execution context makes the execution of an application dependent on the available services and devices. Building applications capable of evolving dynamically to their execution context is a challenging task. In fact, the architecture of such an application cannot be fully known nor statically specified at design, development or deployment times. It is then needed to redefine the concept of dynamic application in order to cover the design, development, execution and management phases, and to enable thus the dynamic construction and evolution of applications. In this dissertation, we propose a model-driven approach for the design, development and execution of dynamic applications. We defined a component service model that considers dynamic properties within a component model. This model allows defining an application by its intention (its goal) through a set of composition properties, constraints and preferences. An application is thus specified in an abstract way, which allows controlling its gradual composition during development and execution times. Our approach aims to blur the boundary between development-time and runtime. Thus, the same model and the same composition mechanisms are used from design to runtime. At runtime, the composition process considers also the services available in the execution platform in order to compose applications opportunistically; and the variability of the execution context in order to adapt compositions dynamically. We implemented our approach through a prototype named COMPASS, which relies on the CADSE platform for building software design and development environments, and on the APAM platform for building an execution environment for dynamic service-based applications.; L'essor de l'Internet et l'évolution des dispositifs communicants ont permis l'intégration du monde informatique et du monde réel, ouvrant ainsi la voie à de nouveaux types d'applications, tels que les applications ubiquitaires et pervasives. Ces applications doivent s'exécuter dans des contextes hétérogènes, distribués et ouverts qui sont en constante évolution. Dans de tels contextes, la disponibilité des services et des dispositifs, les préférences et la localisation des utilisateurs peuvent varier à tout moment pendant l'exécution des applications. La variabilité des contextes d'exécution fait que l'exécution d'une application dépend, par exemple, des services disponibles ou des dispositifs accessibles à l'exécution. En conséquence, l'architecture d'une telle application ne peut pas être connue statiquement à la conception, au développement ou au déploiement, ce qui impose de redéfinir ce qu'est une application dynamique : comment la concevoir, la développer, l'exécuter et la gérer à l'exécution. Dans cette thèse, nous proposons une approche dirigée par les modèles pour la conception, le développement et l'exécution d'applications dynamiques. Pour cela, nous avons défini un modèle de composants à services permettant d'introduire des propriétés de dynamisme au sein d'un modèle de composants. Ce modèle permet de définir une application en intention, via un ensemble de propriétés, de contraintes et de préférences de composition. Une application est ainsi spécifiée de façon abstraite ce qui permet de contrôler la composition graduelle de l'application lors de son développement et de son exécution. Notre approche vise à effacer la frontière entre les activités effectuées avant et pendant l'exécution des applications. Pour ce faire, le même modèle et les mêmes mécanismes de composition sont utilisés de la conception jusqu'à l'exécution des applications. A l'exécution, le processus de composition considère, en plus, les services disponibles dans la plate-forme d'exécution permettant la composition opportuniste des applications ; ainsi que la variabilité du contexte d'exécution permettant l'adaptation dynamique des compositions. Nous avons mis en œuvre notre approche via un prototype nommé COMPASS, qui s'appuie sur les plates-formes CADSE pour la réalisation d'environnements logiciels de conception et de développement, et APAM pour la réalisation d'un environnement d'exécution d'applications à services dynamiques.

A central research goal in information systems science is to achieve a close alignment between business processes, structures of organizations, and the functionality offered by enterprise information systems (EISs), which are used to support the work of organizations. Traditionally, there is a methodical gap between describing organizational incidents and software functionality, because organizations and software systems are understood and constructed with different terminology and on different levels of abstractions, typically also by differently educated groups of people. In enterprise models (EMs), dedicated modeling language elements are used to express knowledge about processes in organizations, e. g., about who is responsible for performing actions, what resources are involved, and what strategic goals are intended to be realized by organizational means. The work at hand shows, how EISs can be created based on this knowledge, which serve as supporting software for performing these tasks. Software development traditionally has to face a distinction between people who work with software, and people who create software. With the use of EMs, a chance opens up to closer involve the users of software systems into the process of developing and configuring the software. Building software from enterprise models is desirable, because once a dedicated relationship between enterprise models and software functionality has been established by a development method, involved users and responsible stakeholders can adapt the software according to their business needs, without having to deal with programming or technical details. This increases efficiency both in developing and operating the software, because software functionality is derived from requirements implicitly stated in EMs. Such a development procedure also promises to more efficiently adapt EIS to dynamic changes in organizations and their environment. Trust in the developed software system is also increased by involving users and responsible stakeholders into specifying the resulting software functionality. The following research work elaborates a software development method to create EISs from EMs. The method is designed as a generic framework to work with any enterprise modeling language, and to generate software for any target system platforms, after appropriate configuration. Fundamental challenges in methodically transforming conceptual models to implementation artifacts, are faced by involving auxiliary models into the software creation process, and splitting up the transformation procedure into multiple dedicated phases. Using this approach, the abstraction gap between conceptual enterprise models and technical implementation artifacts gets systematically bridged by introduced methodical concepts, in order to perform an ontological turn from the bird’s-eye-view description perspective of enterprise models, to an internal system perspective describing technical details of a software system. The elaborated method provides means for efficiently guiding modelers and software developers through the software engineering process. It can be configured at multiple points, to choose the degree of automation on a continuum between a manually supervised development process with methodically scheduled manual development steps, and a zero-coding 100% code generation approach. To clarify the theoretically introduced concepts, prototypical implementation examples are included in the present work. They demonstrate how to configure the method with model-transformations, validity checks, and domain-specific modeling languages, and serve as initial example cases for enterprise model driven software development using the Software Engineering with Enterprise Models (SEEM) method. Ein zentrales Forschungsziel der Wirtschaftsinformatik ist es, einen Abgleich zwischen den Geschäftsprozessen und Strukturen von Organisationen, und der Funktionalität von Unternehmensinformationssystemen (Enterprise Information Systems, EIS), zu erreichen, mit denen die Arbeit von Organisationen unterstützt wird. Traditionell besteht eine methodische Kluft zwischen der Beschreibung organisationaler Gegebenheiten und der Funktionalität von Software, denn Organisationen und Softwaresysteme werden mit verschiedener Terminologie und auf verschiedenen Abstraktionsebenen beschrieben und konstruiert, und dies typischerweise von verschieden ausgebildeten Personengruppen. In Unternehmensmodellen werden dedizierte Sprachmittel genutzt, um Wissen über Prozesse in Organisationen zu modellieren, zum Beispiel über handelnde und verantwortliche Akteure, eingesetzte Ressourcen, oder strategische Ziele, die durch organisatorische Mittel erreicht werden sollen. Die vorliegende Arbeit zeigt, wie basierend auf diesem Wissen EIS entwickelt werden können, die als unterstützende Software zur Ausführung dieser Aufgaben dienen. Softwareentwicklung sieht sich traditionell mit einer Trennung zwischen Personen, die mit Software arbeiten, und Personen, die Software erstellen, konfrontiert. Unter Nutzung von Unternehmensmodellen eröffnet sich eine Chance, Benutzer enger in den Prozess der Entwicklung und Konfiguration von Software einzubinden. Es ist wünschenswert, Unternehmensmodelle zur Softwareentwicklung methodisch heranzuziehen, denn sobald eine nachvollziehbare Beziehung zwischen Unternehmensmodellen und Software-Funktionalität mit Hilfe einer Entwicklungsmethode etabliert ist, können beteiligte Nutzer die Software selbst entsprechend ihrer Bedürfnisse mittels Unternehmensmodellierung anpassen, ohne mit Programmierung oder technischen Details umgehen zu müssen. Das erhöht die Effizienz sowohl bei der Entwicklung als auch Anwendung der Software, denn die Software-Funktionalität wird aus Anforderungen abgeleitet, die implizit in Unternehmensmodellen erfasst sind. Eine solche Entwicklungsmethode verspricht außerdem, EIS an dynamische Veränderungen in Organisationen und deren Umgebung effizienter und kostengünstiger anpassen zu können. Außerdem wird das Vertrauen in die entwickelte Software wird durch Einbeziehung von Nutzern in die Anforderungsspezifikaton gestärkt, wenn Anwender und Leitungsverantwortliche in der Lage sind, die Funktionalität der Software in eigener Verantwortung zu gestalten. Die nachfolgend dargestellten Forschungen erarbeiten eine Software-Entwicklungsmethode zur Erstellung von EIS aus Unternehmensmodellen. Die Methode ist als generischer Rahmen entworfen und kann prinzipiell mit jeder Unternehmensmodellierungssprache verwendet werden, und für jede Zielarchitektur Software erstellen, nach entsprechender Konfiguration. Grundsätzliche Herausforderungen, die sich beim methodischen Übergang von konzeptionellen Modellen zu Implementierungsartefakten stellen, werden durch die Einführung von ergänzenden Zusatzmodellen in den Software-Entwicklungsprozess, sowie die Aufteilung des Transformationsverfahrens in mehrere dedizierte Phasen, angegangen. Mit diesem Ansatz wird die Abstraktionslücke zwischen konzeptionellen Unternehmensmodellen und Implementierungsartefakten durch methodische Konzepte systematisch überbrückt, um die Beschreibungsperspektive von der Vogelperspektive der Unternehmensmodellierung hin zur internen Systemsicht auf Details eines Softwaresystems ontologisch zu drehen. Die erarbeitete Methode erlaubt es, Software-Architekten und -Entwickler effizient durch den Entwicklungsprozess zu leiten. Sie kann an verschiedenen Stellen konfiguriert werden, um den Automationsgrad auf einem Kontinuum zwischen einem manuell beaufsichtigten Entwicklungsprozess mit methodisch vorgesehenen manuellen Entwicklungsschritten, oder einem “zero-coding” Entwicklungsansatz mit 100% Code-Generierung, auszuwählen. Zur Veranschaulichung der theoretisch eingeführten Konzepte enthält die vorliegende Arbeit prototypische Implementierungsbeispiele. Sie demonstrieren die Konfiguration der Methode mit Modelltransformationen, Modellvalidierungen und domänenspezifischen Modellierungssprachen, und dienen als erste Anwendungsbeispiele für Unternehmensmodellgetriebenen Softwareentwicklung mit der Software Engineering with Enterprise Models (SEEM) Methode.

Dissertação de mestrado em Engenharia de Informática, Atualmente, o maior desafio no desenvolvimento de software é referente à a portabilidade das aplicações para as várias plataformas disponíveis, especialmente pela crescente heterogeneidade nos componentes de hardware, de middleware e de software base. O desenho de modelos abstratos de software é uma das formas mais elegantes e eficientes para solucionar este desafio. A Model-Driven Software Engineering (MDSE) ́é uma metodologia de desenvolvimento em que os modelos são chave em todo o ciclo de vida do projeto, desde a captura de requisitos, passando pelas fases de modelação e desenvolvimento, e por fim nos processos de teste e instalação. O objetivo primário desta dissertação foca-se na construção de uma ferramenta, o MDA SMART, capaz de interpretar modelos abstratos de software, parametrizáveis, e de gerar automaticamente código fonte para várias plataformas. A ferramenta, caracterizada por uma arquitetura robusta e extensível, é idealizada para permitir a manipulação de modelos de forma ágil, para ser modular o suficiente para integrar novos perfis meta-modelo e para escalar eficientemente para novas plataformas. O MDA SMART resulta da articulação de uma Domain-Specific Language (DSL) para a gestão dos meta-modelos e consequentes processos de transformação. Na utilização da DSL são obtidos processos de transformação rigorosos, com elevado desempenho e que visam maximizar a consistência e portabilidade dos modelos através de medidas ajustadas a destoarem a heterogeneidade entre as plataformas. Adicionalmente, a ferramenta visa compatibilizar os modelos de lógica de negócio com os referentes às interfaces gráficas que, conjugados, vão permitir a obtenção de modelos e código fonte com alto nível de consistência e completude., The current problem of software development stays on solutions portability for the rising number of platforms. This happens because the hardware high speed evolution, as well as middleware and base software has become more complete, efficient, and in more standardized ways. To port a software product for many platforms it demands the use of several technical specifications, such as wireless connections, advanced electronics, and the internet. Using a model-driven approach it is possible to reuse software solutions between different targets, since models are not affected by the platform diversity and its evolution. The Model-Driven Software Engineering (MDSE) is a development methodology where models are the key for all project lifecycle, from requisites gathering, through modeling and development stage, as well as on testing. This dissertation reports on a tool, the MDA SMART, 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. The tool core is based on a Domain-Specific Language (DSL) definition to ensure models consistency and transformations. With a DSL approach it is possible to achieve rigorous and high performance transformations procedures. Unlike other tools, this tool is targeted to ensure the models consistency and to provide high independency between abstraction layers, maximizing the source code correctness and portability. The ultimate objective is to support other model-driven frameworks on MDA SMART. Here, to make compatible logic models with interface models and generate new models and source code at higher level of completion and consistency.

International audience; Model-driven software engineering (MDE) is a well-known approach for developing software. It reduces complexity, facilitates maintenance and allows for the simulation, verification, validation and execution of software models. In this article, we show how MDE and model execution can be leveraged in the context of human-computer interaction (HCI). We claim that in this application domain it is beneficial to use heterogeneous models, combining different models of computation for different components of the system. We report on a case study that we have carried out to develop an executable model of a gesture-based application for manipu- lating 3D objects, using the Kinect sensor as input device, and the OGRE graphical engine as output device for real- time rendering. The interaction part of this application is fully specified as an executable heterogeneous model with the ModHel'X modeling environment. We exploit the seman- tic adaptation between different models of computation to implement a layered application using the most appropriate models of computation for each layer.

Model-Driven Engineering (MDE) is a software development methodology that relies on the Separation of Concerns (SoC) and Abstraction principles to deal with complexity. Thinking in terms of higher levels of abstraction and building dedicated models to address specific concerns allow decomposing a problem into more manageable subproblems. Within the framework of MDE, model composition is an active field of research that focuses on automating the composition of model-based artifacts in a multi-modeling environment. However the lack of a common formalism for comparing existing approaches hinders their adaptation and reuse for building new model composition techniques. The main contribution of this thesis is to propose a novel definition of model composition as a pair of a mapping and an interpretation. This definition paves the way to a theoretical framework that (1) unifies existing representations of model composition techniques and (2) automates the process of building model composition tools. The main contribution is supported by two subsidiaries propositions: - We propose categories to classify existing mapping techniques and existing model composition interpretations. - We define a language that supports the definition of generic mappings among models and the definition of interpretations. We validate the contribution through two experiments: (1) a systematic literature review validates the proposed categories for mappings and interpretations; (2) a prototype that supports the model composition approach has been tested on an industrial case study from Technicolor about the composition of legacy APIs for the management of heterogeneous video and broadcasting equipments., L'Ingénierie Dirigée par les Modèles (IDM) est basée sur le principe d'abstraction et de séparation des préoccupations pour gérer la complexité du développement de logiciels. Les ingénieurs s'appuient sur des modèles dédiées à la résolution d'un problème particulier. Dans le cadre de l'IDM, la composition de modèles est un domaine de recherche très actif qui vise à automatiser les tâches de recomposition des modèles. La quasi-inexistence de consensus pour comparer les techniques existantes entraîne une explosion de l'effort nécessaire pour produire de nouveaux outils spécifiques à partir de techniques existantes. La contribution principale de cette thèse est de proposer une définition originale de la composition de modèles comme étant une paire correspondance-interprétation. A partir de cette définition, nous proposons un cadre théorique qui (1) unifie les représentations des techniques de composition existantes et qui (2) automatise le développement d'outils de composition de modèles. La contribution principale s'appuie sur deux sous-contributions supplémentaires : - Nous proposons des catégories pour classer les techniques de correspondance et les interprétations existantes. - Nous proposons un langage de modélisation spécifique pour la définition de correspondances génériques entre modèles et la définition d'interprétations. Un prototype logiciel a été développé et utilisé dans le cadre du projet MOPCOM-I du pôle de compétitivité Images & Réseaux de la région Bretagne. La validation de la contribution a été démontrée sur un cas d'étude proposé par Technicolor pour l'intégration de librairies existantes dédiées à la gestion d'équipements numériques de diffusion vidéo.

Teaching of model-driven software engineering in a software engineering master program curriculum suits well with the maturity of the students and their ability to understand the concept. Still the education might fail if the teaching is not based on convincing arguments and relations to the research or practice. We are about introducing a model-driven engineering course in our software engineering master curriculum and our goal is to relate the teaching with both research results and industrial practice. In this paper, we describe our approach – how to utilize the research results and how to relate the course to the requirements from industry we have cooperation with.

The Coordination Reform of 2012 requires Norwegian municipalities and regional health authorities to enter into legally binding service agreements. Although several research projects have been undertaken to analyse the implications of this reform, there is no central database where researches can be given access and analyse the service agreements. In this paper we present how we use model-driven software engineering and user-centric design in an initial development of an information system designed to allow researches to access and analyse service agreements. For this project, it was crucial to discuss the requirements of the system with domain-experts at a high level of abstraction in order to elicit feedback so that the development could proceed at a fast pace and in the right direction. Furthermore, given time and resource constraints, we elected to use a model driven approach using automatic code generation coupled with high-productivity frameworks. In this way we were able to create prototypes so that the developers could get fast feedback from the domain-experts and improvements could be implemented with minimal effort.