Modeling in Advanced Systems Engineering

The use of models and the activity of modeling is an integral part of almost all development activities for complex systems.

Complexity - the main Challenge

Complexity is an omnipresent challenge, for software, for mechanical systems with intelligence (e.g., autonomous cars, robots, healthcare gadgets or airplanes), for production plants, and also for biological systems (e.g., advanced medicine, human cells, organs, and even full organisms), that will be engineered with increased frequency in the future. Managing complexity in a development process becomes much easier, when a well organized development process can be centered around an end-to-end modelling approach, allowing to connect early requirements, architectural and design decisions, behavioral specifications, as well as testable expected properties and test data through an integrated modeling approach.

“Systems of systems” are typically confederated and collaborating ensembles of systems that were originally designed individually, but through new opportunities that were not originally envisioned, are now required to tightly cooperate. Examples of such systems include telecommunications services, multiple integrated web services across the internet, energy networks and also the city networks of collaborating smart buildings and transportation infrastructure. Modelling is a core technique to understand the interplay of a system of systems.

Models in Engineering

All of the examples listed previously rely on models. During development of these initially independent systems, models are often defined before the system exists, requiring explicit modeling activities to explicate requirements on the system to document multiple design decisions and alternatives.

Models in Data Science

This is an entirely different process from how models come to life when using data science techniques to extract models (e.g., of behavior or typical dynamic configurations) from observations of existing systems. These other kinds of extracted models are helpful when optimizing existing systems and processes, but are not intended for the original design (which may have occurred by nature).

Shared Modeling Paradigms?

However, it is our belief that even though the process for model creation and use is different across various domains, the same underlying modeling paradigms and concepts can often be incorporated. As a consequence, these models could also be adopted in similar modeling languages.

This brings us to the interesting question of whether and how far a modeling language from UML or SysML (e.g., Statecharts or Activity Diagrams) is already fit for this purpose?

For example, how much extension is needed to add concepts such as modeling uncertainty and statistical distribution of possible behaviors? Even though there is much research in these domains that has produced compelling results, how long will it take to see these results made available in broadly used tools? We believe that much progress still needs to be made in order to realize the full potential.

Software Model Languages migrate to Systems Engineering?

Currently (in 2022+), there is an ongoing effort to inject more explicit modeling techniques into the Systems Engineering discipline, which we define as including the intersection of the mechanical, electrical and software subdomains.

Software Engineering already provides many modeling techniques to address complexity and architectural structure. This is also true for Electrical Engineering, with Mechanical Engineering supporting the use of many modeling ideas in different contexts.

The concepts of modeling across these disciplines can expand the ability of a systems engineer to address safety, security, robustness and operability concerns, as well as many other desirable properties of the systems to be developed and produced in the future.

Model and Language Integration

This observation brings us to the well-known challenge that most of these modeling techniques do not integrate very well. As a consequence, it is still frustratingly difficult to define an appropriate tool chain that adequately addresses a new project’s needs (e.g., systems analyses and synthesis activities).

AI-components in a System: a game changer? – Partially!

From a Software Engineering point of view, the existence of components developed using Artificial Intelligence does not really change the game. Software Engineering has established the foundational understanding that software is never completely correct and the unpredictable behavioral errors must be detected and absorbed internally to prevent full system failure. The integration of AI components becomes just another type of unreliable component that must be mastered.

Specific precautions must be taken to address the possible failures of AI-based components. Even the idea of self-explainability is not an entirely new concept. A common challenge of Software Engineering is the need to explain to a user what the software is doing or why it cannot do a specific requested action. The existence of explicitly defined models can be helpful in explaining behavior to users (e.g., using state model as underlying concepts).

“Advanced Systems Engineering” needs both, Software Engineering and AI

The idea of “Advanced Systems Engineering” is an approach that tries to address many of the current challenges, often by adding AI-based development techniques for the software needs of the system.

