Modeling Software Architecture & MontiArc

Summary of Most Relevant Topic 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 [BKRW17] [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] [HRR12] and also and applied it among others to Cyber-Physical Systems [RRW13].

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] [RW18]) 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 with Semantics

MontiArc [HRR10] [Hab16] is a framework for modeling and simulation of software architectures that has been developed for modeling distributed interactive systems using MontiCore.

The domain of the architecture description language (ADL) MontiArc are information-flow architectures which describe the components of a (software) system and their message-based communication. Hence, MontiArc captures active components (agents, actors) of a logical or physical distribution, their interfaces (ports), the communication infrastructure between components, and hierarchical decomposition. A component is a unit which executes computations or stores data. It may have arbitrary complexity and size being a subsystem or a single function. A component has an explicitly defined interface via which it communicates with its environment. It is implemented as a textual language and comes with an eclipse-integrated editor.

On one hand MontiArc is an architecture description language that helps to model distributed systems by supporting the user with context condition (well-formedness rules) checks and analyses. On the other hand MontiArc serves a simulation environment and a code generator to generate simulation components out of MontiArc models. MontiArc provides a timed, event-based simulation framework that can execute behavior implemented in Java and attached to MontiArc models in a declarative way so that analysis and validation of MontiArc models becomes possible [Hab16].

Because the language MontiArc is designed for extensibility , several sub-languages for behavior may be embedded directly within component definitions. MontiArc is e.g. extended with automata to MontiArcAutomaton [RRW13c], [Wor16] and [RRW14a], with Cloud-constructs to ClArc [PR13], and with security annotations to MontiSecArc [HHR+15].

MontiArc - Architecture Programming

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] which supported by powerful code generation mechanisms based on chains of model transformations [AHRW17] [AHRW17b]. General mechanisms for a systematic extension of the language MontiArc for various purposes are discussed in [BHH+17].

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 ( 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 have 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], to synthesize implementations of crosscutting views [MRR14a], 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. We have documented an evaluation our specification and verification techniques in an experience report [MRRW16]. These concepts are now successfully integrated into automotive development processes [DGH+19].

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. We provide powerful analyses of software architecture behavior evolution in [BKRW19]. Otherwise, the architecture description will rapidly become obsolete as the software evolves to accommodate changes. One way for understanding evolution based on semantic differences is presented in [BKRW17].

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.

This is based on a classification of dynamic reconfiguration approaches in these kinds of architecture description languages [BHK+17] and also applied to dynamic architectural changes in self-adaptive cooperative systems [KKR19].

Videos in this playlist:

  • Transformation Tool for Simulink Models to MontiArc Models
  • Multi User Online IDE for DSLs on the example language MontiArc
  • Controlling a Self Driving Car with MontiArc
  • MontiArcAutomaton Editor

Key Statements

  1. Distributed Software Architecture can be modeled in hierarchically decomposed systems using message passing.
  2. The communication paradigm, advanced composition and refinement techniques are semantically sound and well explored.
  3. MontiArc is an extensible tool infrastructure with an architectural definition language (ADL) at its core.
  4. ADL + Statemachine integration is explored in MontiArcAutomaton and used for robotics applications.
  5. ADL + Java integration is explored as GPL with architectural support.
  6. Delta-MontiArc explores an additive variability mechanism, well suited for an agile start of SPL integration.

