The Embedded Frontier

Jacob Beningo concludes his embedded software modernization framework series by discussing the establishment of metrics scoreboards for embedded systems development. He explores various metrics categories including code quality, performance, and security, with a deep dive into cyclomatic complexity as a powerful but underutilized metric among embedded developers.Key Takeaways:• Metrics scoreboards provide visibility into quality, predictability, and improvement opportunities in embedded development• Things that get measured get managed - tracking metrics helps identify root causes of development problems• Avoid vanity metrics like commit frequency; focus on metrics aligned with project goals• Cyclomatic complexity measures independent paths through functions and should stay below 10 for maintainable code• Seven key metrics categories: code quality, reliability/safety, testing, performance, resource utilization, process/productivity, and security• AI tools can significantly simplify dashboard creation and metrics analysis automation• Code coverage is valuable but can be gamed - ensure tests actually validate functionality, not just execute code• Compiler warnings should be eliminated or documented; aim for zero warnings in production code• Metrics trends are more important than point-in-time values for identifying code quality decay• Modern tools like Segger SystemView and Percepio Tracealyzer enable real-time performance metrics collection

Jacob Beningo explores how artificial intelligence and machine learning can modernize embedded systems development, sharing practical examples and dispelling myths about AI's applicability to embedded development. He demonstrates how AI can accelerate development workflows, from requirements gathering to code generation, while emphasizing an iterative, agile approach rather than fully autonomous AI development.Key Takeaways:• AI can provide 2x performance improvements for embedded development teams through automation and assistance• Use AI iteratively in small problem spaces rather than attempting fully autonomous agentic workflows• Create specialized AI tools for specific embedded systems domain areas like requirements gathering and code reviews• AI can help reduce debugging time, which typically consumes 20-40% of development effort• Machine learning inference can run effectively on resource-constrained 16-bit microcontrollers• Teams ignoring AI adoption risk being left behind as the technology becomes mainstream in embedded development• Focus on identifying repetitive daily tasks that can benefit from AI automation• Modern microcontrollers with neural processing units enable sophisticated on-chip machine learning applications• AI works best as a productivity multiplier rather than a replacement for embedded developers• Start with low-hanging fruit like debugging assistance and code review automation

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

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

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

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

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

This podcast episode explores step three of modernizing embedded software development: adopting DevOps practices to solve the critical problem of late and over-budget project delivery in embedded systems. Host Jacob Beningo discusses the four core DevOps principles, presents a compelling case study of the Ariane 5 rocket failure that cost $500 million, and provides practical guidance for implementing CI/CD pipelines to improve software quality and delivery speed.Key Takeaways:• Only 35% of embedded development teams deliver projects on time, with most running 3-6 months late• DevOps focuses on incremental value delivery, improved collaboration, automation, and continuous improvement• The Ariane 5 rocket explosion ($500 million loss) could have been prevented with proper integration testing and CI/CD practices• Start DevOps implementation with automated builds using containers to create unified development environments• Enforce code quality and standards automatically within CI/CD pipelines using tools like Misra C/C++• Implement regression testing to catch bugs early when they're easier and less costly to fix• Use metrics analysis to automatically identify tight coupling and potential bug locations in code• Artifact management ensures traceability and ability to deliver specific software versions to customers• Deployment automation should at minimum enable automatic hardware testing, even if not direct customer deployment• DevOps creates a value feedback loop between companies and customers through observability and telemetry

NXP's Brendan Slade discusses why major semiconductor companies are investing heavily in Zephyr RTOS, exploring how this open-source real-time operating system is transforming embedded development for IoT and edge computing applications. The conversation covers NXP's role as a founding platinum member of the Zephyr project, practical advice for developers evaluating RTOS options, and the collaborative ecosystem driving innovation in microcontroller software development.Key Takeaways:• Zephyr provides integrated middleware beyond just a kernel, unlike traditional RTOS options like FreeRTOS• NXP was a founding platinum member of Zephyr project to drive strategic direction for microcontroller enablement• Device tree configuration is the biggest learning curve hurdle, but once mastered, enables easy hardware portability• The Zephyr project has ~50 members including major OEMs from automotive, industrial, and consumer sectors• All code contributions require pull requests, tests, and peer review - no single company can force changes• Power management infrastructure is built into Zephyr drivers, enabling faster development of low-power applications• Training resources are available from multiple partners, and NXP offers Visual Studio Code extensions for easier development• The MCX N947 Freedom board (~$30) provides an excellent platform for exploring Zephyr capabilities• Future focus areas include AI enablement, cybersecurity compliance, and higher-level application frameworks• Companies should invest in device tree training first, then start with evaluation boards to assess portability benefits

