The Agile Embedded Podcast

By: Luca Ingianni Jeff Gable
  • Summary

  • Learn how to get your embedded device to market faster AND with higher quality. Join Luca Ingianni and Jeff Gable as they discuss how agile methodologies apply to embedded systems development, with a particular focus on safety-critical industries such as medical devices.
    2021-2024 Jeff Gable & Luca Ingianni
    Show more Show less
activate_Holiday_promo_in_buybox_DT_T2
Episodes
  • Exploring Rust for Embedded Systems with Philip Markgraf
    Oct 30 2024

    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

    Show more Show less
    50 mins
  • Magic is Bad
    Oct 16 2024

    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

    Show more Show less
    42 mins
  • Bailey Steinfadt on teaching git to non-developers
    Oct 2 2024

    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

    Show more Show less
    39 mins

What listeners say about The Agile Embedded Podcast

Average customer ratings
Overall
  • 5 out of 5 stars
  • 5 Stars
    1
  • 4 Stars
    0
  • 3 Stars
    0
  • 2 Stars
    0
  • 1 Stars
    0
Performance
  • 5 out of 5 stars
  • 5 Stars
    1
  • 4 Stars
    0
  • 3 Stars
    0
  • 2 Stars
    0
  • 1 Stars
    0
Story
  • 5 out of 5 stars
  • 5 Stars
    1
  • 4 Stars
    0
  • 3 Stars
    0
  • 2 Stars
    0
  • 1 Stars
    0

Reviews - Please select the tabs below to change the source of reviews.

Sort by:
Filter by:
  • Overall
    5 out of 5 stars
  • Performance
    5 out of 5 stars
  • Story
    5 out of 5 stars

Great advice and easy to absorb!

Two experienced developers sharing their knowledge and advice in a casual but focused discussion. They understand real-world challenges and are reasonable about implementing these concepts instead of having a dogmatic approach.

Something went wrong. Please try again in a few minutes.

You voted on this review!

You reported this review!