The episode features a discussion with Mitch English, a product development team lead at Inertia, about using the QP (Quantum Platform) framework for embedded systems development. Mitch and Jeff recently collaborated on a medical device project where they successfully implemented QP. The framework, created by Miro Samek, implements the actor model with active objects running in their own threads and communicating via messages. This approach helps avoid common concurrency issues found in traditional RTOS implementations.

The discussion covers how QP's hierarchical state machine framework makes it easier to manage complex state transitions and system behaviors. They share their experience using QP on a blood analyzer project, discussing how they structured the code with different layers of abstraction and maintained multiple test builds throughout development. The team found that QP's architecture helped make the system's complexity more manageable and testable.

A key learning they shared was about event communication - while they initially used direct posting between active objects, they later realized that using the publish-subscribe pattern more extensively would have made testing easier and the system more flexible. They recommend starting with QP's simple examples and gradually building up complexity rather than trying to implement complex examples right away.

Key Timestamps:
00:00:00 - Introduction and background
00:03:00 - Overview of QP framework and actor model
00:06:30 - Discussion of hierarchical state machines
00:19:30 - Project architecture and implementation approach
00:27:00 - Testing strategies and development process
00:30:00 - Team structure and collaboration
00:35:00 - Hardware/software integration
00:39:00 - Advice for getting started with QP
00:41:50 - About Inertia and contact information

Links:

Miro Samek's QP framework: https://www.state-machine.com/products/qp
Miro's book on QP framework: https://www.state-machine.com/psicc2
QP GitHub repository with example code: https://github.com/QuantumLeaps/qpc-examples
Inertia website: http://www.inertiapd.com/
Mitch English LinkedIn: https://www.linkedin.com/in/mitchellenglish/

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 

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 

Bryan Finster's episode on Luca's DevOps podcast. part one: https://open.spotify.com/episode/26cnxrZEWhQRxY3jkwQTb8?si=Fj3VtirDRU-l2xQAomrWUw
Bryan Finster's episode on Luca's DevOps podcast. part two: https://open.spotify.com/episode/36U6glqDPuvkpPwrdD8Axv?si=8T9isqUHS6WBh1aQyZEXGA
Scaled Agile DevOps Maturity Framework (SADMF), a SAFe parody: https://scaledagiledevops.com/
Klaus Leopold's Flight Levels framework: https://www.flightlevels.io/

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 

In this episode of the Agile Embedded Podcast, we are joined by Mark VanderVoord and Michael Karlesky, creators of the open-source tools Unity, CMock, and Ceedling, which help developers unit test C code. Mark and Michael share their journey of creating these tools, their experiences as open-source maintainers, and insights into the evolving landscape of embedded systems testing.

The discussion covers the origins of their tools, the challenges of maintaining open-source projects, and the different needs of various embedded development communities. We also explore the gaps in current testing tools, particularly in system and integration testing for embedded systems. The episode concludes with exciting news about the upcoming Ceedling 1.0 release and the launch of Ceedling Pro, a new commercial support offering.

Key Topics Discussed:

1. Origins of Unity, CMock, and Ceedling (3:00)
2. Challenges of open-source maintenance (14:30)
3. Barriers to entry for test-driven development in embedded systems (9:15)
4. System and integration testing tools for embedded systems (28:00)
5. Use of simulators and emulators in testing (37:30)
6. Changes in embedded development communities over time (41:30)
7. Upcoming Ceedling 1.0 release and Ceedling Pro launch (52:00)

Notable Quotes:

"The tools were really easy to develop in the first place. Unity is a very simple thing, and some people just use that without any of the rest of our tools. So the tool concept is not that hard. The thing that's hard, I think, for people getting into test-driven development or even test after is, more conceptual, like what do you test and how do you test it and what's worth doing and what's not." - Mark VanderVoord (10:15)

"GitHub as a tool is amazing. And also there's a couple, I love that they have all these metrics for like contributing to projects and stuff like that. And that really motivates some people, but also that occasionally gets in our way because as Mike said, the easiest path isn't always directly merging something and then they don't get credit for." - Mark VanderVoord (21:30)

"Arduino actually cured me of my hatred for C++. I, for a long time, despised C++. I just, it was just so stupidly complicated and arcane and just a junk drawer of software concepts." - Michael Karlesky (47:30)

Timestamps:

0:00 - Introduction and guest introductions
3:00 - Origins of Unity, CMock, and Ceedling
9:15 - Barriers to entry for test-driven development in embedded systems
14:30 - Challenges of open-source maintenance
28:00 - Discussion on system and integration testing tools
37:30 - Thoughts on simulators and emulators in testing
41:30 - Changes observed in embedded development communities
47:30 - Arduino and its impact on C++ perception
52:00 - Upcoming Ceedling 1.0 release and Ceedling Pro launch
55:30 - Closing remarks and contact information

For more information about the topics discussed, visit throwtheswitch.org or reach out to Mark and Michael directly.

https://www.linkedin.com/company/100875285/
[email protected]
[email protected]
www.throwtheswitch.org
www.github.com/ThrowTheSwitch/Ceedling

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 

Discussing Modern Development Techniques in Embedded Systems