SummaryIn this episode of the Embedded Frontier Podcast, Jacob Beningo dives into modernizing embedded software architecture—the second step in his seven-step framework for building faster, smarter firmware. He explores why most legacy architectures turn into “giant balls of mud,” how tightly coupling software to hardware holds teams back, and the four architectural dimensions you must consider: characteristics, principles, decisions, and structure.Jacob also shares controversial yet practical perspectives, including his philosophy that “there is no hardware, only data,” and why data—not hardware—should dictate design. From architectural decision records (ADRs) to adopting a top-down approach with the 4C model, this episode provides actionable insights for designing scalable, maintainable, and future-ready embedded systems.TakeawaysAvoid spaghetti code: Emergent architectures rarely scale; intentional design upfront is critical.Define architecture characteristics: Select 3–7 key qualities (e.g., modularity, scalability, robustness) to guide decisions.Establish design principles: Adopt philosophies like “data dictates design” and “there is no hardware, only data.”Capture architectural decisions: Use ADRs to record trade-offs and prevent wasted rework.Think top-down: Use the 4C model (Context → Containers → Components → Classes) instead of bottom-up hardware-first design.Abstract hardware: Decouple hardware details from application logic for scalability and reusability.Prepare for change: Modern IoT and ML-driven systems demand flexible, forward-looking architectures.Keywordsembedded systems, software architecture, modularity, scalability, ADR, design principles, data dictates design, hardware abstraction, IoT, DevOps, test-driven development, modern firmware, top-down design, containers, 4C model

In this episode of the Embedded Frontier podcast, Jacob Beningo and Kyle Dando from NXP discuss the modernization of embedded software and firmware, focusing on the MCU Xpresso SDK. They explore the significant changes made to the SDK, including the adoption of CMake and KConfig, the introduction of West for managing software repositories, and the overall impact on developer workflows. The conversation also covers the migration path for existing users and future trends in embedded software development, emphasizing the importance of user feedback in shaping the SDK's evolution.Takeaways- Modern build systems are essential for embedded software development.- The MCU Xpresso SDK packages low-level drivers and middleware for ease of use.- Accessibility improvements were a primary focus in SDK modernization.- CMake was adopted for its universal build capabilities and customer demand.- West allows for efficient management of software from multiple repositories.- KConfig simplifies project configuration and dependency management.- Developers can choose between command line and IDE workflows.- Migration to the new SDK is designed to minimize disruption for users.- Future trends include support for new operating systems and ecosystems.- User feedback is vital for continuous improvement of the SDK.

In this episode of the Embedded Frontier Podcast, Jacob Beningo discusses the importance of modernizing build systems in embedded software development. He outlines a seven-step framework for developing faster and smarter firmware, focusing on the need to overhaul build systems to keep pace with contemporary development practices. The conversation covers containerization, the adoption of tools like CMake and West, and the integration of AI technologies to enhance build processes and ensure flexibility and scalability in software development.Takeaways- Overhauling your build system is crucial for modern development.- Build systems must adapt to contemporary software practices.- Containerization provides a consistent build environment.- CMake offers flexibility and modularity in builds.- West helps manage multiple repositories effectively.- Modern build systems should integrate with CI/CD workflows.- Flexibility in workflows enhances developer productivity.- AI can assist in transitioning to modern build systems.- Scalability is essential for long-term software projects.- A modern build system reduces stress and increases efficiency.Keywordsembedded systems, build system, DevOps, CMake, containerization, software development, AI, firmware, modern architecture, CI/CD

