Advancing the state-of-the-art in software construction

The concrete implementation of systems and prototypes, with which concepts and methods are studied, is our foundation of research. The long-term goal is to contribute to something that might be called a handbook for software construction. Let us illustrate this by means of a classical engineering discipline. An engineer who constructs a bridge considers all the relevant parameters according to explicitly documented knowledge about bridge building. This narrows down the number of choices, but helps to ensure that the bridge won’t collapse.
In an analogous way a software construction handbook should describe the relevant context and solutions for typical problems at hand. This includes all aspects of software construction, in particular

  • software design and implementation
  • software reuse and composition
  • programming methodology

A pragmatic research approach requires a focus on certain domain areas. Currently we have chosen socalled embedded (control) systems:

Embedded (control) systems

An embedded system is “a computer system hidden inside a product other than a computer” (D. Simon: An Embedded Software Primer, Addison-Wesley, 1999). The spectrum of embedded systems ranges, for example, from mobile phones to safety-critical control systems in cars. Today about 98% of the programmable CPUs run as embedded systems. The workload in the design and implementation of embedded systems is shifting continuously from hardware to software. At the same time the complexity is growing due to the increasing functionality provided by embedded systems. Therefore the systematic, if possible automated development of software for embedded systems (embedded software for short) represents a challenge.
In embedded control systems, that is systems that control physical processes, the software has to periodically acquire sensor data about the environment (that is, the state of the variables under control), compute the control laws and set the actuators. The stand-alone operation of embedded control systems outside human supervision requires a high degree of autonomy and reliability to be built into embedded software. We assess the area of embedded software engineering for control systems as an emerging field in software science for the following reasons:

  • There is a large technological gap between embedded and non-embedded software. This needs to be closed as discussed below.
  • The development of embedded systems has its roots in electrical engineering and control engineering which implies a focus on hardware so far. In other words, software is adjusted to a specific hardware platform. Any change of the hardware platform requires a tedious adaptation of the software. Typically, electrical and control engineers on one side and software engineers on the other side represent two quite separated camps that accomplish the development of embedded systems. The focus on the hardware platform may be another reason why the area has not been very attractive for software science so far. Due to their background, electrical and control engineers have not significantly contributed to software technology tailored to embedded (control) systems.
  • Complexity: As a consequence of the above stated advances in hardware resources, embedded systems have to harness the additional resources and thus have to provide more functionality which in turn sharply increases their complexity. The additional functionality is implemented in software so that the software portion of embedded systems will continue to grow. Adequate software technology has to be applied to meet the quality demands, in particular of safety-critical systems.

To improve the development and quality of embedded control systems we regard a move from a hardware-oriented towards a software-oriented construction as mandatory.

Research challenges in embedded software engineering

Compared to software in other domains, embedded control systems have to cope with the behavior and timing of environment processes. For example, the characteristics of a combustion engine define the requirements of the associated control software, that is, which mechanical or chemical processes inside the engine have to be observed in parallel and what the corresponding timing requirements are. Sensors capture the relevant information about the controlled objects. The control software has to calculate, within the time constraints, the necessary adjustments of actuators that imply the desired system behavior. From a birds-eye view the principal challenges of embedded software development that need to be addressed are the following:

  • Explicit modeling of the timing behavior. State-of-the-art programming languages do not offer abstractions for dealing with real-time requirements. Synchronous languages set a first step in this direction about twenty years ago. The timed programming model, recently invented in the realm of the  Giotto project represents a major improvement, delivering crucial embedded software properties such as time and value determinism, as well as composibility. The Timing Definition Language (TDL) is a current research project that relies on the timed programming model. We have seamlessly integrated TDL with Matlab/Simulink, the state-of-the-art visual interactive modeling tool set used by control engineers.
  • Component standards and improved reusability. Component standards have to be extended to comprise the notion of timing requirements and automated schedulability checks. Known reuse approaches such as object-oriented product lines and plug-in architectures have to be adjusted to the specific needs of real-time requirements. For a discussion of the various issues related to this topic, see, for example, the paper Embedded Software Market Transformation Through Reusable Frameworks (by W. Pree, A. Pasetti; published at the first EMSOFT conference, Lake Tahoe, California, October 8-10, 2001).
  • Improvement of development processes. The development of safety-critical software with its stringent quality requirements demands adequate software processes, adapted to the specific requirements of embedded systems. The embeddedCMMI project tries to deliver results that can be harnessed in practice.
  • Formal verification. The generated timing and functionality code has to adhere exactly to the behavior specified by developers in their models.

Overall, the automation of embedded software development requires an adaptation of software science concepts and formal methods as well as their integration. This might include the definition of new programming languages targeted at embedded software as well as processes, methods and tools that are unknown in non-embedded software.