In this episode, Jeff and Luca discuss trunk-based development, a software development practice where developers merge their work into the main branch (trunk) frequently - at least daily. They explain how this approach differs from traditional branching models like GitFlow, and address common objections and concerns. The hosts emphasize that while trunk-based development may seem risky, it actually reduces risk by exposing integration problems early and forcing teams to implement good engineering practices like automated testing and feature flags.The discussion highlights how trunk-based development acts as a "forcing function" that encourages better development practices, smaller changes, and more frequent collaboration between team members. They explain that while this approach originated in web development, it's equally applicable to embedded systems. The hosts cite research from the book "Accelerate" showing that trunk-based development is a predictor of high-performing software teams.The episode concludes by emphasizing that most objections to trunk-based development actually point to underlying process issues that need to be addressed, and that the benefits of early integration and feedback outweigh the perceived downsides.Timestamps:00:00:00 - Introduction and topic overview00:03:00 - Basic version control concepts and branching00:08:00 - Definition and principles of trunk-based development00:13:00 - Feature flags explanation and implementation00:20:00 - Common objections to trunk-based development00:27:00 - Application to embedded systems00:34:00 - Benefits of trunk-based development00:40:00 - Impact on team dynamics and collaboration00:47:00 - Research backing and evidence from "Accelerate"Shownotes / Links:MinimumCD: https://minimumcd.org/Accelerate: https://www.goodreads.com/book/show/35747076-accelerateThe nvie branching model: https://nvie.com/posts/a-successful-git-branching-model/ You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click here 

Mitch English, Product Development Team Lead at Inertia, dives into the QP framework for embedded systems. He discusses his experience implementing QP in a medical device project, emphasizing its efficiency in managing complex state machines. The conversation covers event communication strategies, revealing how a shift to a publish-subscribe pattern could enhance flexibility. Mitch also highlights the importance of starting simple and gradually increasing complexity, and he underscores the QP framework's advantages over traditional solutions in real-time applications.

https://youtu.be/Zwo1aTElfis You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click here 

Dive into the nuances of the Scaled Agile Framework, where experts unpack its role in large organizations transitioning to agile. Discover the complexities of managing dependencies and collaboration in industries like automotive. Learn how structuring product teams and utilizing release trains can drive success. Critics highlight the pitfalls of SAFe as a one-size-fits-all solution, advocating for customization instead. The conversation also touches on adaptable frameworks like Scrum and alternatives that prioritize value without rigid adherence.

Mark VanderVoord and Michael Karlesky, the innovative minds behind the open-source tools Unity, CMock, and Ceedling, delve into the evolution of unit testing for C code in embedded systems. They discuss the challenges of transitioning from proprietary to open-source and the emotional hurdles maintainers face. The duo highlights gaps in existing integration testing tools and the vital role of simulators. They also share the exciting news about the upcoming Ceedling 1.0 release and the launch of Ceedling Pro, showcasing their commitment to enhancing the embedded development community.

Discussing Modern Development Techniques in Embedded SystemsIn this episode of the Agile Embedded Podcast, hosts Jeff Gable and Luca Ingianni play buzzword bingo, discussing various modern development techniques, tools, and methodologies in the context of embedded systems. They explore the relevance and applicability of terms like microservices, serverless, Kubernetes, Docker, continuous integration, continuous delivery, continuous deployment, A/B testing, API-first design, behavior-driven development, and modern languages such as Rust and C++. They also touch upon the use of AI in development and deployment processes, along with debugging, observability, monitoring, and simulation tools like Memfault, Mender, and Renode. The conversation seeks to provide insights and opinions on which of these techniques and tools are worth investigating or applying to embedded projects.00:00 Introduction to the Agile Embedded Podcast00:06 Exploring Modern Development Buzzwords01:26 Web Technologies in Embedded Systems05:28 Diving into Docker for Embedded Development07:49 Understanding Immutable Infrastructure13:32 Continuous Integration, Delivery, and Deployment19:53 A/B Testing in IoT Devices23:06 API First Design in Embedded Systems26:08 Modern Languages: The Case for Rust27:54 Exploring Rust in Embedded Systems28:37 Challenges with Modern C Programming30:10 Embedded Linux and Language Flexibility32:27 Model-Based Development with Simulink33:53 Modern Tooling for Embedded Systems40:25 AI in Embedded Systems44:05 AI-Assisted Development47:36 Conclusion and Contact Information You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click here 