SummaryIn this episode of the Embedded Frontier Podcast, Jacob Beningo introduces a comprehensive framework for modernizing embedded systems development. He discusses the importance of adapting to modern techniques in firmware development, emphasizing the need for a shift in workflows, architectures, and tools. The episode outlines a seven-step process that includes modernizing build systems, improving software architecture, implementing DevOps practices, embracing test-driven development, leveraging simulation, adopting AI and machine learning, and establishing a metrics scoreboard to track progress. Each step is designed to help teams develop faster and smarter firmware, ultimately leading to more efficient and effective embedded systems development.TakeawaysModernizing firmware is essential for efficient development.The seven-step modernization framework includes build systems, architecture, DevOps, testing, simulation, AI, and metrics.Modern build systems should support various developer tools and environments.Software architecture must be scalable and flexible, separating application code from hardware.DevOps is crucial for improving collaboration and speeding up development cycles.Testing should be prioritized, with an emphasis on test-driven development (TDD).Simulation can help developers test application code without hardware dependencies.AI and machine learning can enhance both on-chip processing and development workflows.Metrics are essential for tracking progress and identifying areas for improvement.The framework aims to help teams deliver better products on time and within budget.Keywordsembedded systems, firmware development, modernization framework, build systems, DevOps, test-driven development, simulation, AI, machine learning, metrics

In this episode of the Embedded Frontier podcast, Jacob Beningo explores the evolving role of artificial intelligence (AI) in embedded systems development. He discusses the potential applications of AI, including code review, documentation, and generating code, while emphasizing the importance of adopting AI technologies to enhance productivity and efficiency in the field. Beningo also addresses the challenges and risks associated with AI, advocating for its integration into development workflows to stay competitive in the industry.TakeawaysAI has a unique role to play in embedded systems development.Documentation is a critical area where AI can assist developers.AI can help automate code reviews, making them more efficient.Using AI for generating code can speed up the prototyping process.AI can help document architectural decisions and trade-offs.The rapid evolution of AI technology presents both opportunities and risks.AI can serve as an augmentation tool for developers, enhancing their capabilities.Understanding how to effectively prompt AI is crucial for getting desired results.AI can help reduce technical debt by improving documentation practices.The integration of AI into workflows can lead to significant productivity gains.

SummaryIn this episode of the Embedded Frontier, Jacob Beningo discusses the key trends observed at Embedded World 2025, focusing on the integration of commercial tools with modern workflows, the rise of Zephyr as a dominant RTOS, the pervasive influence of AI in embedded systems, the necessity of multi-core processors, and the mainstream adoption of DevOps practices. Beningo emphasizes the importance of adapting to these trends to enhance development efficiency and product reliability.TakeawaysCommercial tools are starting to support open source development.Zephyr is becoming a dominant player in the embedded systems industry.AI technologies are increasingly being integrated into embedded devices.Multi-core processors are becoming essential for complex IoT applications.DevOps practices are being adopted more widely in embedded development.Security and compliance must be automated in development workflows.The integration of AI can significantly enhance embedded system capabilities.Open source and commercial tools can work together effectively.Modern workflows are essential for efficient embedded software development.The industry is evolving rapidly, and developers must adapt to stay competitive.Keywordsembedded systems, trends, Zephyr, AI, multi-core processors, DevOps, modern workflows, commercial tools, open source, Embedded World 2025

SummaryIn this conversation, Jacob Beningo interviews John Taylor about his extensive experience in embedded systems and his new book, 'The Embedded Project Cookbook.' They discuss the inspiration behind the book, its target audience, and key themes such as the importance of building and testing software before hardware. John shares insights on challenges in requirements gathering, the use of a reference design, and the transition from C to C++ in embedded projects. They also explore future trends in the industry, particularly the impact of AI, and conclude with key takeaways from the book.TakeawaysJohn Taylor has over 30 years of experience in embedded systems.The Embedded Project Cookbook was inspired by the need for better documentation and processes.The primary audience for the book includes software architects and tech leads.Building and testing software before hardware can save time and improve code quality.Requirements gathering is a critical yet challenging aspect of embedded systems development.The GM 6000 digital heat controller serves as a relatable reference design in the book.Source code and frameworks provided in the book can help developers bootstrap their projects.C++ offers advantages in type safety and encapsulation for embedded systems.AI is becoming part of embedded workflows, but its understanding of embedded systems is still limited.Quality in projects requires planning and discipline beyond just writing code.KeywordsEmbedded Systems, Embedded Project Cookbook, Software Development, Requirements Gathering, C++, AI in Embedded Systems, Software Architecture, Project Management, Hardware Development, John Taylor

