Being able to maintain the consistency between various different, but related models is an important enabler for model-based software engineering. Research on bidirectional transformations (bx) addresses this issue and has resulted in various and diverse formal foundations, approaches, tools, and application scenarios. In order to understand and compare different bx approaches, we have developed benchmarx, a benchmarking framework specifically for bx. Up until now, however, benchmarx has been limited to one-sided model synchronisation tasks, where only one of two related models can be changed at a time. As the more general case of concurrent model synchronisation is crucial for many practical applications of bx, we propose in this paper an extension to our bx benchmarking framework to support concurrent model synchronisation tasks, where two related models can both be changed concurrently and must then be synchronised to restore consistency. To evaluate our new extensions we present an update of an existing benchmarx example, families-to-persons, to include new test cases requiring concurrent synchronisation. We discuss some of the challenges involved in defining such a benchmark including handling conflicts, defining the expected behavior of the bx tool under test, and providing bx tools with enough freedom to reject some of the changes to either model. We also present a solution to the updated families-to-persons benchmarx example implemented using BXtend as a bx tool.

Model transformations are crucial for model-driven development. Many different languages exist that allow for the description of mappings between different metamodels. Over the past few years, these languages and accompanying tools have matured significantly, but they still suffer from a common problem as they lack expressiveness. In this paper, we present NICE, an expression language for model transformations that has been integrated in our bidirectional model transformation language BXtendDSL, which overcomes this dilemma. NICE is a modular, reusable, and adaptable language that compiles to plain Java code and is easy to use.

This paper investigates the comparative effectiveness of model-to-model transformations generated by an LLM based upon user prompts versus those created with dedicated model transformation languages, using a standard benchmark. The emergence of Generative AI offers a novel approach, allowing developers to specify transformations in natural language rather than learning specialized languages. However, our findings suggest that, in its current state, generative AI does not yet pose a threat to dedicated model transformation languages. While AI-assisted approaches promise to provide flexibility and accessibility, dedicated model transformation languages still offer structured advantages crucial for complex transformations, especially when bidirectionality and incrementality are mandatory requirements. This research contributes to the ongoing discourse on the role of AI in software engineering, highlighting its potential and current limitations in enhancing model transformation processes.

Low-code development (LCD) platforms promise to empower citizen developers to define core domain models and rules for business applications. However, as domain rules grow complex, LCD platforms may fail to do so effectively. Generative AI, driven by large language models (LLMs), offers source code generation from natural language but suffers from its non-deterministic black-box nature and limited explainability. Therefore, rather than having LLMs generate entire applications from single prompts, we advocate for a white-box approach allowing citizen developers to specify domain models semi-formally, attaching constraints and operations as natural language annotations. These annotations are fed incrementally into an LLM contextualized with the generated application stub. This results in deterministic and better explainable generation of static application components, while offering citizen developers an appropriate level of abstraction. We report on a case study in manufacturing execution systems, where the implementation of the approach provides first insights.

This paper presents a solution to the Asymmetric and Directed Bidirectional Transformation for Container Orchestrations Case at TTC 2023 using BXtendDSL. BXtendDSL is hybrid language for bidirectional and incremental model transformations, allowing transformation developers to specify model transformations on the declarative and imperative level, allowing for maximum expressive power to tackle all possible transformation problems.

This paper presents a solution to the Case at TTC 2023 using BX-tendDSL. BXtendDSL is hybrid language for bidirectional and incremental model transformations, allowing transformation developers to specify model transformations on the declarative and imperative level, allowing for maximum expressive power to tackle all possible transformation problems.

Model transformations are a major driving force behind model-driven software development (MDSD), when typically an initial model is refined throughout the development process over several steps until eventually code is generated. Strict forward engineering processes require unidirectional model transformations, where an initial requirements model is refined through various model transformation steps. Roundtrip engineering on the other hand calls for bidirectional and incremental model transformations instead, where changes may be propagated back and forth while retaining manual modifications to the models involved. In this paper, we present BXtendDSL, a framework for bidirectional incremental model transformations. BXtendDSL combines two languages: a light-weight declarative language for defining correspondences between model elements, and an imperative language that allows to implement behavior that cannot be specified in the declarative language. We demonstrate our approach by a case study. We also include an evaluation of this case study that demonstrates conciseness, expressiveness, and scalability of our hybrid approach.

Bidirectional transformations have been studied in a wide range of application domains. In model-driven software engineering, they are required for roundtrip engineering processes. We present a pragmatic approach to engineering bidirectional model transformations that assists transformation developers by domain-specific languages, frameworks, and code generators and provides for conciseness, expressiveness, and scalability. We also discuss different variants of transformation development processes as well as their advantages and drawbacks.

Model-driven software engineering (MDSE) as well as software product line engineering (SPLE) achieve productivity gains by raising the level of abstraction and fostering organized reuse. Consequently, the integrating discipline model-driven software product line engineering (MDSPLE) aims at combining the best of both worlds by creating multi-variant models which are (automatically) configured into single-variant models which are in turn adapted further (if required). Inherently complex multi-variant models call for urgently needed tools providing support for editing multi-variant models. In this paper, we present a framework for projectional multi-variant editors which make complexity manageable using a user-friendly representation. At all times, a domain engineer is aware of editing a multi-variant model which is necessary to assess the impact of changes on all model variants. Supporting a clear separation of product space (domain model) and variant space (variability annotations), our projectional multi-variant editors provide a novel approach to representing variability information which is displayed non-intrusively. Furthermore, the domain engineer may employ a projectional multi-variant editor to adapt the representation of the multi-variant domain model in a flexible way, according to the current focus of interest.