However, many of the existing modeling techniques, methods and practices of Software Engineering are currently often ignored because of an assumption that software need not be developed in the future as in the past. This approach places an emphasis on training software through condensing available data to directly embeddable models. Yet, this idea will only work in very very narrow cases and it is not clear what to do with the majority of the complex software that is not addressed by an “Advanced Systems Engineering” approach.

Innovative systems seem to derive their innovations to a larger extent from the software and software services around the mechanical part of the system. And only a little part of it can actually be developed using AI techniques. The rest is still pure Software Engineering.

Software Engineering methods, techniques and tools would be well applied in other disciplines

Computer Science (in general) and Software Engineering (in particular) have not been able to transfer all of their knowledge, techniques and methods to Systems Engineering.

There is much to do and the use of an integrated set of modeling techniques, defined in explicit modeling languages and assisted by an integrated toolchain, is still far away. Software development methods, such as Agile Methods or DevOps, amidst the general use of models is steadily increasing in the integrated Systems Engineering domain.

It will be interesting to see which forms of model modularity will be more successful and beneficial for Systems Engineers in the long-term and how all of these forms and their use of models will collaborate during design and operation of advanced, intelligent systems.

Some Achievements of Software Engineering

The above observations are to be seen in the light of the history and start of the Software Engineering discipline: In early times software engineers were often told from experts in systems development that they “should develop their software in the same systematic and predictable way as other engineers (e.g., mechanical engineers)”.

We can trace Software Engineering back to the 1968 NATO Science Committee conference in Garmisch, Germany, organized by Friedrich L. Bauer. In that short time, software developers have created their own portfolio of methods, ranging from heavyweight documentation-oriented approaches to the much more beloved agile and light-weight methods. Even though there is always potential for optimization, agile techniques have reached a level where software developers can produce reliable products using cost efficient, relatively predictable and controllable processes.

What seems to be even more important is that the way of developing software is tightly connected to general innovation processes that not only lead to novel ideas about how to implement software, but also to new ideas about potential features and services that can be integrated into software solutions. The tight coupling of software development and innovation is closely related to the strong connection between requirements elicitation and direct implementation in agile processes, where the same stakeholders are responsible for the innovations of development. Furthermore, the invention of new control and data structures in object-oriented development can drive the innovation of new features.

Software-based companies in Silicon Valley have used this mood of innovation effectively. They have integrated software services into their core business model, which has led to innovative thinking and effective, agile development of products in other domains (e.g., medical services, autonomous driving, electric cars, finance). Traditional companies based on fundamental engineering processes may feel threatened by the radical change and fast rate of innovation that the new technologies offer.

There are many challenges in training classical engineers to adopt a new form of project organization, most importantly more
responsibilities are given to the developers and developers have to accept these. However, this mindset is a constructive approach to improve innovation. Traditional engineering-based companies, as well as other software-intensive companies, now have to catch up. Many good examples in these areas give us hope that change is possible.

In systems that require expertise from multiple areas of engineering, traditional engineers are becoming more open to software engineering practices. Furthermore, software development methodologies are being adopted more frequently into traditional engineering practice. In a recent and wellknown German TV broadcast, a highly esteemed expert in mechanical and production engineering, Günther Schuh, was asked why he and his team were able to produce the “StreetScooter” electric car so quickly. Schuh said, “Because they have used computer science methods”. In particular, Schuh mentioned agility as a key catalyst to the increased speed of development.


  1. Software Engineering has developed an excellent portfolio of development methods, languages and tools.
  2. An “Advanced Systems Engineering” approach should
    integrate Model-Based and Agile Software Development methodology much more intensively.

This essay is an excerpt from SoSyM editorials [GR22a] and [GR18a], which are published under the Creative Commons licence.

  1. [GR22a]
    J. Gray, B. Rumpe:
    In: Journal Software and Systems Modeling (SoSyM), Volume 21(2), pp. 435-436, Springer Berlin / Heidelberg, Mar. 2022.
  2. [GR18a]
    J. Gray, B. Rumpe:
    In: Journal Software and Systems Modeling (SoSyM), Volume 17(2), pp. 363-364, Springer Berlin / Heidelberg, 2018.