In this episode of Embedded Frontier, Jacob Beningo discusses the top trends in embedded systems for 2025. He highlights the increasing role of AI and machine learning, the dominance of open-source software, the critical importance of security, and the ongoing relevance of programming languages like C and C++. Beningo also emphasizes the rise of simulation technologies, the integration of DevOps and observability, and the expansion of edge AI, providing insights into how these trends will shape the future of embedded systems development.Takeaways·      AI will enhance embedded systems development.·      Machine learning applications are still underutilized.·      Open-source software is becoming increasingly dominant.·      Security is a top priority for embedded systems.·      C remains the most widely used programming language.·      Simulation technologies will modernize development processes.·      DevOps practices are essential for improving software quality.·      Edge AI will allow for local data processing.·      Modern programming languages will see increased adoption.·      2025 will bring significant changes to embedded systems.Keywordsembedded systems, AI, machine learning, open source, security, programming languages, DevOps, edge AI, simulation technologies

Curious about the future of embedded systems? In this episode, Jacob Beningo is joined by Shawn Prestridge from IAR Systems to tackle the pressing challenges developers face today. From real-world insights into AI’s role in embedded devices to the overlooked pitfalls of security in connected systems, Shawn shares practical lessons learned from his decades in the field. Whether you’re interested in how AI can transform your development process, or you're navigating the complexities of modern code quality and security, this conversation offers actionable strategies that every embedded developer needs. Don't miss this chance to learn from the cutting edge of embedded systems development.

In this episode, Jacob Beningo interviews François Baldassari, Memfault CEO, about IoT security compliance demands. They discuss embedded manufacturers' readiness for new security regulations, the challenges they face, and potential solutions. They also explore the differences between the EU's Cyber Resilience Act and the US's Cyber Trust Mark. François emphasizes the importance of OTA updates, using open-source software, and building security teams within hardware companies. He also highlights the need for collecting the right data and observability to improve security posture.TakeawaysEmbedded manufacturers are not fully ready for new IoT security compliance demands.Regulatory frameworks like the EU's Cyber Resilience Act and the US's Cyber Trust Mark are coming into effect and will require certification of cybersecurity guidelines.Challenges include the uncertainty of the regulations, the additional costs and effort required, and the lack of established infrastructure and best practices.Recommendations for compliance include implementing OTA updates, using open-source software, adopting SBOM scanning, and ensuring observability of devices.AI is not currently a solution for compliance, but it may play a role in the future as more data is collected and analyzed.Joining the conversation around open-source products and following security best practices can help improve device security.

SummaryIn this conversation, Jacob and Daniel Situnayake discuss the future of AI and machine learning in embedded software development. They explore the challenges and opportunities of implementing AI and machine learning at the edge, and how tools like TensorFlow Lite for Microcontrollers and Edge Impulse are making it easier for developers to deploy models on resource-constrained devices. They also discuss the importance of balancing model accuracy with resource constraints and the potential for AI-generated models in the future. Overall, the conversation highlights the growing interest and potential of AI and machine learning in the embedded space.KeywordsAI, machine learning, embedded software development, TensorFlow Lite, Edge Impulse, resource constraints, model accuracy, AI-generated modelsTakeawaysAI and machine learning are being increasingly applied to embedded software development, opening up new possibilities for edge devices.Tools like TensorFlow Lite for Microcontrollers and Edge Impulse are making it easier for developers to implement AI and machine learning on resource-constrained devices.Balancing model accuracy with resource constraints is a key consideration in embedded AI development.The future of embedded AI and machine learning holds the potential for AI-generated models and more sophisticated applications at the edge.

