Key Topics[02:30] Definition of BDD as an additional layer of discipline on top of TDD[03:15] Common pitfalls of TDD, including testing to implementation and brittle tests[08:30] The structure of BDD tests using Given-When-Then format[12:00] Applying BDD at different levels, from unit tests to system tests[15:45] Using test doubles and spies for hardware interactions in embedded systems[22:30] Testing state machines with BDD[27:00] Off-target testing and hardware abstraction layers[33:00] Why BDD isn't more widely used in embedded systems[36:30] Using code coverage as a signal rather than a goal metric[39:00] Overcoming the learning curve and maintaining discipline in BDDNotable Quotes"BDD is an additional layer of discipline on top of TDD. Dan North's goal was to get straight to the good stuff of TDD without getting into the pitfalls." — Steve"The key thing that BDD does by saying we're going to focus on behavior is you look at the API that you've written and you say, what can I do through the public API to affect this, to check the results and so forth?" — Steve"By having abstraction layers, you create your thin layer that's substitutable with either the real code on target, or with a test double off target." — Steve"Code coverage as a goal metric is not a good thing. Rather than using code coverage as just this almost dimensionless metric, use it as a signal to guide you." — Steve"By adhering very strictly to the simple rules of how to do BDD, by forcing yourself to the discipline of that strict adherence, it keeps you on track." — SteveResources MentionedJames Grenning's bookSteve's blog postEmbedded Online TalkIan Cooper's video 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 

John Taylor, an experienced embedded developer with over 30 years in microcontrollers and embedded Linux, discusses his new book, co-authored with Wayne Taylor. They explore practical techniques for embedded project development and emphasize the importance of blending waterfall structure with agile methodologies. Tailored for various roles, from junior developers to managers, the book encourages teams to adapt recipes for their unique challenges. John highlights the role of experience in engineering and the need for improved communication within teams.

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.