Selected Topic-Specific Publications

  1. [KKR19]
    N. Kaminski, E. Kusmenko, B. Rumpe:
    In: The Journal of Object Technology, B. Combemale, S. Ali (Eds.), Volume 18(2), pp. 1-20, AITO - Association Internationale pour les Technologies Objets, Jul. 2019. The 15th European Conference on Modelling Foundations and Applications.
  2. [BKRW19]
    A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
    In: Journal of Systems and Software, P. Pelliccione, J. Bosch, M. Marija (Eds.), Volume 149, pp. 437-461, Elsevier, Mar. 2019.
  3. [DGH+19]
    I. Drave, T. Greifenberg, S. Hillemacher, S. Kriebel, E. Kusmenko, M. Markthaler, P. Orth, K. S. Salman, J. Richenhagen, B. Rumpe, C. Schulze, M. Wenckstern, A. Wortmann:
    In: Software: Practice and Experience, R. Buyya, J. Bishop, K. Cooper, R. Jonas, A. Poggi, S. Srirama (Eds.), Volume 49(2), pp. 301-328, Wiley Online Library, Feb. 2019.
  4. [RW18]
    B. Rumpe, A. Wortmann:
    In: Principles of Modeling: Essays Dedicated to Edward A. Lee on the Occasion of His 60th Birthday, Lohstroh, Marten and Derler, Patricia Sirjani, Marjan (Eds.), pp. 383-406, LNCS 10760, ISBN 978-3-319-95246-8, Springer, 2018.
  5. [BHK+17]
    A. Butting, R. Heim, O. Kautz, J. O. Ringert, B. Rumpe, A. Wortmann:
    In: Proceedings of MODELS 2017. Workshop ModComp, CEUR 2019, Sep. 2017.
  6. [BHH+17]
    A. Butting, A. Haber, L. Hermerschmidt, O. Kautz, B. Rumpe, A. Wortmann:
    In: European Conference on Modelling Foundations and Applications (ECMFA’17), pp. 53-70, LNCS 10376, Springer, Jul. 2017.
  7. [BKRW17a]
    A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
    In: In 12th International Conference on Software Engineering Advances (ICSEA 2017), pp. 213-218, IARIA XPS Press, May 2017.
  8. [BKRW17]
    A. Butting, O. Kautz, B. Rumpe, A. Wortmann:
    In: International Conference on Software Architecture (ICSA’17), pp. 145-154, IEEE, Apr. 2017.
  9. [AHRW17]
    K. Adam, K. Hölldobler, B. Rumpe, A. Wortmann:
    In: International Conference on Robotic Computing (IRC’17), pp. 172-179, IEEE, Apr. 2017.
  10. [AHRW17b]
    K. Adam, K. Hölldobler, B. Rumpe, A. Wortmann:
    In: Journal of Software Engineering for Robotics (JOSER), Volume 8(1), pp. 3-16, 2017.
  11. [HKR+16]
    R. Heim, O. Kautz, J. O. Ringert, B. Rumpe, A. Wortmann:
    In: Software Architecture - 10th European Conference (ECSA’16), Volume 9839, pp. 175-182, LNCS, Springer, Dec. 2016.
  12. [Wor16]
    A. Wortmann:
    Aachener Informatik-Berichte, Software Engineering, Band 25, Shaker Verlag, Nov. 2016.
  13. [MRRW16]
    S. Maoz, J. O. Ringert, B. Rumpe, M. v. Wenckstern:
    In: Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp’16), Volume 1723, pp. 19-24, CEUR Workshop Proceedings, Oct. 2016.
  14. [Hab16]
    A. Haber:
    Aachener Informatik-Berichte, Software Engineering, Band 24, Shaker Verlag, Sep. 2016.
  15. [RRRW15b]
    J. O. Ringert, A. Roth, B. Rumpe, A. Wortmann:
    In: Journal of Software Engineering for Robotics (JOSER), Volume 6(1), pp. 33-57, 2015.
  16. [HHR+15]
    L. Hermerschmidt, K. Hölldobler, B. Rumpe, A. Wortmann:
    In: Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp’15), Volume 1463, pp. 18-23, CEUR Workshop Proceedings, 2015.
  17. [RRW14a]
    J. O. Ringert, B. Rumpe, A. Wortmann:
    Aachener Informatik-Berichte, Software Engineering, Band 20, Shaker Verlag, Dec. 2014.
  18. [Rin14]
    J. O. Ringert:
    Aachener Informatik-Berichte, Software Engineering, Band 19, ISBN 978-3-8440-3120-1, Shaker Verlag, Aachen, Germany, Dec. 2014.
  19. [MRR14b]
    S. Maoz, J. O. Ringert, B. Rumpe:
    In: Software Engineering Conference (ICSE’14), pp. 95-105, ACM, 2014.
  20. [MRR14a]
    S. Maoz, J. O. Ringert, B. Rumpe:
    In: Software Engineering 2014, W. Hasselbring, N. C. Ehmke (Eds.), Volume 227, pp. 63-64, LNI, Gesellschaft für Informatik, Köllen Druck+Verlag GmbH, 2014.
  21. [PR13]
    A. Navarro Pérez, B. Rumpe:
    In: Model-Driven Engineering for High Performance and Cloud Computing Workshop, Volume 1118, pp. 15-24, CEUR Workshop Proceedings, 2013.
  22. [RRW13c]
    J. O. Ringert, B. Rumpe, A. Wortmann:
    In: Conference on Robotics and Automation (ICRA’13), pp. 10-12, IEEE, 2013.
  23. [MRR13]
    S. Maoz, J. O. Ringert, B. Rumpe:
    In: Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE’13), Meyer, B. and Baresi, L. and Mezini, M. (Eds.), pp. 444-454, ACM New York, 2013.
  24. [RRW13]
    J. O. Ringert, B. Rumpe, A. Wortmann:
    In: Software Engineering Workshopband (SE’13), Volume 215, pp. 155-170, LNI, 2013.
  25. [HRR12]
    A. Haber, J. O. Ringert, B. Rumpe:
    RWTH Aachen University, AIB-2012-03, Technical Report, Feb. 2012.
  26. [HRRS12]
    A. Haber, H. Rendel, B. Rumpe, I. Schaefer:
    In: Large-Scale Complex IT Systems. Development, Operation and Management, 17th Monterey Workshop 2012, pp. 183-208, LNCS 7539, Springer, 2012.
  27. [HKR+11]
    A. Haber, T. Kutz, H. Rendel, B. Rumpe, I. Schaefer:
    In: Software Architecture Conference (ECSA’11), pp. 6:1-6:10, ACM, 2011.
  28. [HRR+11]
    A. Haber, H. Rendel, B. Rumpe, I. Schaefer, F. van der Linden:
    In: Software Product Lines Conference (SPLC’11), pp. 150-159, ISBN 978-1-4577-1029-2, IEEE, 2011.
  29. [HRRS11]
    A. Haber, H. Rendel, B. Rumpe, I. Schaefer:
    In: Tagungsband des Dagstuhl-Workshop MBEES: Modellbasierte Entwicklung eingebetteterSysteme VII, pp. 1 - 10, fortiss GmbH, 2011.
  30. [MMR10]
    T. Mens, J. Magee, B. Rumpe:
    In: IEEE Computer, Volume 43(5), pp. 42-48, IEEE, May 2010.
  31. [HRR10]
    A. Haber, J. O. Ringert, B. Rumpe:
    In: Tagungsband des Dagstuhl-Workshop MBEES: Modellbasierte Entwicklung eingebetteterSysteme VI, Volume 2010-01, pp. 13 - 22, Informatik-Bericht, fortiss GmbH, Germany, 2010.
  32. [GKPR08]
    H. Grönniger, H. Krahn, C. Pinkernell, B. Rumpe:
    In: Modellbasierte Entwicklung von eingebetteten Fahrzeugfunktionen, pp. 76-89, Informatik Bericht 2008-01, TU Braunschweig, 2008.
  33. [GHK+08]
    H. Grönniger, J. Hartmann, H. Krahn, S. Kriebel, L. Rothhardt, B. Rumpe:
    In: Proceedings of 4th European Congress ERTS - Embedded Real Time Software, 2008.
  34. [BR07]
    M. Broy, B. Rumpe:
    In: Informatik-Spektrum, Band 30(1), pp. 3-18, Springer Berlin, Feb. 2007.
  35. [GHK+07]
    H. Grönniger, J. Hartmann, H. Krahn, S. Kriebel, B. Rumpe:
    In: Object-oriented Modelling of Embedded Real-Time Systems Workshop (OMER4’07), 2007.
  36. [PR99]
    J. Philipps, B. Rumpe:
    In: Congress on Formal Methods in the Development of Computing System (FM’99), pp. 96-115, LNCS 1708, Springer, 1999.
  37. [HRR98]
    F. Huber, A. Rausch, B. Rumpe:
    In: Technology of Object-Oriented Languages and Systems (TOOLS 26), pp. 58-70, IEEE, 1998.