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
