48 research outputs found

    Evaluating Model Differencing for the Consistency Preservation of State-based Views

    Get PDF
    While developers and users of modern software systems usually only need to interact with a specific part of the system at a time, they are hindered by the ever-increasing complexity of the entire system. Views are projections of underlying models and can be employed to abstract from that complexity. When a view is modified, the changes must be propagated back into the underlying model without overriding simultaneous modifications. Hence, the view needs to provide a fine-grained sequence of changes to update the model minimally invasively. Such fine-grained changes are often unavailable for views that integrate with existing workflows and tools. To this end, model differencing approaches can be leveraged to compare two states of a view and derive an estimated change sequence. However, these model differencing approaches are not intended to operate with views, as their correctness is judged solely by comparing the input models. For views, the changes are derived from the view states, but the correctness depends on the underlying model. This work introduces a refined notion of correctness for change sequences in the context of model-view consistency. Furthermore, we evaluate state-of-the-art model differencing regarding model-view consistency. Our results show that model differencing largely performs very well. However, incorrect change sequences were derived for two common refactoring operation types, leading to an incorrect model state. These types can be easily reproduced and are likely to occur in practice. By considering our change sequence properties in the view type design, incorrect change sequences can be detected and semi-automatically repaired to prevent such incorrect model states

    Mining domain-specific edit operations from model repositories with applications to semantic lifting of model differences and change profiling

    Get PDF
    Model transformations are central to model-driven software development. Applications of model transformations include creating models, handling model co-evolution, model merging, and understanding model evolution. In the past, various (semi-) automatic approaches to derive model transformations from meta-models or from examples have been proposed. These approaches require time-consuming handcrafting or the recording of concrete examples, or they are unable to derive complex transformations. We propose a novel unsupervised approach, called Ockham, which is able to learn edit operations from model histories in model repositories. Ockham is based on the idea that meaningful domain-specifc edit operations are the ones that compress the model diferences. It employs frequent subgraph mining to discover frequent structures in model diference graphs. We evaluate our approach in two controlled experiments and one real-world case study of a large-scale industrial model-driven architecture project in the railway domain. We found that our approach is able to discover frequent edit operations that have actually been applied before. Furthermore, Ockham is able to extract edit operations that are meaningful—in the sense of explaining model diferences through the edit operations they comprise—to practitioners in an industrial setting. We also discuss use cases (i.e., semantic lifting of model diferences and change profles) for the discovered edit operations in this industrial setting. We fnd that the edit operations discovered by Ockham can be used to better understand and simulate the evolution of models

    Commit-Based Continuous Integration of Performance Models

    Get PDF

    Code merging using transformations and member identity

    Get PDF
    Conventionally, merging code files is performed using generic line-based merging algorithms (e.g., diff3) that are unaware of the syntax and semantics of the programming language, outputting conflicts that could be avoided. Structured and semistructured merging techniques are capable of reducing conflicts, but they still suffer from false positives (conflicts that could be avoided) and false negatives (conflicts that go undetected). We propose a merging technique that combines semistructured and transformation-based strategies, where conflict detection is aware of semantic aspects of the programming language. We extract transformations of two branches and apply a merging process that analyzes incompatible transformations, avoiding false positives and false negatives that occur in existing approaches. We developed Jaid, a prototype merging tool for Java based on the assumption that structural code elements evolve with attached UUIDs (representing identity). We performed an early experiment with 63 merge scenarios from two open-source projects to test the technique and assess its feasibility.info:eu-repo/semantics/publishedVersio

    Derivation of Change Sequences from State-Based File Differences for Delta-Based Model Consistency

    Get PDF
    In der sichtenbasierten Software-Entwicklung ist es möglich, dass mehrere Sichten das gleiche Konzept abbilden, wodurch Sichten redundante oder abhängige Informationen darstellen können. Es ist essenziell, diese individuellen Sichten synchron zu halten, um Inkonsistenzen im System zu vermeiden. In Ansätzen mit einem Single Underlying Model (SUM) werden Inkonsistenzen vermieden, indem das SUM als zentrale und einzige Informationsquelle genutzt wird, von welcher Sichten projiziert werden. Um Sichten mit dem SUM zu synchronisieren, wird in den meisten Fällen eine deltabasierte Konsistenzhaltung verwendet. Diese nutzt feingranulare Änderungssequenzen, welche von den einzelnen Sichten bereitgestellt werden müssen, um das SUM inkrementell zu aktualisieren. In realen Anwendungsfällen ist die Funktionalität zur Bereitstellung dieser Änderungssequenzen jedoch selten verfügbar. Stattdessen werden nur zustandsbasierte Änderungen persistiert. Es ist insofern wünschenswert Sichten, welche nur zustandsbasierte Änderungen bereitstellen, in deltabasierter Konsistenzhaltung zu unterstützen. Dies kann erreicht werden, indem die feingranularen Änderungssequenzen von den zustandsbasierten Änderungen abgeleitet werden. In dieser Arbeit wird die Qualität von abgeleiteten Änderungssequenzen im Kontext von Modellkonsistenzhaltung evaluiert. Um eine solche Sequenz abzuleiten, müssen übereinstimmende Elemente aus den verglichenen Modellen identifiziert und deren Unterschiede bestimmt werden. Um übereinstimmenden Elemente zu identifizieren, nutzen wir zwei Strategien. Bei der einen Strategie werden übereinstimmende Elemente anhand ihres eindeutigen Bezeichners erkannt. Bei der anderen Strategie wird eine Ähnlichkeitsmetrik basierend auf den Eigenschaften der Elemente genutzt. Als Evaluationsgrundlage werden verschiedene Testszenarien erstellt. Für jeden Test wird eine initiale und eine geänderte Version von sowohl einem UML-Klassendiagramm als auch Java-Code bereitgestellt. Wir nutzen die verschiedenen Strategien, um Änderungssequenzen basierend auf den zustandsbasierten Änderungen der UML-Sicht abzuleiten, geben diese an das SUM weiter und untersuchen die Ergebnisse in beiden Domänen. Die Ergebnisse zeigen, dass die Strategie, welche eindeutige Bezeichner nutzt, in fast allen betrachteten Fällen (97 %) die korrekte Änderungssequenz liefert. Bei der Nutzung der ähnlichkeitsbasierten Strategie können wir zwei wiederkehrende Fehlermuster identifizieren. Bezüglich dieser Probleme stellen wir eine erweiterte ähnlichkeitsbasierte Strategie vor, welche in der Lage ist, die Auftrittshäufigkeit der Fehlermuster zu reduzieren ohne die Ausführungsgeschwindigkeit signifikant zu beeinflussen

    Model Transformation Testing and Debugging: A Survey

    Get PDF
    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

    Automatically correcting syntactic and semantic errors in ATL transformations using multi-objective optimization

    Full text link
    L’ingénierie dirigée par les modèles (EDM) est un paradigme de développement logiciel qui promeut l’utilisation de modèles en tant qu’artefacts de première plan et de processus automatisés pour en dériver d’autres artefacts tels que le code, la documentation et les cas de test. La transformation de modèle est un élément important de l’EDM puisqu’elle permet de manipuler les représentations abstraites que sont les modèles. Les transformations de modèles, comme d’autres programmes, sont sujettes à la fois à des erreurs syntaxiques et sémantiques. La correction de ces erreurs est difficile et chronophage, car les transformations dépendent du langage de transformation comme ATL et des langages de modélisation dans lesquels sont exprimés les modèles en entrée et en sortie. Les travaux existants sur la réparation des transformations ciblent les erreurs syntaxiques ou sémantiques, une erreur à la fois, et définissent manuellement des patrons de correctifs. L’objectif principal de notre recherche est de proposer un cadre générique pour corriger automatiquement de multiples erreurs syntaxiques et sémantiques. Afin d’atteindre cet objectif, nous reformulons la réparation des transformations de modèles comme un problème d’optimisation multiobjectif et le résolvons au moyen d’algorithmes évolutionnaires. Pour adapter le cadre aux deux catégories d’erreurs, nous utilisons différents types d’objectifs et des stratégies sophistiquées pour guider l’exploration de l’espace des solutions.Model-driven engineering (MDE) is a software development paradigm that promotes the use of models as first-class artifacts and automated processes to derive other artefacts from them such as code, documentation and test cases. Model transformation is an important element of MDE since it allows to manipulate the abstract representations that are models. Model transformations, as other programs are subjects to both syntactic and semantic errors. Fixing those errors is difficult and time consuming as the transformations depend on the transformation language such as ATL, and modeling languages in which input and output models are expressed. Existing work on transformation repair targets either syntactic or semantic errors, one error at a time, and define patch templates manually. The main goal of our research is to propose a generic framework to fix multiple syntactic and semantic errors automatically. In order to achieve this goal, we reformulate the repair of model transformations as a multi-objective optimization problem and solve it by means of evolutionary algorithms. To adapt the framework to the two categories of errors, we use different types of objectives and sophisticated strategies to guide the search

    Selective Traceability for Rule-Based Model-to-Model Transformations

    Get PDF
    Model-to-model (M2M) transformation is a key ingredient in a typical Model-Driven Engineering workflow and there are several tailored high-level interpreted languages for capturing and executing such transformations. While these languages enable the specification of concise transformations through task-specific constructs (rules/mappings, bindings), their use can pose scalability challenges when it comes to very large models. In this paper, we present an architecture for optimising the execution of model-to-model transformations written in such a language, by leveraging static analysis and automated program rewriting techniques. We demonstrate how static analysis and dependency information between rules can be used to reduce the size of the transformation trace and to optimise certain classes of transformations. Finally, we detail the performance benefits that can be delivered by this form of optimisation, through a series of benchmarks performed with an existing transformation language (Epsilon Transformation Language - ETL) and EMF-based models. Our experiments have shown considerable performance improvements compared to the existing ETL execution engine, without sacrificing any features of the language

    Towards the Co-Evolution of Models and Artefacts of Industrial Tools Through External Views

    Get PDF
    Modern software systems comprise multiple models. When these models are changed, interdependent models must be evolved accordingly. Manually managing this co-evolution of models is tedious and error-prone. Moreover, other interdependent artefacts, such as persisted states of industrial software applications, must co-evolve accordingly. Automated consistency preservation allows for efficiently managing the co-evolution of models. However, while state-of-the-art approaches operate delta-based, typical software applications persist changes state-based without conforming to explicit metamodels. Additionally, software applications may persist changes infrequently, even though interdependent models might be concurrently modified. As such, current approaches are insufficient for artefacts of industrial tools. To address these issues, we propose an approach for the co-evolution of models and artefacts of industrial tools by treating these artefacts as external views on the models
    corecore