Flexible Views for View-based Model-driven Development

Modern software development faces the problem of fragmentation of information across heterogeneous artefacts in different modelling and programming languages. In this dissertation, the Vitruvius approach for view-based engineering is presented. Flexible views offer a compact definition of user-specific views on software systems, and can be defined the novel ModelJoin language. The process is supported by a change metamodel for metamodel evolution and change impact analysis

Distributed model validation with Epsilon

Scalable performance is a major challenge with current model management tools. As the size and complexity of models and model management programs increases and the cost of computing falls, one solution for improving performance of model management programs is to perform computations on multiple computers. In this paper, we demonstrate a low-overhead data-parallel approach for distributed model validation in the context of an OCL-like language. Our approach minimises communication costs by exploiting the deterministic structure of programs and can take advantage of multiple cores on each (heterogeneous) machine with highly configurable computational granularity. Our performance evaluation shows that the implementation is extremely low overhead, achieving a speed up of 24.5× with 26 computers over the sequential case, and 122× when utilising all six cores on each computer

Model-Based Engineering of Collaborative Embedded Systems

This Open Access book presents the results of the "Collaborative Embedded Systems" (CrESt) project, aimed at adapting and complementing the methodology underlying modeling techniques developed to cope with the challenges of the dynamic structures of collaborative embedded systems (CESs) based on the SPES development methodology. In order to manage the high complexity of the individual systems and the dynamically formed interaction structures at runtime, advanced and powerful development methods are required that extend the current state of the art in the development of embedded systems and cyber-physical systems. The methodological contributions of the project support the effective and efficient development of CESs in dynamic and uncertain contexts, with special emphasis on the reliability and variability of individual systems and the creation of networks of such systems at runtime. The project was funded by the German Federal Ministry of Education and Research (BMBF), and the case studies are therefore selected from areas that are highly relevant for Germany’s economy (automotive, industrial production, power generation, and robotics). It also supports the digitalization of complex and transformable industrial plants in the context of the German government's "Industry 4.0" initiative, and the project results provide a solid foundation for implementing the German government's high-tech strategy "Innovations for Germany" in the coming years

Ernst Denert Award for Software Engineering 2020

This open access book provides an overview of the dissertations of the eleven nominees for the Ernst Denert Award for Software Engineering in 2020. The prize, kindly sponsored by the Gerlind & Ernst Denert Stiftung, is awarded for excellent work within the discipline of Software Engineering, which includes methods, tools and procedures for better and efficient development of high quality software. An essential requirement for the nominated work is its applicability and usability in industrial practice. The book contains eleven papers that describe the works by Jonathan Brachthäuser (EPFL Lausanne) entitled What You See Is What You Get: Practical Effect Handlers in Capability-Passing Style, Mojdeh Golagha’s (Fortiss, Munich) thesis How to Effectively Reduce Failure Analysis Time?, Nikolay Harutyunyan’s (FAU Erlangen-Nürnberg) work on Open Source Software Governance, Dominic Henze’s (TU Munich) research about Dynamically Scalable Fog Architectures, Anne Hess’s (Fraunhofer IESE, Kaiserslautern) work on Crossing Disciplinary Borders to Improve Requirements Communication, Istvan Koren’s (RWTH Aachen U) thesis DevOpsUse: A Community-Oriented Methodology for Societal Software Engineering, Yannic Noller’s (NU Singapore) work on Hybrid Differential Software Testing, Dominic Steinhofel’s (TU Darmstadt) thesis entitled Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules, Peter Wägemann’s (FAU Erlangen-Nürnberg) work Static Worst-Case Analyses and Their Validation Techniques for Safety-Critical Systems, Michael von Wenckstern’s (RWTH Aachen U) research on Improving the Model-Based Systems Engineering Process, and Franz Zieris’s (FU Berlin) thesis on Understanding How Pair Programming Actually Works in Industry: Mechanisms, Patterns, and Dynamics – which actually won the award. The chapters describe key findings of the respective works, show their relevance and applicability to practice and industrial software engineering projects, and provide additional information and findings that have only been discovered afterwards, e.g. when applying the results in industry. This way, the book is not only interesting to other researchers, but also to industrial software professionals who would like to learn about the application of state-of-the-art methods in their daily work

Ernst Denert Award for Software Engineering 2020

