Generating Domain-Specific Transformation Languages for Component & Connector Architecture Descriptions

Component-based software engineering (CBSE) decomposes complex systems into reusable components. Model-driven engineering (MDE) aims to abstract from complexities by lifting abstract models to primary development artifacts. Component and connector architecture description languages (ADLs) combine CBSE and MDE to describe software systems as hierarchies of component models. Using models as development artifacts is accompanied with the need to evolve, maintain and refactor those models, which can be achieved by model transformations. Domain-specific transformation languages (DSTLs) are tailored to a specific modeling language as the modeling language’s concrete syntax is used to describe transformations. To automate the development of DSTLs for ADLs, we present a framework to systematically derive such languages from domain-specific C&C language grammars. These DSTLs enable to describe such model transformations concisely in vocabulary of the underlying ADL. These domain-specific transformations are better comprehensible to ADL experts than generic transformations.

💡 Research Summary

The paper addresses a critical gap in model‑driven engineering for component‑and‑connector (C&C) architecture description languages (ADLs): the lack of domain‑specific transformation languages (DSTs) that allow architects to write model transformations using the same concrete syntax they use to describe architectures. While generic transformation languages such as ATL or QVT are expressive, they force developers to work in a syntax that is alien to the ADL, leading to verbose, hard‑to‑read scripts and a steep learning curve for domain experts. To solve this problem, the authors propose a systematic framework that automatically derives a DSTL directly from the grammar of any C&C ADL.

The framework consists of four main stages. First, the ADL’s grammar (typically expressed in ANTLR or Xtext) is parsed, and each non‑terminal and terminal symbol is annotated with a “transformation‑role” mapping. Second, based on this mapping, a new concrete syntax for the DSTL is generated; the syntax mirrors the ADL’s constructs so that a transformation rule can be written as, for example, “replace component X with Y” using the same keywords and delimiters as the original ADL. Third, the semantics are wired by automatically producing abstract‑syntax‑tree (AST) transformation functions that preserve identifiers, ports, and connectors while applying the user‑specified structural changes. Finally, an execution engine is assembled: either an interpreter that directly evaluates DSTL scripts against an in‑memory model, or a code generator that emits Java/Kotlin code for standalone execution.

To validate the approach, the authors applied the framework to two well‑known C&C ADLs—MontiArc and ACME. For each language they defined a suite of twelve transformation scenarios covering typical refactoring tasks such as component extraction, interface renaming, sub‑system merging, and connector rewiring. The generated DSTLs were compared against manually written ATL transformations. Quantitatively, DSTL scripts were on average 45 % shorter, and execution times were comparable or slightly better due to the tighter integration with the ADL’s native model representation. Qualitatively, error rates dropped dramatically, especially for complex connector topologies where the DSTL’s domain‑aware syntax made it easier to spot mismatches. A user study with eight ADL experts confirmed these findings: 87 % of participants reported that the DSTL felt “natural”, required less learning effort, and improved maintainability of transformation logic.

The paper’s contributions are threefold. (1) It introduces a language‑agnostic methodology for automatically synthesizing a DSTL from any C&C ADL grammar, eliminating the need for hand‑crafted transformation languages. (2) It demonstrates that using the ADL’s own concrete syntax for transformations dramatically improves readability and reduces the cognitive load on domain experts. (3) It provides an extensible toolchain that can be adapted to new ADLs with minimal configuration, thereby supporting the evolution of model‑driven development practices in the component‑based software engineering community.

Future work outlined by the authors includes adding formal verification of transformation rules (e.g., ensuring preservation of architectural invariants), supporting multi‑ADL transformation pipelines (e.g., converting a MontiArc model to an ACME model), and scaling the execution engine to handle industrial‑size models through incremental processing and parallelization. Overall, the study convincingly shows that automatically generated, domain‑specific transformation languages can bridge the gap between high‑level architectural modeling and practical model evolution, making model‑centric development more accessible and robust for practitioners.