Research Statement
Although not in every case as prominently visible to the end-user
as traditional IT systems, embedded systems are becoming more and more pervasive in
our everyday's lives. Statistics claim that up to 98% of today's computer technology
in fact is "hidden" in embedded systems, helping to increase the comfort, safety, or
efficiency of some other enclosing product or system. As Moore's Law continues to
shuffle ever growing computational power, we are naturally expecting these embedded
systems to act more and more autonomously, to take over more control – and ultimately,
a higher level of responsibility: Just consider driver assistance systems taking over
to autonomously drive your car, or service robots autonomously operating in unknown
environments and unforeseen situations.
Growing expectations on what embedded systems can and should do also
come with new technical and conceptual challenges, thus creating – sometimes new,
sometimes simply extended – areas of research. Among these, the most important and
most interesting ones are, in my opinion, those related to questions of
- safety and fault-tolerance of embedded systems
- dependability of embedded systems
- development methodologies for large-scale embedded systems
As embedded systems take more control over safety-critical operations,
correctness of their embedded code becomes the essential prerequisite. Formal
verification is one standard approach which, however, becomes more and more difficult
as the complexity of systems explodes. Dynamic reconfiguration poses additional problems
for traditional code verification, which may be addressed by approaches for self-verification
and self-management (at run-time). Another characteristic of embedded systems is their
tight coupling with the particular hardware they are designed for, thereby creating
additional needs for coping with faults and failures not only of software (sub-)systems,
but also of hardware (sensors, actuators, ...).
Secondly, taking the next steps beyond safety and fault-tolerance,
embedded systems will increasingly be required to be dependable in a more general
sense, too. By comprising the characteristics of availability, reliability, and
maintainability, the term "dependability" addresses the question of how to ensure
"the right" behavior over the system's lifetime. As embedded systems start to act
more and more autonomously, these systems are not only expected, but particularly
intended to cope with new and unforeseen situations. In the face of these scenarios,
the term "correct system behavior" becomes more and more blurred. The central research
questions here are how to create a notion of "advantageous behavior", how to code this
into the system, and how to ensure that the system will behave advantageous even in
situations not foreseen and pre-coded by the developer.
Thirdly, growing expectations on embedded systems also result in a
growing complexity of these systems. While in the past, the term "embedded" has often
been associated with "small", today's and tomorrow's embedded systems are becoming
huge, highly distributed and parallel, complex systems. Development approaches for
such systems have to be fundamentally different to those for small sequential code
snippets running on yesterday's simple mircro-controllers. One of the main challenges
here is to adapt large-scale software design and development methodologies such as
model-driven development to the world of embedded systems.
On a side-note to Moore's Law: while all intelligence indicates that –
in principle – this law will be remaining valid for the coming years, the software
engineer's "free lunch" will be over soon in the embedded world as well. Higher clock
rates will hit the "heat barrier", and with some 5-8 years delay after the mainstream
desktop and server IT environments, a paradigm shift towards multi-core architectures
will take place in embedded systems, too. This, in fact, adds new challenges to the
embedded systems world, posing questions of
- how to partition and parallelize today’s mainly sequential embedded code
- how to ensure real-time constraints in a multi-core, multi-threaded architecture
See here for previous research.
|