The Embedded Frontier

#024 - Simulating Embedded Systems

In this episode, Jacob explores simulation for embedded systems as the seventh step in modernizing embedded development. He discusses functional simulation, on-chip simulation, and software architecture simulation, demonstrating how proper abstraction enables developers to validate code before hardware is available. Jacob provides a practical demonstration of simulating a push button module with debouncing algorithms, showing how modern software architecture can dramatically improve embedded system development workflows. Key Takeaways: • Functional simulation allows embedded developers to validate code without physical hardware by abstracting low-level hardware dependencies • Modern embedded architecture should decouple application code from hardware using zero-cost or low-cost abstractions • Push button debouncing serves as an excellent example for learning simulation techniques that every embedded engineer can relate to • On-chip simulation tools like QEMU and Renode can simulate processor-level instructions but may be incomplete for microcontroller peripherals • State machine simulation enables visual validation of system behavior before code deployment • AI tools can now rapidly generate simulation code, making functional simulation more accessible than ever • Socket communication provides deterministic and fast data exchange for functional simulation environments • Start simple with side projects like weather stations or button modules to learn simulation techniques • Legacy systems can be gradually refactored to support simulation by decoupling high-risk areas from hardware dependencies • Simulation enables faster development cycles and reduces dependency on hardware availability during early development phases

#023 - Modernization Embedded Systems with Test-Driven Development

In this episode, embedded systems expert Jacob Beningo explores test-driven development (TDD) as the fourth step to modernize embedded software development. He addresses common misconceptions that TDD doesn't work for embedded developers, demonstrates how proper software architecture enables effective testing, and explains the mental shift required to write tests before production code for higher quality, more reliable embedded systems. Key Takeaways: • Test-driven development requires writing tests first, then production code to make tests pass, which feels counterintuitive initially but improves over time • Properly architected embedded software with decoupled hardware layers makes TDD highly effective for application code • The mental adjustment to TDD takes several weeks but results in faster overall development and higher code quality • TDD provides immediate feedback when changes break existing functionality through regression testing • Multiple testing types are available: unit, integration, system, regression, performance, and user acceptance testing • System-level TDD can drive development from user requirements down to individual components • AI tools can accelerate TDD processes while maintaining rigorous testing standards • A simple push button module can require 98 tests and 4,000 checks for complete validation • 100% test coverage is a worthy goal but doesn't guarantee bug-free code • TDD initially feels slower but dramatically reduces debugging time and improves long-term development velocity

#022 - 2026 Embedded Systems Trends

Embedded systems expert Jacob Beningo explores five major industry trends for 2026, focusing on how AI-assisted development, security requirements, and platform-based engineering are reshaping embedded software development. This comprehensive analysis covers emerging technologies and methodologies that microcontroller-based system developers need to understand to stay competitive in the evolving embedded systems landscape. Key Takeaways: • Use AI to create custom development tools rather than just copying code, potentially saving months of development time annually • Security is no longer optional due to regulations like CRA - threat modeling and secure boot processes are now requirements • Platform-based engineering is driving adoption of modern tools like CMake, VS Code, and Zephyr RTOS across silicon vendors • C++ continues gradual adoption in embedded systems, growing from 3% to 30% market share over 20 years while C remains dominant • Functional simulation techniques can reduce debugging time by 50%, saving significant development resources when combined with AI tools • Edge AI and tiny ML are poised for resurgence as microcontrollers gain more compute power and specialized processing units • DevOps adoption varies widely, with basic Git and compilation pipelines being minimum requirements for modern development • West manifest tools are becoming important for managing complex multi-repository platform projects • AI should enhance expertise rather than replace fundamental embedded systems knowledge and skills • Copy-paste culture threatens to erode deep embedded systems expertise needed for solving complex hardware-software integration issues

#021 - From Pray and Patch to Proactive: Modernizing Embedded Security

Visit our sponsor's website to learn more about their embedded security solutions at https://www.RunSafeSecurity.com/jacob  This episode explores the critical shift from reactive "patch and pray" security approaches to proactive embedded security strategies. Host Jacob discusses common vulnerabilities in embedded systems, real-world security threats from nation-state actors, and practical tools and processes developers can implement to secure their devices throughout the entire development lifecycle. Key Takeaways: • Memory exploits (buffer overflows, out-of-bounds reads/writes, use-after-free) are the most common embedded system vulnerabilities • Nation-state actors like Voltaifun are actively targeting critical infrastructure through embedded devices • Even simple connected devices like $20 coffee makers pose significant security risks through botnets and grid manipulation • Supply chain attacks have risen 700% in recent years, requiring secure programming and signed keys throughout manufacturing • Threat Model Security Analysis (TMSA) should be performed upfront to identify critical data and potential attack vectors • Hardware isolation using ARM TrustZone, multi-core processors, or memory protection units provides essential security layers • Software Bill of Materials (SBOM) helps track open source components and monitor for newly discovered vulnerabilities • Static and dynamic analysis tools should be integrated into CI/CD pipelines for continuous security monitoring • Security must be considered throughout the entire device lifecycle, from design to end-of-life decommissioning • Proactive security approaches using runtime protection tools are more effective than reactive patching strategies

#020 - Embedded DevOps with GitLabs Darwin Sanoy

In this episode of the Embedded Frontier podcast, host Jacob interviews Darwin from GitLab's field CTO office about the adoption and implementation of DevOps practices in embedded systems development. They explore the unique challenges embedded developers face when modernizing their workflows, including managing complex codebases with hundreds of millions of lines of code, compliance requirements, and the critical differences between software-only products and embedded systems where software is just one component of the final product. Key Takeaways: • Embedded systems require different DevOps approaches than pure software products since shipping software doesn't mean shipping the final product • Modern vehicles contain 650 million lines of code in 2025, up from 200 million just five years ago, creating new complexity management challenges • Three categories of embedded systems each need different DevOps strategies: digital disruptors, stable machines, and functional safety systems • Containerized builds and shared development environments eliminate "works on my machine" problems and create reproducible, auditable builds • Software supply chain security through Solza attestation provides traceability from source code to final artifacts • Compliance as code can automate many regulatory requirements like ISO 26262 and MISRA C++, reducing manual bottlenecks • AI integration at the platform level helps embedded developers onboard to DevOps without becoming DevOps experts • Continuous delivery (creating release-ready firmware) is more appropriate for embedded than continuous deployment to production • Automated testing and QA are crucial to prevent manual processes from becoming the limiting factor in development speed • Over-the-air updates in embedded systems require managed deployments with higher reliability than cloud container replacements