Code Generator Composition for Model-Driven Engineering of Robotics Component & Connector Systems

Engineering software for robotics applications requires multidomain and application-specific solutions. Model-driven engineering and modeling language integration provide means for developing specialized, yet reusable models of robotics software architectures. Code generators transform these platform independent models into executable code specific to robotic platforms. Generative software engineering for multidomain applications requires not only the integration of modeling languages but also the integration of validation mechanisms and code generators. In this paper we sketch a conceptual model for code generator composition and show an instantiation of this model in the MontiArc- Automaton framework. MontiArcAutomaton allows modeling software architectures as component and connector models with different component behavior modeling languages. Effective means for code generator integration are a necessity for the post hoc integration of applicationspecific languages in model-based robotics software engineering.

💡 Research Summary

The paper addresses a fundamental challenge in robotics software engineering: how to manage the inherent multidomain nature of robotic applications while still providing a reusable, model‑driven development workflow. Traditional model‑driven engineering (MDE) approaches often assume a single, homogeneous modeling language and a tightly coupled code generator, which quickly becomes insufficient when a robot system must integrate sensing, real‑time control, communication, and high‑level decision making. To bridge this gap, the authors propose a conceptual framework for code generator composition, which treats each domain‑specific modeling language and its associated generator as an independent plug‑in that can be combined at the meta‑model level.

The framework is instantiated in the MontiArc‑Automaton environment, a component‑and‑connector (C&C) modeling platform that already supports heterogeneous behavior specifications (state machines, data‑flow languages, custom DSLs). The key technical contributions are threefold:

1. Standardized Generator Interfaces – Each generator declares its input meta‑model, required preprocessing steps, produced artifacts, and explicit dependencies via a common interface. This abstraction decouples the generator’s internal implementation from the surrounding tool chain.

2. Generator Composition Model (GCM) – A declarative model that captures the dependency graph among generators and validators. By applying topological sorting to this graph, the framework automatically derives a safe execution order, ensuring that, for example, a state‑machine generator runs before a ROS‑binding generator that needs the generated class skeleton.

3. Integrated Validation – Validators are also defined through a uniform interface and are scheduled in the same dependency‑aware pipeline, guaranteeing that model consistency checks precede code generation, thus catching errors early.

The authors demonstrate the approach with two widely used robotic middleware platforms: ROS and OROCOS. A single C&C architecture is modeled once, and then combined with different behavior languages (e.g., a UML‑style state machine and a data‑flow DSL). The composition framework automatically produces the appropriate platform‑specific code: ROS nodes or OROCOS components, each enriched with the correct communication glue and execution semantics. Importantly, when a new behavior language is introduced post‑hoc, the dependency graph updates automatically, and no manual re‑engineering of the generation pipeline is required.

Experimental results show that the composed generators produce correct, compile‑ready code for both target platforms, and that the overhead of managing the composition (graph construction, sorting, and orchestration) is negligible compared to the benefits of modularity and reuse. The paper also discusses how the approach supports incremental development: developers can replace or upgrade a generator (e.g., switching from a legacy C code generator to a modern C++ one) without affecting other parts of the pipeline, as long as the interface contracts are respected.

Beyond the concrete MontiArc‑Automaton case study, the authors argue that the composition model is domain‑agnostic. Any MDE environment that separates structural models (components and connectors) from behavioral models can adopt the same interface‑based plug‑in architecture. Future work is outlined to extend the framework toward runtime reconfiguration, tighter model‑code synchronization, and application to other safety‑critical domains such as automotive or medical robotics.

In summary, the paper provides a robust, scalable solution for integrating multiple modeling languages and their code generators in robotics MDE. By formalizing generator interfaces and leveraging dependency‑driven composition, it enables post‑hoc language integration, reduces maintenance effort, and accelerates the generation of platform‑specific executable code, thereby advancing the state of the art in model‑driven robotics engineering.