In 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 Podcast
00:06 Exploring Modern Development Buzzwords
01:26 Web Technologies in Embedded Systems
05:28 Diving into Docker for Embedded Development
07:49 Understanding Immutable Infrastructure
13:32 Continuous Integration, Delivery, and Deployment
19:53 A/B Testing in IoT Devices
23:06 API First Design in Embedded Systems
26:08 Modern Languages: The Case for Rust
27:54 Exploring Rust in Embedded Systems
28:37 Challenges with Modern C Programming
30:10 Embedded Linux and Language Flexibility
32:27 Model-Based Development with Simulink
33:53 Modern Tooling for Embedded Systems
40:25 AI in Embedded Systems
44:05 AI-Assisted Development
47: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 Markgraf

In 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 Welcome
00:26 Philip's Journey with Rust
01:01 The Evolution of Programming Languages
02:27 Evaluating Programming Languages for Embedded Systems
06:13 Adopting Rust for a Green Energy Project
08:57 Benefits of Using Rust
11:24 Rust's Memory Management and Borrow Checker
15:50 Comparing Rust and C/C++
19:32 Industry Trends and Future of Rust
22:30 Rust in Cloud Computing and Embedded Systems
23:11 Vendor-Supplied Driver Support and ARM Processors
24:09 Open Source Hardware Abstraction Libraries
25:52 Advantages of Rust's Memory Model
29:32 Test-Driven Development in Rust
30:35 Refactoring and Tooling in Rust
31:14 Simplicity and Coding Standards in Rust
32:14 Error Messages and Linting Tools
33:32 Sustainable Pace and Developer Satisfaction
36:15 Adoption and Transition to Rust
39:37 Hiring Rust Developers
42:23 Conclusion and Resources

Resources

Phil's Linkedin

The Rust Language
Rust 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 

The Dangers of Magic in Software Abstractions

In this episode of the Agile Embedded Podcast, hosts Jeff Gable and Luca Ingianni discuss the pitfalls of relying on 'magic' in software development, particularly in tooling, build systems, and frameworks. They illuminate how seemingly helpful abstractions can become burdensome when they obscure necessary complexities or become hard to debug. Through various examples, including comparisons of Arduino and CMake, they explore what makes a good abstraction versus a bad one. The conversation also delves into the importance of composability, testability, and the real-world impact of overly simplistic or 'magical' solutions in long-term projects. The episode wraps up with practical advice for selecting and designing more effective coding abstractions to mitigate risks.

00:00 Introduction and Episode Theme
00:19 The Problem with Magic in Programming
02:54 Examples of Good and Bad Abstractions
04:45 Frameworks and Tools: Arduino vs. CMake
08:10 Vendor-Supplied Tools and Their Pitfalls
13:05 Characteristics of Good Abstractions
29:04 Testing and Abstractions
37:10 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 

Building Trust with Git: Teaching Best Practices to Non-Software Engineers

In 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 Welcome
00:24 Bailey's Background and Stonepath Engineering
01:41 Challenges with Non-Software Engineers Using Git
05:46 Teaching Git to Non-Software Engineers
14:35 Building Trust Through Git and Communication
20:45 Tools and Techniques for Effective Communication
37: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 

Applying 'Accelerate' Principles to Embedded Systems | Agile Embedded Podcast

Welcome to the latest episode of the Agile Embedded Podcast with Jeff Gable and Luca Ingianni! In this episode, we address a listener's question about the book 'Accelerate' by Nicole Forsgren, Jez Humble, and Gene Kim. Jeff and Luca delve into how the principles from this book, which focuses on Lean Software and DevOps, can be applied to embedded systems development. They discuss the nuances of embedded systems, the relevance of DORA metrics, and share insights on how capabilities and processes from the book translate to the unique challenges of embedded systems. Tune in to understand how you can adapt and implement these best practices in your projects.

00:00 Introduction to the Agile Embedded Podcast
00:06 Overview of the Book 'Accelerate'
00:50 Research Methodology and Key Findings
02:56 DORA Metrics Explained
05:30 Key Capabilities for Effective Organizations
18:41 Applying 'Accelerate' Principles to Embedded Systems
20:19 Challenges and Considerations in Embedded Systems
34:10 The Importance of Logging and Feedback Loops
37:43 Empowering Teams and Encouraging Experimentation
41:58 Final Thoughts and Recommendations

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 

Navigating Firmware and Software Collaboration in Medical Devices: Insights with Weronika Michaluk

In this episode of the Agile Embedded Podcast, hosts Jeff Gable and Luca Ingianni are joined by Weronika Michaluk, Software as a Medical Device Practice Lead at HTD Health. Weronika shares her experiences and lessons learned from working with firmware teams, bridging cross-functional collaboration, and discussing the importance of version control, aligning technical aspects, and clear communication. The conversation delves into agile methodologies, customer interactions, and strategies for efficient requirement management in the medical device industry. Tune in to gain valuable insights from Weronika's extensive expertise.

00:00 Introduction and Guest Introduction
00:38 Veronica's Background and Experience
01:54 Understanding Software as a Medical Device (SAMD)
04:14 Lessons Learned in Cross-Functional Teams
05:42 Importance of Version Control
08:58 Team Collaboration and Communication
21:17 Managing Requirements in Agile Development
25:49 Effective Team Collaboration and Documentation
26:24 Tools and Processes for Project Management
26:42 Client and Team Meetings
27:13 Refinement and Feedback Loops
29:38 Change Order Process
36:11 Client Perspectives on Agile
38:09 Challenges with Agile in Medical Device Development
40:18 Differences in Client Types
45:47 Final Thoughts and Conclusion

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