Model driven product line engineering : core asset and process implications

Reuse is at the heart of major improvements in productivity and quality in Software Engineering. Both Model Driven Engineering (MDE) and Software Product Line Engineering (SPLE) are software development paradigms that promote reuse. Specifically, they promote systematic reuse and a departure from craftsmanship towards an industrialization of the software development process. MDE and SPLE have established their benefits separately. Their combination, here called Model Driven Product Line Engineering (MDPLE), gathers together the advantages of both. Nevertheless, this blending requires MDE to be recasted in SPLE terms. This has implications on both the core assets and the software development process. The challenges are twofold: (i) models become central core assets from which products are obtained and (ii) the software development process needs to cater for the changes that SPLE and MDE introduce. This dissertation proposes a solution to the first challenge following a feature oriented approach, with an emphasis on reuse and early detection of inconsistencies. The second part is dedicated to assembly processes, a clear example of the complexity MDPLE introduces in software development processes. This work advocates for a new discipline inside the general software development process, i.e., the Assembly Plan Management, which raises the abstraction level and increases reuse in such processes. Different case studies illustrate the presented ideas.This work was hosted by the University of the Basque Country (Faculty of Computer Sciences). The author enjoyed a doctoral grant from the Basque Goverment under the “Researchers Training Program” during the years 2005 to 2009. The work was was co-supported by the Spanish Ministry of Education, and the European Social Fund under contracts WAPO (TIN2005-05610) and MODELINE (TIN2008-06507-C02-01)

Consistency-by-Construction Techniques for Software Models and Model Transformations

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

Pattern-based refactoring in model-driven engineering

L’ingénierie dirigée par les modèles (IDM) est un paradigme du génie logiciel qui utilise les modèles comme concepts de premier ordre à partir desquels la validation, le code, les tests et la documentation sont dérivés. Ce paradigme met en jeu divers artefacts tels que les modèles, les méta-modèles ou les programmes de transformation des modèles. Dans un contexte industriel, ces artefacts sont de plus en plus complexes. En particulier, leur maintenance demande beaucoup de temps et de ressources. Afin de réduire la complexité des artefacts et le coût de leur maintenance, de nombreux chercheurs se sont intéressés au refactoring de ces artefacts pour améliorer leur qualité. Dans cette thèse, nous proposons d’étudier le refactoring dans l’IDM dans sa globalité, par son application à ces différents artefacts. Dans un premier temps, nous utilisons des patrons de conception spécifiques, comme une connaissance a priori, appliqués aux transformations de modèles comme un véhicule pour le refactoring. Nous procédons d’abord par une phase de détection des patrons de conception avec différentes formes et différents niveaux de complétude. Les occurrences détectées forment ainsi des opportunités de refactoring qui seront exploitées pour aboutir à des formes plus souhaitables et/ou plus complètes de ces patrons de conceptions. Dans le cas d’absence de connaissance a priori, comme les patrons de conception, nous proposons une approche basée sur la programmation génétique, pour apprendre des règles de transformations, capables de détecter des opportunités de refactoring et de les corriger. Comme alternative à la connaissance disponible a priori, l’approche utilise des exemples de paires d’artefacts d’avant et d’après le refactoring, pour ainsi apprendre les règles de refactoring. Nous illustrons cette approche sur le refactoring de modèles.Model-Driven Engineering (MDE) is a software engineering paradigm that uses models as first-class concepts from which validation, code, testing, and documentation are derived. This paradigm involves various artifacts such as models, meta-models, or model transformation programs. In an industrial context, these artifacts are increasingly complex. In particular, their maintenance is time and resources consuming. In order to reduce the complexity of artifacts and the cost of their maintenance, many researchers have been interested in refactoring these artifacts to improve their quality. In this thesis, we propose to study refactoring in MDE holistically, by its application to these different artifacts. First, we use specific design patterns, as an example of prior knowledge, applied to model transformations to enable refactoring. We first proceed with a detecting phase of design patterns, with different forms and levels of completeness. The detected occurrences thus form refactoring opportunities that will be exploited to implement more desirable and/or more complete forms of these design patterns. In the absence of prior knowledge, such as design patterns, we propose an approach based on genetic programming, to learn transformation rules, capable of detecting refactoring opportunities and correcting them. As an alternative to prior knowledge, our approach uses examples of pairs of artifacts before and after refactoring, in order to learn refactoring rules. We illustrate this approach on model refactoring

Managing Consistency of Business Process Models across Abstraction Levels

Process models support the transition from business requirements to IT implementations. An organization that adopts process modeling often maintain several co-existing models of the same business process. These models target different abstraction levels and stakeholder perspectives. Maintaining consistency among these models has become a major challenge for such an organization. For instance, propagating changes requires identifying tacit correspondences among the models, which may be only in the memories of their original creators or may be lost entirely. Although different tools target specific needs of different roles, we lack appropriate support for checking whether related models maintained by different groups of specialists are still consistent after independent editing. As a result, typical consistency management tasks such as tracing, differencing, comparing, refactoring, merging, conformance checking, change notification, and versioning are frequently done manually, which is time-consuming and error-prone. This thesis presents the Shared Model, a framework designed to improve support for consistency management and impact analysis in process modeling. The framework is designed as a result of a comprehensive industrial study that elicited typical correspondence patterns between Business and IT process models and the meaning of consistency between them. The framework encompasses three major techniques and contributions: 1) matching heuristics to automatically discover complex correspondences patterns among the models, and to maintain traceability among model parts---elements and fragments; 2) a generator of edit operations to compute the difference between process models; 3) a process model synchronizer, capable of consistently propagating changes made to any model to its counterpart. We evaluated the Shared Model experimentally. The evaluation shows that the framework can consistently synchronize Business and IT views related by correspondence patterns, after non-simultaneous independent editing