Exploring Rust for Embedded Systems with Philip MarkgrafIn this episode of the Agile Embedded Podcast, hosts Jeff Gable and Luca Ingianni are joined by Philip Markgraf, an experienced software developer and technical leader, to discuss the use of Rust in embedded systems. Philip shares his background in C/C++ development, his journey with Rust, and the advantages he discovered while using it in a large development project. The conversation touches on memory safety, efficient resource management, the benefits of Rust's type system, and the supportive Rust community. They also explore the practical considerations for adopting Rust, including its tooling, ecosystem, and applicability to Agile development. The episode concludes with Philip offering resources for learning Rust and connecting with its community.00:00 Introduction and Guest Welcome00:26 Philip's Journey with Rust01:01 The Evolution of Programming Languages02:27 Evaluating Programming Languages for Embedded Systems06:13 Adopting Rust for a Green Energy Project08:57 Benefits of Using Rust11:24 Rust's Memory Management and Borrow Checker15:50 Comparing Rust and C/C++19:32 Industry Trends and Future of Rust22:30 Rust in Cloud Computing and Embedded Systems23:11 Vendor-Supplied Driver Support and ARM Processors24:09 Open Source Hardware Abstraction Libraries25:52 Advantages of Rust's Memory Model29:32 Test-Driven Development in Rust30:35 Refactoring and Tooling in Rust31:14 Simplicity and Coding Standards in Rust32:14 Error Messages and Linting Tools33:32 Sustainable Pace and Developer Satisfaction36:15 Adoption and Transition to Rust39:37 Hiring Rust Developers42:23 Conclusion and ResourcesResourcesPhil's LinkedinThe Rust LanguageRust chat rooms (at the Awesome Embedded Rust Resources List)The Ferrocene functional-safety qualified Rust compiler  You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click here 

Dive into the dangers of 'magic' in software development as the hosts dissect how deceptive abstractions can complicate coding. They compare frameworks like Arduino, which empowers, to CMake, which may confuse. The discussion focuses on the importance of composability, testability, and creating readable software. Beware of auto-generated code; it often leads to headaches with cryptic names and bloat. Gain practical tips for selecting effective tools that enhance clarity and minimize risks in long-term projects.

Building Trust with Git: Teaching Best Practices to Non-Software EngineersIn this episode of the Agile Embedded Podcast, hosts Jeff Gable and Luca Ingianni are joined by Bailey Steinfadt, owner of Stonepath Engineering. Bailey discusses her experiences in teaching Git and other software tools to non-software engineers, particularly in small manufacturing companies. Topics include the importance of visibility and trust in code projects, the typical profiles of her clients, and strategies for effective communication and trust-building between technical and non-technical stakeholders. The episode also touches on useful tools like GitHub, Miro, and Draw.io for managing projects and fostering collaboration.00:00 Introduction and Guest Welcome00:24 Bailey's Background and Stonepath Engineering01:41 Challenges with Non-Software Engineers Using Git05:46 Teaching Git to Non-Software Engineers14:35 Building Trust Through Git and Communication20:45 Tools and Techniques for Effective Communication37:32 Final Thoughts and Contact Information You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click here 

Dive into the fascinating world of embedded systems by applying principles from 'Accelerate.' Discover how DORA metrics measure software delivery performance and can guide teams. The discussion highlights the value of experimentation and innovation in organizations while addressing the complexities of change approval processes in DevOps. Learn about job satisfaction and the importance of cross-functional teams, all while harnessing rapid iteration to enhance product quality. The insights presented are invaluable for anyone navigating the challenges of embedded systems.