<< back to topics

Modeling Software Architecture & the MontiArc Tool

A selection of papers from Bernhard Rumpe and the Software Engineering Group

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 such systems consist of subsystems and components like
  • 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. 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.

Theoretical foundation 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 (see for the MontiArc tool) 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, 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.

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]. It allows developers to express dynamically extensible interfaces of components with so-called Component Interface Diagrams (CID).


  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.

Further Topics:

Selected Publications:

<< list of all topics list of all publications >>