Model-driven software development (MDSD) heavily relies on model transformations. While in a strict forward engineering process unidirectional transformations are used, bidirectional transformations are crucial as soon as roundtrip engineering comes into play. In this paper, we present a hybrid language specifically designed to describe bidirectional model transformations. From a declarative transformation specification code is generated which uses our framework for bidirectional and incremental model transformations. A sophisticated code generation mechanism allows for hooking into the generated transformation code at the imperative level to supply behavior that cannot be expressed declaratively. A thorough evaluation demonstrates conciseness, expressiveness, and scalability of our approach.

Bidirectional incremental model transformations are crucial for supporting round-trip engineering in model-driven software development. A variety of domain-specific languages (DSLs) have been proposed for the declarative specification of bidirectional transformations. Unfortunately, previous proposals fail to provide the expressiveness required for solving practically relevant bidirectional transformation problems. To address this shortcoming, we propose a layered approach: On the declarative level, a bidirectional transformation is specified concisely in a small and light-weight external DSL. From this specification, code is generarated into an object-oriented framework, on top of which the behavior of the transformation may be complemented and adapted in an imperative internal DSL. An evaluation with the help of a well-known transformation case demonstrates that this layered hybrid approach is both concise and expressive, and also scalable.

Model-driven software product line engineering (MDSPLE) combines the productivity gains achieved by model-driven software engineering and software product line engineering. In MDSPLE, multi-variant models are created in domain engineering which are configured into single-variant models that are adapted further (if required) in application engineering. Since multi-variant models are inherently complex, tools are urgently needed which provide specific support for editing multi-variant models. In this paper, we present a framework for projectional multi-variant editors which do not hide complexity but make it manageable by a user-friendly representation. At all times, a domain engineer is aware of editing a multi-variant model which is necessary to assess the impact of changes on all model variants. Projectional multi-variant editors provide a novel approach to representing variability information which is displayed non-intrusively and supports a clear separation of the product space (the domain model) from the variant space (variability annotations). Furthermore, the domain engineer may employ a projectional multi-variant editor to adapt the representation of the multi-variant domain model in a flexible way, according to the current focus of interest.

Bidirectional transformations (bx) are relevant for a wide range of application domains. While bx problems may be solved with unidirectional languages and tools, maintaining separate implementations of forward and backward synchronizers with mutually consistent behavior can be difficult, laborious, and error-prone. To address the challenges involved in handling bx problems, dedicated languages and tools for bx have been developed. Due to their heterogeneity, however, the numerous and diverse approaches to bx are difficult to compare, with the consequence that fundamental differences and similarities are not yet well understood. This motivates the need for suitable benchmarks that facilitate the comparison of bx approaches. This paper provides a comprehensive treatment of benchmarking bx, covering theory, implementation, application, and assessment. At the level of theory, we introduce a conceptual framework that defines and classifies architectures of bx tools. At the level of implementation, we describe Benchmarx, an infrastructure for benchmarking bx tools which is based on the conceptual framework. At the level of application, we report on a wide variety of solutions to the well-known Families-to-Persons benchmark, which were developed and compared with the help of Benchmarx. At the level of assessment, we reflect on the usefulness of the Benchmarx approach to benchmarking bx, based on the experiences gained from the Families-to-Persons benchmark.

: Model transformation are the core of model-driven software engineering. Typically an initial model is refined throughout the development process using model transformations to derive subsequent models until eventually code is generated. In round-trip engineering processes, these model transformations are performed not only in forward, but also in backward direction. To this end, bidirectional transformation languages provide a single transformation definition for both directions. This paper evaluates the transformation languages QVT Relations (QVT-R) which allows to specify incremental bidirectional transformations declaratively at a high level of abstraction and BXtend - a framework for procedural specification of both forward and backward transformation in a single rule set. Both languages have been used to implement the AST2Dag transformation example. The benchmarx framework was used for a quantitative and qualitative evaluation of the obtained results.

The Eclipse Modeling Framework (EMF) constitutes a popular ecosystem for model-driven development. In the technological space of EMF, a wide variety of model-based tools have been developed, including tools for transforming and editing models. Model editors may display models in different representations such as diagrams, trees, or tables. Due to the increasing popularity of human-readable textual syntax, there is a growing demand for textual model editors. In EMF, this demand is currently satisfied by syntax-based editors which persist models as text files. In contrast, we propose a projectional editor that persists models natively as EMF models; the textual representation constitutes a projection of the underlying EMF model. Projectional editing does not only exclude syntactic errors; in addition, maintaining the underlying model persistently facilitates tool integration. The projectional editor is generic; it may be instantiated for different modeling languages by declarative definitions of their concrete syntax. So far, model editors for subsets of Java and ALF (Action Language for Foundational UML) have been built to demonstrate the feasibility of the generic approach.