This open access book provides an overview of the dissertations of the eleven nominees for the Ernst Denert Award for Software Engineering in 2020. The prize, kindly sponsored by the Gerlind & Ernst Denert Stiftung, is awarded for excellent work within the discipline of Software Engineering, which includes methods, tools and procedures for better and efficient development of high quality software. An essential requirement for the nominated work is its applicability and usability in industrial practice. The book contains eleven papers that describe the works by Jonathan Brachthäuser (EPFL Lausanne) entitled What You See Is What You Get: Practical Effect Handlers in Capability-Passing Style, Mojdeh Golagha’s (Fortiss, Munich) thesis How to Effectively Reduce Failure Analysis Time?, Nikolay Harutyunyan’s (FAU Erlangen-Nürnberg) work on Open Source Software Governance, Dominic Henze’s (TU Munich) research about Dynamically Scalable Fog Architectures, Anne Hess’s (Fraunhofer IESE, Kaiserslautern) work on Crossing Disciplinary Borders to Improve Requirements Communication, Istvan Koren’s (RWTH Aachen U) thesis DevOpsUse: A Community-Oriented Methodology for Societal Software Engineering, Yannic Noller’s (NU Singapore) work on Hybrid Differential Software Testing, Dominic Steinhofel’s (TU Darmstadt) thesis entitled Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules, Peter Wägemann’s (FAU Erlangen-Nürnberg) work Static Worst-Case Analyses and Their Validation Techniques for Safety-Critical Systems, Michael von Wenckstern’s (RWTH Aachen U) research on Improving the Model-Based Systems Engineering Process, and Franz Zieris’s (FU Berlin) thesis on Understanding How Pair Programming Actually Works in Industry: Mechanisms, Patterns, and Dynamics – which actually won the award. The chapters describe key findings of the respective works, show their relevance and applicability to practice and industrial software engineering projects, and provide additional information and findings that have only been discovered afterwards, e.g. when applying the results in industry. This way, the book is not only interesting to other researchers, but also to industrial software professionals who would like to learn about the application of state-of-the-art methods in their daily work

Definition of a Type System for Generic and Reflective Graph Transformations

This thesis presents the extension of the graph transformation language SDM (Story Driven Modeling) with generic and reflective features as well as the definition of type checking rules for this language. The generic and reflective features aim at improving the reusability and expressiveness of SDM, whereas the type checking rules will ensure the type-safety of graph transformations. This thesis starts with an explanation of the relevant concepts as well as a description of the context in order to provide the reader with a better understanding of our approach. The model driven development of software, today considered as the standard paradigm, is generally based on the use of domain-specific languages such as MATLAB Simulink and Stateflow. To increase the quality, the reliability,and the efficiency of models and the generated code, checking and elimination of detected guideline violations defined in huge catalogues has become an essential, but error-prone and time-consuming task in the development process. The MATE/MAJA projects, which are based on the use of the SDM language, aim at an automation of this task for MATLAB Simulink/Stateflow models. Modeling guidelines can be specified on a very high level of abstraction by means of graph transformations. Moreover, these specifications allow for the generation of guideline checking tools. Unfortunately, most graph transformation languages do not offer appropriate concepts for reuse of specification fragments - a MUST, when we deal with hundreds of guidelines. As a consequence we present an extension of the SDM language which supports the definition of generic rewrite rules and combines them with the reflective programming mechanisms of Java and the model repository interface standard JMI. Reusability and expressiveness are not the only aspects we want to improve. Another fundamental aspect of graph transformations must be ensured: their correctness in order to prevent type errors while executing the transformations. Checking and testing the graph transformations manually would ruin the benefit obtained by the automation of the guideline checking and by the generic and reflective features. Therefore, we propose in this work a type-checking method for graph transformations. We introduce a new notation for rules of inference and define a type system for SDM. We also proposed an algorithm to apply this type system. We illustrate and evaluate both contributions of our work by applying them on running examples. Proposals for other additional SDM features as well as for possible improvements of our type checking open new perspectives and future research to pursue our work

Optimisation of Model Management Programs Using Automated Program Rewriting