In this episode, Jacob Beningo discusses the importance of debugging in embedded development and shares several techniques to decrease debugging time. He highlights the statistic that development teams spend 20-40% of their time debugging, which equates to 2.5-4.5 man-months of development. Beningo emphasizes the use of test-driven development (TDD) as a way to prevent bugs and decrease debugging time. He also recommends mastering debugging techniques for microcontrollers, using profiling and monitoring tools, employing assertions, and utilizing on-host simulation. Beningo concludes by encouraging listeners to track their debugging time and implement strategies to decrease it.TakeawaysDevelopment teams spend 20-40% of their time debugging, which can equate to 2.5-4.5 man months of development.Test-driven development (TDD) can help prevent bugs and decrease debugging time.Mastering debugging techniques for microcontrollers and utilizing profiling and monitoring tools can improve debugging efficiency.Using assertions and on-host simulation are additional techniques to decrease debugging time.Tracking debugging time and implementing strategies to decrease it can lead to increased productivity and innovation.

SummaryIn this episode, Jacob Beningo interviews Frank Herta, the CEO of Curtail Incorporated, about the risks of zero-day attacks in open source software. They discuss the importance of DevSecOps and the need for comprehensive security measures. Frank shares his background in security and how his company is working on detecting zero-day bugs. They also explore the vulnerabilities of open source software and the potential for third-party supply chain attacks. Open source software testing differs from proprietary software testing in terms of who is responsible for testing. Open source projects have their own testing processes, but it's important for software developers to test the open source software in the context of their own applications. DevSecOps is a cultural shift that aims to integrate security and testing throughout the software development process. It involves early testing, collaboration between teams, and a focus on security from the beginning. The nature of threats in open source software is changing, with third-party attacks on repositories becoming a major concern. Complacency and slow response times are also issues that need to be addressed. Developers and managers using open source software should follow security best practices, stay updated on vulnerabilities, and actively test their software. Curtail is working on innovative solutions to analyze and compare different open source packages for better security.Keywordsembedded systems, open source software, zero-day attacks, DevSecOps, security measures, vulnerabilities, supply chain attacks, open source software, testing, proprietary software, DevSecOps, third-party attacks, complacency, response time, security best practices, CurtailTakeawaysOpen source software is prevalent in the industry, with 70-90% of software being open source-based.Companies and their customers are at risk of zero-day attacks due to the widespread use of open source software.Historical examples like Heartbleed and Apache Struts have demonstrated the vulnerabilities of open source software.DevSecOps is crucial for integrating security measures throughout the software development lifecycle.Comprehensive testing, documentation, and active involvement in open source communities can help mitigate security risks.Comparing different versions of open source software and monitoring network behavior can help detect changes and potential vulnerabilities. Open source software should be tested in the context of the specific application it will be used in.DevSecOps is a cultural shift that integrates security and testing throughout the software development process.Third-party attacks on open source repositories are a growing concern.Complacency and slow response times can lead to security vulnerabilities.Developers and managers should follow security best practices and actively test their software.Curtail is working on innovative solutions to analyze and compare different open source packages for better security.

In this episode, Jacob Benningo discusses the importance of DevOps in the embedded software development industry. He emphasizes the need for DevOps to improve project delivery, efficiency, and product quality. Jacob provides insights into the principles of DevOps, the implementation of CI/CD pipelines, and the impact of DevOps on software development processes. He also shares actionable steps for implementing DevOps in embedded software development.TakeawaysEmbedded DevOps is crucial for improving project delivery, efficiency, and product quality in embedded software development.The principles of DevOps include incremental value delivery, improved collaboration, automation, and continuous improvement.Implementing a CI/CD pipeline is essential for automating software development processes and improving code quality.DevOps transforms how embedded systems are developed, leading to cleaner and more efficient software development processes.Actionable steps for implementing DevOps include defining an ideal pipeline, creating a roadmap, and setting up a DevOps framework for remote software building.

Carsten Gregerson shares his background in the embedded systems industry and how he got into it. He discusses his work at Nabto, a company that provides remote access to small devices using peer-to-peer technology. Carsten then delves into the topic of real-time operating systems (RTOS) and the battle for open-source RTOS. He explains the difference between a real-time operating system and a high-end operating system and how the introduction of the internet into embedded devices has increased the need for RTOS. He also discusses the consolidation happening in the industry with the acquisition of RTOS by big tech companies. Jacob shares his thoughts on Zephyr, an open-source RTOS, and its place in the market. He also explores the challenges of adopting Zephyr for embedded developers and the potential future of embedded development with the integration of interpreters and AI.

