The requirements for embedded systems have changed dramatically over the last few decades. Systems have become more complex and need to address safety, security and reliability – across various markets and diverse applications. The development process, however, has largely stayed the same. This talk will build on the fundamentals of software and systems architecture, including the implications of soft versus hard real-time, and explain why separation, in its various forms, is a critical concept when developing high-reliability systems.

Embedded systems are becoming more complex, requiring higher performance and more features, leading to an increased demand for modern programming languages such as C++. In this class, we will discuss the use of C++ and modern C++ for embedded development, focusing on its benefits and challenges.

With multicore processors now standard, modern cars and aircraft are integrating diverse systems onto shared hardware. For example, a single chip might now handle both a car's autonomous driving functions and its GPS navigation, or a plane's flight controls and in-flight entertainment. This consolidation creates a significant problem: how can engineers prevent a glitch in a non-critical application from causing a fatal failure in a safety-critical one?

This session dives into the technical solutions from the automotive and avionics sectors. We'll discuss how to use tools like separation kernels, time-triggered scheduling, and hardware-enforced isolation to manage resource contention and guarantee fault containment, ensuring your system remains predictable and certifiable to industry standards.

Rust is a modern, memory safe and efficient programming language that has a high potential for many types of embedded systems. Its emphasis on performance, type safety, concurrency, and memory safety makes it ideal for safety or security related use-cases.

More and more embedded projects have started to convert their critical code portions from C to Rust and combine it with existing C-code. While the Rust code may be well-designed and trusted, if the C-code it is combined with is not trustworthy, the untrusted C based program portion can crash or compromise the trusted Rust code indirectly. To make sure the untrusted C-code cannot harm the trusted Rust code, software developers need to combine trusted and untrusted code in a way that ensures they are free from interference.

This presentation shows examples how untrusted program portions can make Rust code malfunction. It discusses the importance of freedom-from-interference for mixed-criticality systems and provides different approaches to implement these when writing Rust code, including a discussion of different software architectures appropriate for embedded use-cases.

The isolation of applications into distinct execution environments is a widely recognized foundation for achieving security in embedded systems. Hypervisors are frequently employed to realize such partitioning. However, the underlying principle of memory separation is also inherent to traditional operating system process management.

Presenting hypervisors as the exclusive mechanism for secure separation may be reductive, as alternative approaches—most notably separation kernels—provide comparable or superior guarantees. Furthermore, hypervisors introduce an additional software layer that can increase the system's attack surface and introduce new sources of failure, thereby affecting both safety and security. Separation kernels, by contrast, enable the construction of software architectures that mitigate these risks while avoiding the overhead associated with hypervisors. This presentation examines the problem space in depth and analyzes how foundational separation architectures can more effectively address the challenges of safety and security in embedded systems.