<< back to topics
Modeling Software Architecture & the MontiArc Tool
Summary of Selected Papers
Distributed interactive systems have become more and more important in the last decades. It is becoming the standard case that a system is distributed. Typically, these systems consist of subsystems and components such as
- sensors, control units, and actuators in cyber-physical machines,
- high performance computing nodes,
- big data storage nodes,
- messages transmitted between web services in cloud computing applications, or
- interaction between mobile humans.
The main paradigm for communication in distributed systems is asynchronous message passing between actors. The logical or physical architecture of a hierarchically decomposed system can be modeled like this excerpt of a car locking device:

Messages can be
- event signals, e.g., messages on a bus,
- values measured by sensors and discrete event signals,
- streams of telephone or video data,
- method invocation, or
- complex data structures passed between software services.
Semantically our approach is formally sound and well-defined using streams, state machines, components, as well as expressive forms of composition and refinement (see here for Semantics). We leverage this, for instance, to enable a semantic differentinc of component & connector architectures [BKR+17][BKRW19].
Some challenges in the design and implementation of these systems are the development of an appropriate architectural decomposition of the system and fitting component interfaces suitable for property analysis, effective realization, and reuse of components under variability considerations. We have made a number of contributions to this field from more theoretical considerations up to a concrete tooling infrastructure called MontiArc[BKRW17a].
Theoretical Foundations of Software Architecture Modeling
A theoretical foundation of a model-based development in terms of an integrated, homogeneous, but modular construction kit for architectural models is described in [BR07]. Mathematical foundations are given for modeling of interfaces, building architectures through composition and decomposition, layering architectures as well as hierarchical decomposition, and implementation of components using state machines. Especially the refinement (see also [PR99]) of hierarchy, interfaces, and behavior is discussed as well as abstraction mechanisms for the integration of abstract viewpoints. The presented theory consists of a set of theorems and provides a basis for architectural modeling without sticking to a concrete syntax of a modeling language.
MontiArc - Architecture Modeling and Architectural Programming
The architectural design language MontiArc has been developed for modeling distributed interactive systems. It captures active components (agents, actors) of a logical or physical distribution, their interfaces (ports), the communication infrastructure between the components, and a hierarchic decomposition. MontiArc is a full ADL, although we have omitted some uninteresting concepts from the AADL standard and could then optimize others.
![]() |
MontiArc is described in [HRR12] in detail. MontiArc is a textual language and comes with an eclipse-integrated editor. It provides a simulation framework that can execute behavior implemented in Java and attached to MontiArc models in a declarative way so that analysis on MontiArc models becomes possible. |
Because the language MontiArc is designed for extensibility cite("BHH+17"); ?>, several sublanguages for behavior may be embedded directly within component definitions. MontiArc is e.g. extended with automata to MontiArcAutomaton [RRW13c] and [RRW14a]. In [HRR10], an extension of MontiArc with Java is presented, which becomes a full programming language that exhibits architecture, data structure and behavior. [RRRW15b] describes how the language is composed of individual sublanguages. With this approach, a smooth integration of architectural design and programming is achieved. We call this architectural programming [HRR10], [BKRW17a].
Architectural Variability
The article "Variability" discusses our contributions in more detail, but it is worth to mention that much variability research was applied to and experimentally verified using MontiArc.
Variability of a system has to be considered and modeled by appropriate means during all phases of the development but especially in the architectural design. MontiArc has thus been extended in two different ways, hierarchical variability modeling and delta-modeling, in order to explore ways to enable architectural modeling of variants defined in a product line.
In [HRR+11], we explored a variability mechanism based on MontiArc that allows specifying component variants fully integrated at any level of the component hierarchy. Here, variation points may have hierarchical dependencies. Associated variants define how this variability can be realized in component configurations. As a general drawback of this approach, systems are restricted to the set of predefined variations and cannot be extended. This approach is not additive.
We thus explored delta-modeling as an additive approach to variability design. This will allow a company to immediately start to develop and think in terms of product lines, even years before the full variability model is extracted (reengineered) from former and ongoing projects. The main idea is to represent any system by a core system and a set of deltas that specifies modifications. In [HRRS11] we describe Δ-MontiArc, which applies this concept successfully to MontiArc. The core is a MontiArc model. A delta-language is defined describing how to add, remove, or modify architectural elements. The concrete realization of Δ-MontiArc using the DSL development framework MontiCore (www.monticore.de) is described in [HKR+11]. The developed language allows the modular modeling of variable software architectures and supports proactive, reactive as well as extractive product line development. As a next step, we explored in [HRRS12] how to evolve a complete delta-based product line, e.g. by merging or splitting deltas.
Requirements, Evolution, Dynamics of Architecture
A methodological approach to close the gap between the requirements architecture and the logical architecture of a distributed system realized in a function net is described in [GHK+07] and [GHK+08]. It supports the tracing of requirements to the logical software architecture by modeling the logical realization of a feature that is given in a requirement in a dedicated feature view. This allows us to break down complexity into manageable tasks and to reuse features and their modular realization in the next product generation. [GKPR08] extends this modeling approach to model variants of an architecture. These concepts are now successfully integrated into automotive development processes.
We also defined a precise verification technique that allows developers to decompose logical architectures into smaller pieces of functionality, e.g., individual features in [MRR13] and [Rin14], and to verify their consistency against a complete architecture in [MRR14b]. Our hypothesis is that with this technique, developers will be able to decompose requirements into features and compose their implementation late in the development process. That will definitely increase reusability of features. An overview and a detailed discussion on the challenges of co-evolution of architectural system descriptions and the system implementation is given in [MMR10]. Architectural descriptions of a system deal with multiple views of a system including both its functional and nonfunctional aspects. Especially, critical aspects of a system should be reflected in its architecture. The description must also be accurately and traceably linked to the software's implementation so that any change of the architecture is reflected directly in the implementation, and vice versa. Otherwise, the architecture description will rapidly become obsolete as the software evolves to accommodate changes. |
![]() |
While many architecture styles assume static structures, we
explored a modeling technique to describe dynamic
architectures in [HRR98][HKR+16].
The former [HRR98] allows developers to
express dynamically extensible interfaces of components with
so-called component interface diagrams. The latter [HKR+16]
allows developers to associate component configurations
to modes and to specify dynamic reconfiguration behavior
via mode automata that describe when to switch modes.
Summary
- Distributed Software Architecture can be modeled in hierarchically decomposed systems using message passing.
- The communication paradigm, advanced composition and refinement techniques are semantically sound and well explored.
- MontiArc is an extensible tool infrastructure with an architectural definition language (ADL) at its core.
- ADL + Statemachine integration is explored in MontiArcAutomaton and used for robotics applications.
- ADL + Java integration is explored as GPL with architectural support.
- Delta-MontiArc explores an additive variability mechanism, well suited for an agile start of SPL integration.
Related Topics
- Automotive
- Agile Model-Based Software Engineering
- Cloud Computing & Enterprise Information Systems
- Cyber-Physical Systems (CPS)
- Generative Software Engineering
- Modeling Software Architecture
- MontiCore - Language Workbench
- Robotics
- Semantics of Modeling Languages
- State-Based Modeling (Automata)
Selected Related Publications
-
[BKRW19]
A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
Continuously analyzing finite, message-driven, time-synchronous component & connector systems during architecture evolution.
In: Journal of Systems and Software, 149, pp. 437-461, March 2019. -
[BKR+17]
A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
Semantic Differencing for Message-Driven Component & Connector Architectures.
In: International Conference on Software Architecture (ICSA'17), Gothenburg, pg. 145-154. IEEE, April 2017. -
[BKRW17a]
A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
Architectural Programming with MontiArcAutomaton.
In: International Conference on Software Engineering Advances (ICSEA'17), pg. 213-218, Athens, Greece, IARIA XPS Press, May 2017. Received Best Paper Award. -
[BHH+17]
A. Butting, A. Haber, L. Hermerschmidt, O. Kautz, B. Rumpe, A. Wortmann:
Systematic Language Extension Mechanisms for the MontiArc Architecture Description Language.
In: European Conference on Modelling Foundations and Applications (ECMFA'17), Marburg, pg. 53-70. LNCS 10376, Springer, July 2017. - [RRRW15b]
R. Heim, O. Kautz, J. O. Ringert, B. Rumpe, A. Wortmann:
Retrofitting Controlled Dynamic Reconfiguration into the Architecture Description Language MontiArcAutomaton.
In: Software Architecture - 10th European Conference (ECSA'16), LNCS 9839, pp. 175-182. Copenhagen, Denmark, December 2016. Springer. - [RRRW15b]
J. O. Ringert, A. Roth, B. Rumpe, A. Wortmann:
Language and Code Generator Composition for Model-Driven Engineering of Robotics Component & Connector Systems.
In: Journal of Software Engineering for Robotics (JOSER), 6(1):33-57, 2015. -
[RRW14a]
J. O. Ringert, B. Rumpe, A. Wortmann:
Architecture and Behavior Modeling of Cyber-Physical Systems with MontiArcAutomaton.
Aachener Informatik-Berichte, Software Engineering, Band 20. ISBN 978-3-8440-3120-1. Shaker Verlag, 2014. -
[Rin14]
J. O. Ringert:
Analysis and Synthesis of Interactive Component and Connector Systems.
Aachener Informatik-Berichte, Software Engineering Band 19. ISBN 978-3-8440-3120-1. Shaker Verlag, 2014. -
[MRR14b]
S. Maoz, J. O. Ringert, B. Rumpe:
Verifying Component and Connector Models against Crosscutting Structural Views.
In: 36th International Conference on Software Engineering (ICSE 2014). Pages 95-105. Hyderabad, India, ACM New York, June 2014. -
[MRR13]
S. Maoz, J. O. Ringert, B. Rumpe:
Synthesis of Component and Connector Models from Crosscutting Structural Views.
Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'13),
Eds.: B. Meyer, L. Baresi, M. Mezini, pages 444-454, ACM New York, 2013. -
[RRW13c]
Jan Oliver Ringert, Bernhard Rumpe, Andreas Wortmann
MontiArcAutomaton: Modeling Architecture and Behavior of Robotic Systems
In: Workshops and Tutorials Proceedings of the 2013 IEEE International Conference on Robotics and Automation (ICRA), May 6-10, 2013, Karlsruhe, Germany. -
[HRR12]
A. Haber, J. O. Ringert, B. Rumpe
MontiArc - Architectural Modeling of Interactive Distributed and Cyber-Physical Systems
RWTH Aachen University, Technical Report.
AIB-2012-03. February 2012.
-
[HRRS12]
A. Haber, H. Rendel, B. Rumpe, and I. Schaefer
Evolving Delta-oriented Software Product Line Architectures
In: Large-Scale Complex IT Systems. Development, Operation and Management, 17th Monterey Workshop Oxford, UK, LNCS Vol. 7539, pp. 183-208. March 19-21, 2012. -
[HKR+11] A. Haber, T. Kutz, H. Rendel, B. Rumpe, I. Schaefer
Delta-oriented Architectural Variability Using MontiCore
In: ECSA '11 5th European Conference on Software Architecture: Companion Volume, ACM New York, NY, USA, Article No. 6, September 2011. -
[HRRS11]
A. Haber, H. Rendel, B. Rumpe and I. Schäfer
Delta Modeling for Software Architectures.
In: Tagungsband des Dagstuhl-Workshop MBEES: Modellbasierte Entwicklung eingebetteter Systeme VII, fortiss GmbH München, February 2011.
-
[HRR+11]
A. Haber, H. Rendel, B. Rumpe, I. Schaefer, F. van der Linden
Hierarchical Variability Modeling for Software Architectures
In: Proceedings of International Software Product Lines Conference (SPLC 2011), IEEE Computer Society, August 2011.
-
[MMR10]
T. Mens, J. Magee, B. Rumpe
Evolving Software Architecture Descriptions of Critical Systems
In: Computer vol. 43, IEEE Computer Society, May 2010.
-
[HRR10] A. Haber, J. O. Ringert, B. Rumpe.
Towards Architectural Programming of Embedded Systems.
In: Tagungsband des Dagstuhl-Workshop MBEES: Modellbasierte Entwicklung eingebetteter Systeme VI. Informatik-Bericht 2010-01, Institut für Software Systems Engineering, TU Braunschweig, 2010
-
[GKPR08]
H. Grönniger, H. Krahn, C. Pinkernell, B. Rumpe
Modeling Variants of Automotive Systems using Views.
In: Tagungsband Modellierungs-Workshop MBEFF: Modellbasierte Entwicklung von eingebetteten Fahrzeugfunktionen. Berlin, März 2008,
Informatik-Bericht 2008-01, CFG-Fakultät, TU Braunschweig, 2008. -
[GHK+08]
H. Grönniger, J. Hartmann, H. Krahn, S. Kriebel, L. Rothhardt, B. Rumpe
Modelling Automotive Function Nets with Views for Features, Variants, and Modes.
4th European Congress ERTS - Embedded Real Time Software, Toulouse 2008. -
[GHK+07]
H. Grönniger, J. Hartmann, H. Krahn, S. Kriebel, B. Rumpe.
View-Based Modeling of Function Nets.
In: Proceedings of the Object-oriented Modelling of Embedded Real-Time Systems (OMER4) Workshop, Paderborn, October 2007
-
[BR07]
M. Broy, B. Rumpe.
Modulare hierarchische Modellierung als Grundlage der Software- und Systementwicklung..
In: Informatik-Spektrum. Springer Verlag.
Band 30, Heft 1, Februar 2007.
-
[PR99]
Jan Philipps, Bernhard Rumpe.
Refinement of Pipe-and-Filter Architectures
In: FM'99 - Formal Methods, Proceedings of the World Congress on Formal Methods in the Development of Computing System. LNCS 1708, pages 96-115
J. M. Wing, J. Woodcock, J. Davies (eds.)
Springer Publisher, 1999 -
[HRR98]
Franz Huber, Andreas Rausch, Bernhard Rumpe.
Modeling Dynamic Component Interfaces
In: TOOLS 26, Technology of Object-Oriented Languages and Systems
M. Singh, B. Meyer, J. Gil, R. Mitchell (eds.)
IEEE Computer Society, 1998.
<< list of all topics list of all publications >>