Systems of systems

Many computer systems to execute some task consist of a composition of smaller subsystems. When these subsystems can be programmed on their own, we call it a system of systems.

A well-known example is the Internet of Things, IoT, but there are many more examples. Many computers contain multiple cores or special hardware to execute for instance array operations efficiently. In all cases, the programmer has to decide where a computation is executed and how these computation parts are orchestrated. Executing parts of the program on another system typically requires packing and transporting data and results. Those subsystems often require tailor-made programs in a foreign programming language or the use of special libraries.

Key questions to answer in Systems of systems are:

• What is executed where? This concerns the distribution of tasks over the various subsystems. This should be done as flexible as possible to cope with changing hardware and requirements in the future.
• How to orchestrate the computations? Tasks typically need data to get started, exchange information during their work, and to share results. However, all communication takes time and costs energy. Hence, we have to design systems such that communication is limited and flexible.
• How can the programmer be supported in this orchestration? In the typical software project, about 90% of the effort is in maintenance. When things are done correctly, this is largely adapting the system to changing requirements and circumstances. The correction of errors and misunderstandings between domain experts and programmers should be as smoothly as possible. In our vision, the previous two questions can only be answered sustainably by solving the problems at a high level of abstraction. We build Domain Specific Languages, DSLs, for the distribution of subtasks and their orchestration. We investigate what abstractions are most suitable and how they are best implemented.

Key aspects in systems of systems programming are:

• High Productivity. The programmer should be able to create such systems easily and adapt them with little effort to changing requirements. We strongly believe that a proper high abstraction level to express the required tasks is crucial here. Hence, we build and investigate DSLs for Task-Oriented Programming and Array Programming. Appropriate abstractions help the programmer to focus on the important aspects and enable a high productivity. Strong typing prevents that errors in the code will be only detected at runtime.
• High Portability. It is likely subsystems used to execute parts of the program will change over time, or that a program needs to be ported to a system of systems of another architecture. This can only be done efficiently when the programmer can abstract from details of a specific architecture.
• High Performance. The efficient execution of algorithms is the raison d'être of array programming. The need to limit the energy use of electronics in the light of green computing makes high efficiency also crucial for other systems of systems.