OUR SPEAKERS 2026
And more...
Just Wait For It.
Stephan Bökelmann
tba
tba
In Defense of "Useless" Projects: Keeping the Spark Alive
As embedded engineers, many are conditioned to optimize for efficiency, code size, and stability. Yet optimizing daily work strictly for the product roadmap can quietly lead to technical stagnation. How does a team transition to modern C++ or start exploring Rust when the current project demands legacy compliance? The answer often lies in the “one-off.”
In this lightning talk, Florian Humblot argues for the value of single-purpose tools and throwaway prototypes. He demonstrates how treating small side projects as learning laboratories makes it possible to try new libraries, architectural patterns, and even new languages in a low-risk environment—without endangering production commitments. Attendees will leave with practical permission to experiment, plus a simple strategy for turning “distractions” into professional development milestones.
Florian Humblot
Peter Sommerlad
int != safe && int != ℤ
Integer arithmetic in C++ is fraught with subtle pitfalls, ranging from loss of accuracy to outright undefined behavior. What appears to be straightforward arithmetic can easily become a source of bugs, especially when implicit rules start to apply.
This talk explores the risks associated with inappropriate integer operations, with a particular focus on integral promotion and the so-called “usual arithmetic conversions.” These rules, which operate beyond the original operand types, often introduce surprising behavior and can leave even experienced programmers confused.
The session examines relevant MISRA C++ guidelines for integer arithmetic and operations, highlighting both their strengths and their limitations—especially in the context of static analysis.
At the same time, modern C++ offers powerful language features and standard library facilities that make it possible to design safer alternatives. The talk demonstrates how these tools can be combined to achieve well-defined behavior, efficient implementations, and acceptable syntactic clarity when working with integers—acknowledging that some degree of craftsmanship is often required.
This talk does not cover approaches for unlimited-precision arithmetic, which may be necessary in certain application domains.
Learning outcome: Attendees will learn why “just using integers” is rarely trivial in C++, and how to regain control over correctness and intent in integer-heavy code.
Lean, KISS, and Reduce to the Max — Smart Engineering or Just Hype? (With Case Studies)
Modern embedded projects rarely start from scratch. Instead, teams often rely on large SDKs, frameworks, and ecosystems—sometimes consisting of millions of lines of code, countless dependencies, and extensive reference manuals. These solutions promise faster development and richer feature sets. But at what cost?
This talk takes a critical look at the real effort behind such approaches. Memory consumption in the kilobyte or megabyte range, rising development costs, long update cycles for customers, and increasing risks from hard-to-qualify third-party software are common side effects. Using concrete examples from IoT, automotive, consumer appliances, and transportation systems, the session shows how large SDKs and proprietary legacy software can delay delivery dates, complicate debugging, and push teams into a loss of control.
In contrast, the talk explores a deliberately reduced approach: Lean, KISS, and “Reduce to the Max.” Less code often means fewer defects, fewer tests, less qualification effort—and greater transparency. Especially in embedded and IoT projects, it is frequently realistic to fully understand, maintain, and even certify the entire software stack.
The session challenges common pseudo-arguments such as “cleaning up takes too long,” “everyone does it this way,” or “nobody reads 5,000 pages of documentation,” and counters them with a sober cost–benefit analysis. When does a large ecosystem actually pay off? When is a white-paper approach the better choice? And why is the simpler solution so often the more robust one?
Learning outcome: Attendees will learn how to critically assess the real costs of large SDKs and ecosystems—and when a lean, reduced approach leads to more control, robustness, and long-term success in embedded projects.
Thomas Lachnit
Peter Sommerlad
Class Design the MISRA C++ Way
This talk provides a fast-paced overview of the concepts that inspired MISRA C++ guidelines 15.0.1 and 15.0.2, which focus on the correct use of special member functions. It revisits the original design motivations behind these rules and clarifies what problems they are intended to prevent.
The session presents concrete class design examples for manager types and polymorphic base classes—two categories where explicitly defining special member functions is typically required. In contrast, the talk argues that for all other cases, applying the Rule of Zero leads to simpler, safer, and more maintainable class designs.
Learning outcome: Attendees will learn when special member functions are essential for correct class design—and when relying on the Rule of Zero is the safer and more disciplined choice.
Reproducible Linux Systems with Nix & NixOS
Anyone who has ever debugged a Linux setup has likely heard the phrase “But it works on my machine.” What often follows is a long and frustrating search for a missing dependency or an undocumented build step. Nix and NixOS aim to eliminate this entire class of problems.
This talk introduces the core ideas behind Nix and NixOS. Nix enables fully reproducible software packages by isolating builds and requiring all dependencies and build steps to be declared explicitly. NixOS extends this concept to the system level, using a fully declarative configuration to make entire Linux systems reproducible.
The session provides a guided tour through the Nix and NixOS ecosystem, highlighting how these tools support reproducible, long-lived systems and where they fit particularly well in embedded and infrastructure-focused environments.
Learning outcome: Attendees will learn why reproducibility is hard on traditional Linux systems—and how Nix and NixOS make “it works on my machine” a problem of the past.
Florian Pester
Pawel Wiśniewski
Agile testing for microcontroller projects - What are realistic objectives?
At the start of a new microcontroller project, development teams are often faced with an early strategic decision: how should testing be integrated into day-to-day development? Development-accompanying tests offer clear advantages, regardless of whether an agile process explicitly requires them.
Testing early helps uncover defects sooner, improves planning reliability, and avoids the need to “test quality into” the product late in the project. However, introducing tests during development also raises practical questions about effort, priorities, and impact on development speed.
This talk examines how development-accompanying testing can be implemented in practice for microcontroller projects. It introduces different test levels—unit, integration, and system testing—and discusses their feasibility using concrete examples. Typical challenges such as hardware dependencies and timing constraints are addressed from the perspective of a development team.
The session focuses exclusively on embedded microcontroller projects and highlights realistic goals, trade-offs, and limits. It also provides decision-makers with insights into how different testing strategies influence project timelines and outcomes.
Learning outcome: Attendees will learn how to balance early testing and development velocity in microcontroller projects—and where unit, integration, and system testing provide real value without becoming a bottleneck.
Unlocking Edge AI: Seamless Neural Network Deployment with the EmbeddedAICoder
The future of intelligent products depends on effective edge AI deployment. Yet bringing neural networks to resource-constrained embedded devices often feels like an insurmountable challenge—especially in safety-critical domains where predictability and reliability are mandatory.
This talk addresses these challenges head-on by introducing EmbeddedAICoder, a neural network code generator designed specifically for embedded systems. The session explores the practical realities of deploying AI where every byte of memory and every clock cycle matters.
The presentation begins with real-world use cases for AI in safety-critical environments, ranging from automotive systems to industrial automation. These examples highlight why efficiency, determinism, and robustness are non-negotiable requirements for embedded AI.
At the core of the talk are the technical solutions provided by EmbeddedAICoder. The session demonstrates how the tool generates highly optimized, platform-independent C code for neural network inference, resulting in significant performance gains and a substantially reduced memory footprint.
Attendees will learn about advanced strategies for runtime optimization and efficient memory usage, as well as how re-parameterization can be handled in a controlled way to ensure predictable and robust model behavior.
Beyond performance considerations, the talk also addresses security and system integration. It shows how EmbeddedAICoder supports seamless integration into larger embedded systems, ensuring that AI components meet strict security requirements and coexist reliably with other software modules.
Learning outcome: Attendees will learn how to deploy neural networks on resource- and safety-constrained embedded systems—and how code generation, optimization strategies, and careful integration make edge AI practical, efficient, and secure.
Benjamin Wagner
Benjamin Wagner is a senior AI compiler engineer at Robert Bosch GmbH , specializing in embedded AI and the deployment of neural networks for safety-critical systems. With a strong background in software engineering and machine learning, he works at the intersection of ML and embedded technology. Benjamin is a key contributor to EmbeddedAICoder, focusing on performance optimization for resource-constrained devices and the secure integration of AI into real-world embedded systems.
Max Hoffmann
Designing Misuse Resistant APIs - Learning from Security Mistakes
tba
Working With Cache vs Memory Safety
In recent years, memory safety in C and C++ has become one of the most debated topics in systems engineering. At the same time, there is another perennial pain point that never really goes away: cache invalidation. This talk connects both worlds and asks a practical question: what happens to memory safety once caches and cache maintenance enter the picture?
The session looks at when cache invalidation is actually required in embedded and low-level systems, how it can go wrong, and what risks it introduces for correctness and safety. Using real-world engineering context, the talk highlights the kinds of issues that show up when performance constraints, cache behavior, and safety requirements collide.
Learning outcome: Attendees will learn when cache invalidation becomes necessary, how it can undermine assumptions about memory safety, and what disciplined practices help keep systems correct, predictable, and secure.
Piotr Grygorczuk
Detlef Vollmann
Detlef Vollmann has more than 40 years of experience with C++ and over 35 years in embedded systems. He is an active member of the C++ standardization committee, primarily contributing to the concurrency working group, and a contributor to the C++ performance report. He currently works independently as a consultant, focusing on deeply embedded software systems.
Concurrent Queues for Embedded Systems: What C++29 Will Bring
C++11 introduced standardized multithreading, but left out a key building block needed for practical use: concurrent queues. This gap is finally being addressed. While a concrete implementation, std::bounded_queue, is planned for C++29, its reliance on dynamic memory allocation makes it less suitable for many embedded systems.
More important than the concrete container itself are the new queue concepts that the C++ Standard will introduce: basic-concurrent-queue, concurrent-queue, and async-concurrent-queue. These concepts define clear expectations and guarantees that are highly relevant in resource-constrained and real-time environments.
This talk explores how these concurrent queue concepts apply to embedded systems, what kinds of implementations they enable, and what limitations they impose. Based on these constraints, the session derives what qualities engineers can realistically expect from production-ready implementations.
Learning outcome: Attendees will learn how upcoming C++29 concurrent queue concepts impact embedded software design, what guarantees they provide, and how to evaluate and implement queue abstractions without relying on dynamic memory.
Something on Sender/Receiver
Sender/Receiver is an upcoming abstraction for asynchronous execution in modern C++, designed to provide a structured and composable model for concurrency. While it promises greater clarity and flexibility compared to traditional approaches, its practical implications—especially for embedded systems—are not always obvious.
This talk examines key aspects of the Sender/Receiver model and investigates where it introduces real challenges and where common concerns may be overstated. Rather than serving as an introduction, the session focuses on the deeper questions that arise once the basic model is understood.
Particular attention is given to the relevance of Sender/Receiver for embedded systems. The talk explores what kinds of implementations are feasible under embedded constraints and what benefits this abstraction can realistically provide in resource-constrained environments.
Learning outcome: Attendees will gain a clearer understanding of the practical implications of Sender/Receiver for embedded systems and will be able to evaluate when and how this abstraction can be applied effectively.
Detlef Vollmann
Detlef Vollmann has more than 40 years of experience with C++ and over 35 years in embedded systems. He is an active member of the C++ standardization committee, primarily contributing to the concurrency working group, and a contributor to the C++ performance report. He currently works independently as a consultant, focusing on deeply embedded software systems.
Odin Holmes
The Nerd, not the god
tba
tba
The emBO++ Badge: Hardware, Firmware, and Hacking
Every emBO++ comes with its own conference badge—but this badge is more than just a name tag. It is a fully hackable embedded system, designed to be explored, modified, and extended by attendees.
This talk walks through the design and implementation of the emBO++ badge, including its hardware features, firmware environment, and the practical decisions behind its printed circuit board layout. The session explains how the badge was built to be approachable while still offering meaningful opportunities for experimentation.
Attendees will also learn how to get started developing their own applications using a prepared Docker-based toolchain that includes a customized GCC with freestanding standard library additions, enabling modern C++ development on resource-constrained hardware.
Learning outcome: Attendees will learn how the emBO++ badge was designed, how to set up the development environment, and how to start hacking on the hardware using modern embedded C++ tools.
Paul Bendixen
Anna-Lena Marx
Beyond the Release: Managing Long-Term Risk and Compliance in Embedded Linux with Yocto
Future embedded systems will be judged less by the release date and more by their long-term resilience and security. For many manufacturers, the shift from “ship it once” to continuous lifecycle management is a major operational challenge. Regulations such as the EU Cyber Resilience Act (CRA) are formalizing that shift, requiring ongoing vulnerability management and extending responsibility across the supply chain.
This talk argues that a robust and reproducible build system is the cornerstone of any sustainable product strategy in this new environment. It explains how the Yocto Project provides a framework for building maintainable embedded Linux systems that can be supported over years, not just until the next product launch.
The session explores what “lifecycle-ready” actually means in practice: full-stack patchability for targeted CVE fixes, reproducible builds to keep legacy devices maintainable, and automated Software Bill of Materials (SBOM) generation to support regulatory transparency.
Attendees will leave with actionable strategies for implementing lifecycle-aware embedded development and for transforming existing product portfolios to meet evolving regulatory requirements.
Learning outcome: Attendees will learn how to use Yocto to enable long-term maintenance, targeted security fixes, and compliance-ready transparency, and how a reproducible build system becomes a practical foundation for lifecycle management.