Solving heterogeneity for a successful service market

Diese Dissertation ist im Kontext eines neuen Paradigmas im Software Engineering mit dem Namen On-The-Fly Computing entstanden. OTF Computing basiert auf der Idee von spezialisierten On-The-Fly Märkten. OTF Märkte haben unterschiedliche Eigenschaften und die Marktakteure in diesen Märkten benutzen verschiedene Modellierungstechniken für das Service Engineering. Diese Unterschiede resultieren in Heterogenität und erschweren deshalb die Ausführung von automatisierten Marktoperationen, da Servicebeschreibungen nicht automatisch miteinander verglichen werden können. Für das beschriebene Problem bietet diese Dissertation eine Lösung um einen erfolgreichen OTF Markt zu ermöglichen. Für die Vergleichbarkeit von Servicebeschreibungen in einem OTF Markt wird eine formale Zwischenrepräsentation (Kernsprache) eingeführt. Die Marktoperationen werden auf Basis der Kernsprache definiert, die die optimale Ausführung der automatisierten Marktoperationen in einem OTF Markt unterstützt. Der erste Beitrag dieser Dissertation ist der Ansatz Language Optimizer (LOpt). LOpt nutzt als Basis eine Kernsprache, die strukturelle, verhaltensbezogene und nicht-funktionale Serviceeigenschaften beinhaltet. LOpt konfiguriert diese Sprache basierend auf formalisierten Markteigenschaften und einer Wissensbasis mit Konfigurationsexpertise, um eine optimale Kernsprache zur Servicespezifikation im jeweiligen OTF Markt zu erstellen. Der zweite Beitrag dieser Dissertation ist die Anwendung des Model Transformation By-Example Ansatzes um den Marktakteuren ohne Expertise im Sprachdesign Transformationen von ihren proprietären Sprachen in die optimale Kernsprache zu ermöglichen. Der beschriebene Ansatz generiert Transformationen auf Basis von Beispielabbildungen zwischen Servicebeschreibungen zweier Sprachen. Dabei wird die Idee genetischer Algorithmen angewendet.This PhD thesis is written in the context of a new software development paradigm called On-The-Fly Computing. It is based on the idea of specialized service markets called On-The-Fly (OTF) markets. OTF markets have different properties and their participants use different modeling techniques to perform the activity of service engineering. Such differences result in heterogeneity in OTF markets and complicate the execution of automated market operations like service matching as service specifications cannot be automatically compared with each other. This PhD thesis proposes a solution to cope with the mentioned heterogeneity to foster the success of OTF markets and the OTF Computing paradigm. In order to achieve the comparability of specifications in an OTF market, a formal intermediate representation called core language is introduced. Automated market operations are defined on a core language that optimally supports the execution of these operations in this market. The first contribution of this PhD thesis is the approach language Optimizer (LOpt), which supports the systematic design of a service specification language optimal for the execution of automated market operations in an OTF market. LOpt uses a comprehensive core language covering various structural, behavioral, and non-functional service properties. LOpt performs a configuration of this language based on formalized market properties and a knowledge base containing the configuration expertise. The second contribution of this PhD thesis is the application of the Model Transformations By-Example technique to define transformations from proprietary specification languages of market actors to the optimal core language. The approach generates transformations based on example mappings between concrete specifications in both languages given by market actors. ...by Svetlana Arifulina, M.Sc. ; Thesis Supervisors: Prof. Dr. Gregor Engels and Jun. Prof. Dr. Heiko HamannTag der Verteidigung: 08.12.2016Universität Paderborn, Univ., Dissertation, 201

A Functional, Comprehensive and Extensible Multi-Platform Querying and Transformation Approach

This thesis is about a new model querying and transformation approach called FunnyQT which is realized as a set of APIs and embedded domain-specific languages (DSLs) in the JVM-based functional Lisp-dialect Clojure. Founded on a powerful model management API, FunnyQT provides querying services such as comprehensions, quantified expressions, regular path expressions, logic-based, relational model querying, and pattern matching. On the transformation side, it supports the definition of unidirectional model-to-model transformations, of in-place transformations, it supports defining bidirectional transformations, and it supports a new kind of co-evolution transformations that allow for evolving a model together with its metamodel simultaneously. Several properties make FunnyQT unique. Foremost, it is just a Clojure library, thus, FunnyQT queries and transformations are Clojure programs. However, most higher-level services are provided as task-oriented embedded DSLs which use Clojure's powerful macro-system to support the user with tailor-made language constructs important for the task at hand. Since queries and transformations are just Clojure programs, they may use any Clojure or Java library for their own purpose, e.g., they may use some templating library for defining model-to-text transformations. Conversely, like every Clojure program, FunnyQT queries and transformations compile to normal JVM byte-code and can easily be called from other JVM languages. Furthermore, FunnyQT is platform-independent and designed with extensibility in mind. By default, it supports the Eclipse Modeling Framework and JGraLab, and support for other modeling frameworks can be added with minimal effort and without having to modify the respective framework's classes or FunnyQT itself. Lastly, because FunnyQT is embedded in a functional language, it has a functional emphasis itself. Every query and every transformation compiles to a function which can be passed around, given to higher-order functions, or be parametrized with other functions

Fundamental Approaches to Software Engineering

This open access book constitutes the proceedings of the 23rd International Conference on Fundamental Approaches to Software Engineering, FASE 2020, which took place in Dublin, Ireland, in April 2020, and was held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020. The 23 full papers, 1 tool paper and 6 testing competition papers presented in this volume were carefully reviewed and selected from 81 submissions. The papers cover topics such as requirements engineering, software architectures, specification, software quality, validation, verification of functional and non-functional properties, model-driven development and model transformation, software processes, security and software evolution