Over the last few years, the use of Model Driven Engineering (MDE) in industrial applications has been increasing rapidly. For the use of MDE-based applications at a larger scale, they should scale well in terms of the size of the model, execution time, and memory consumption. Adapting the use of MDE for extensive software landscapes, where the underlying models grow large in size poses various scalability challenges. When model management tools run on pay-as-you-go cloud-based resources, inefficiency and limited scalability incur substantial costs. Hence, there is vested interest from vendors of cloud-based MDE solutions for efficient and scalable model management tools. There are specific high-level languages to develop model management programs tailored for the specific tasks they target. This work aims to improve the performance of certain types of model management programs through static analysis. An approach is proposed for optimising model management tasks, particularly model validation, model-to-model transformation and model comparison over large-scale models. The proposed approach leverages static analysis and automated program rewriting techniques to optimise model management programs over large-scale EMF-based models. This optimisation approach aims to bring efficiency in terms of execution time and memory footprint so that developers can still express model management programs in high-level language and execute these programs efficiently. The program is automatically rewritten to an optimised version (where possible). The optimised program is semantically equivalent to the original program but faster and more efficient to execute. The experiments of this study have shown a significant performance gain in execution time and memory footprint

Parallel and Distributed Execution of Model Management Programs

The engineering process of complex systems involves many stakeholders and development artefacts. Model-Driven Engineering (MDE) is an approach to development which aims to help curtail and better manage this complexity by raising the level of abstraction. In MDE, models are first-class artefacts in the development process. Such models can be used to describe artefacts of arbitrary complexity at various levels of abstraction according to the requirements of their prospective stakeholders. These models come in various sizes and formats and can be thought of more broadly as structured data. Since models are the primary artefacts in MDE, and the goal is to enhance the efficiency of the development process, powerful tools are required to work with such models at an appropriate level of abstraction. Model management tasks – such as querying, validation, comparison, transformation and text generation – are often performed using dedicated languages, with declarative constructs used to improve expressiveness. Despite their semantically constrained nature, the execution engines of these languages rarely capitalize on the optimization opportunities afforded to them. Therefore, working with very large models often leads to poor performance when using MDE tools compared to general-purpose programming languages, which has a detrimental effect on productivity. Given the stagnant single-threaded performance of modern CPUs along with the ubiquity of distributed computing, parallelization of these model management program is a necessity to address some of the scalability concerns surrounding MDE. This thesis demonstrates efficient parallel and distributed execution algorithms for model validation, querying and text generation and evaluates their effectiveness. By fully utilizing the CPUs on 26 hexa-core systems, we were able to improve performance of a complex model validation language by 122x compared to its existing sequential implementation. Up to 11x speedup was achieved with 16 cores for model query and model-to-text transformation tasks

Efficient Management of Large Models via Static Analysis

As the size of software and system models grows, scalability issues in the current generation of model management languages (e.g. transformation, validation) and their supporting tooling become more prominent. With the growing popularity of MDE in larger projects, the efficient management and processing of large models have become critical considerations. To address this challenge, execution engines of model management programs need to become more efficient in their use of system resources. Effective resource management is essential not only for minimizing execution costs but also for optimizing resource usage, particularly in scenarios where resources are billed based on usage patterns. This thesis addresses this challenge by presenting an approach to enhance the efficiency of model management programs, which play a pivotal role in querying and manipulating models. This approach focuses on enabling execution engines to load only the necessary parts of models, minimizing the overhead associated with loading unnecessary model elements into memory. Through the utilization of in-advance knowledge obtained from static analysis of model management programs, execution engines can identify, load, and process only the model elements essential for execution. Furthermore, the approach ensures that elements are disposed of from memory when no longer needed, optimizing both memory utilization and processing time. Experimental evaluations demonstrate that our approach empowers model management programs to process larger models faster with a reduced memory footprint compared to current state-of-the-art approaches

Contracts-based Control Integration into Software Systems

International audienceAmong the different techniques that are used to design self-adaptive software systems, control theory allows one to design an adaptation policy whose properties, such as stability and accuracy, can be formally guaranteed under certain assumptions. However, in the case of software systems, the integration of these controllers to build complete feedback control loops is manual. More importantly it requires an extensive handcrafting of non-trivial implementation code. This may lead to inconsistencies and instabilities as no systematic and automated assurance can be obtained on the fact that the initial assumptions for the designed controller still hold in the resulting system.In this chapter, we rely on the principles of design-by-contract to ensure the correction and robustness of a self-adaptive software system built using feedback control loops. Our solution raises the level of abstraction upon which the loops are specified by allowing one to define and automatically verify system-level properties organized in contracts. They cover behavioral, structural and temporal architectural constraints as well as explicit interaction. These contracts are complemented by a first-class support for systematic fault handling. As a result, assumptions about the system operation conditions become more explicit and verifiable in a systematic way