SummaryThis podcast episode discusses using bare metal and real-time operating systems (RTOS) in embedded systems development. It highlights the steady adoption of RTOS in the industry and the continued relevance of bare metal development, particularly in 8-bit microcontrollers. The episode explores the future of RTOS, including the rise of open-source options like Eclipse ThreadX and Zephyr. It also discusses different models for designing RTOS-based applications, such as the independent, dependent, and POSIX interface models. The episode concludes by encouraging listeners to stay informed about RTOS advancements and learn how to architect applications using RTOS effectively.TakeawaysBare metal development and real-time operating systems (RTOS) are both relevant and widely used in embedded systems development.RTOS adoption has remained steady, with about two-thirds of embedded systems using an RTOS and the remaining third using bare metal techniques.The future of RTOS includes the rise of open-source options like Eclipse ThreadX and Zephyr, which offer commercial-quality RTOS at open-source costs.Different models for designing RTOS-based applications include the independent model, dependent model, and POSIX interface model.

In this conversation, Max (Clive) Maxfield discusses his journey into embedded systems and the industry's evolution. He highlights the fascinating developments in AI and its impact on embedded systems. Max also explores how AI can benefit embedded software and hardware developers and the potential applications of AI with sensors. He discusses the advancements in semiconductor technology to keep pace with AI. Finally, Max shares recommendations for managers and developers on adopting AI technologies into their development workflows. In this conversation, Max the Magnificent discusses various aspects of AI and its applications in embedded systems and beyond. He emphasizes the importance of understanding the power of data and cloud computing and the potential of generative AI. Max also shares insights on simplifying website chatbots using AI and highlights the need for managers to stay informed about AI advancements. The conversation concludes with discussing the future of AI collaboration and the importance of viewing AI as a tool rather than a replacement.TakeawaysEmbedded systems have evolved significantly over the years, with AI becoming a prominent feature in the industry.AI offers exciting possibilities for embedded software and hardware developers, enabling them to enhance their products and improve efficiency.Sensors are crucial in integrating AI into embedded systems, allowing for advanced functionalities and applications.The semiconductor industry is continuously advancing to meet the demands of AI, with smaller technology nodes and specialized chips.To adopt AI technologies effectively, managers and developers should stay updated on the latest developments, explore available tools and resources, and consider their projects' specific needs and applications. Tiny ML is a valuable introduction to embedded systems and can be used for applications such as predictive maintenance.Data is a crucial asset, and leveraging cloud computing and AI can enhance its value and provide powerful insights.Partnering with companies specializing in AI implementation can help navigate the complexities of AI integration.Generative AI is becoming increasingly prevalent, with applications ranging from chatbots to automated summaries.AI tools like Chat Simple can simplify the process of implementing chatbots on websites.

In this episode, Jacob discusses trends in the embedded software industry and provides techniques and practices for staying relevant and successful. The trends include leveraging AI to develop embedded systems, improving CI/CD processes, phasing out C for C++ or Rust in 32-bit applications, adopting developer-centric workflows, moving to higher levels of abstraction, and using POSIX APIs in real-time operating systems. The techniques covered are model-based design, containerizing and virtualizing development processes, and adopting DevOps and CI/CD.TakeawaysLeveraging AI can improve efficiency, code generation, debugging, and code reviews in embedded software development.Improving CI/CD processes can enhance automation, reliability, and deployment of embedded software.Phasing out C for C++ or Rust in 32-bit applications can provide more modern and scalable development options.Adopting developer-centric workflows allows for customization and efficiency in the development process.Moving to higher levels of abstraction enables hardware independence and scalability in embedded software development.Using POSIX APIs in real-time operating systems provides flexibility and portability in application code.Model-based design, containerization, and virtualization are effective techniques for efficient and scalable development processes.Adopting DevOps and CI/CD improves collaboration, automation, and efficiency in embedded software development.