Hardware Podcasts

137: Pausing to Think (Repeat)

Embedded.fm · 22 Mar 2018 · 1h 19m · Episode 137

What this episode covers

Dan Saks, founder of Saks & Associates and former secretary of the ANSI/ISO C++ standards committee, explains how C++ can be adopted in embedded systems without the overhead of the Standard Template Library (STL). He advocates for an incremental migration strategy, starting by recompiling C code as C++ and utilizing features like strict type checking, classes with access control, and function overloading to improve safety and maintainability. The discussion addresses common objections regarding dynamic memory, runtime type information, and debugging complexity, arguing that C++'s stronger type system reduces runtime errors and that modern compilers allow disabling expensive features like exceptions. Saks emphasizes separating technical language merits from social management issues, suggesting that C++ is often easier for new graduates to learn and maintain in large codebases due to its encapsulation capabilities.

Most relevant to

early-stage companies

Topics

Mentioned

Companies
Saks & Associates, iRobot
Products
Roomba
Also
C++, C, STL, Arduino

Related episodes from other shows

Other shows on the same ground, closest first.

  • The Pragmatic Embedded Podcast · 58m

    Modern C++ for Embedded with Niall Cooling

    Niall Cooling, director at Feabhas, explains how modern C++ (C++11 through C++23) enables safer, more agile embedded development by replacing C-style practices with compiler-enforced safety and modern tooling. He highlights 'quick wins' like `auto`, `constexpr`, and guaranteed copy elision, which improve code readability and performance without sacrificing the efficiency of C. Cooling argues that the true value of C++ lies in its ecosystem of header-only testing frameworks (like Doctest and Catch2), static analysis tools (Clang-tidy), and CI/CD integration, which allow teams to adopt Agile practices like Test-Driven Development (TDD) even in deeply embedded, safety-critical contexts. He contrasts this with the steep learning curve of Rust and emphasizes that successful adoption requires significant investment in training and process improvement rather than just language syntax changes.

    Embedded firmwareDebugging & failure analysis
    7 chapters

  • Oxide and Friends · 1h 39m

    Settling Beef

    Bryan Cantrill and Adam Leventhal of Oxide Computer Company, joined by Conor Hoekstra of the ADSP podcast and Oxide colleague Cliff Biffle, discuss the cultural and technical friction between the C++ and Rust communities. They analyze how C++'s strict backward compatibility creates a 'legacy tax' that stifles innovation, leading to the creation of successor languages like Carbon and C++2. The group explores the emotional resistance engineers feel when switching languages, arguing that fear of devaluing past expertise often blocks rational technical evaluation. They conclude that learning multiple paradigms, such as Haskell or 4th, makes programmers better regardless of their primary language, and that the industry should focus on mutual learning rather than tribalism.

    Embedded firmwareMicrocontrollers & dev platforms
    7 chapters

  • The Pragmatic Embedded Podcast · 50m

    Exploring Rust for Embedded Systems with Philip Markgraf

    Philip Markgraf, an experienced software developer and technical leader, discusses his recent experience building an embedded device for Kelvin, a green energy company, using the Rust programming language. He contrasts Rust's memory safety, sophisticated type system, and excellent tooling with the complexities and legacy constraints of C and C++. Markgraf highlights how Rust's borrow checker and standardized libraries simplify development, improve reliability, and attract motivated engineers, while noting that adoption is still in the early stages for embedded systems compared to cloud computing.

    Embedded firmwareMicrocontrollers & dev platforms
    9 chapters

  • The Pragmatic Embedded Podcast · 35m

    Rust with Milica Kostic

    Milica Kostic, an embedded software architect with a background in electrical engineering and safety-critical industries like medical devices, discusses her journey from C/C++ to adopting Rust in production. She explains that the most successful adoption occurred in a greenfield embedded Linux project using a microservice architecture, which allowed for clean isolation of Rust code and minimized complex C/C++ interoperability challenges. Kostic highlights the benefits of Rust's tooling, such as Cargo and built-in static analysis, while noting current limitations in microcontroller support, IDE tooling, and certified stacks like BLE.

    Embedded firmwareMicrocontrollers & dev platforms
    8 chapters

  • The Pragmatic Embedded Podcast · 39m

    Christmas Special

    Hosts Jeff Gable and Luca share war stories from their careers in embedded systems, highlighting the pain of manual testing in helicopter avionics, the chaos of managing requirements with Word and Excel in Dropbox for medical devices, and the technical debt of massive #ifdef blocks in legacy machine tool software. They discuss the industry's slow adoption of modern software practices like version control and CI/CD, contrasting embedded development with web development standards. The episode concludes with book recommendations including 'The Phoenix Project' and 'Team Topologies', and reflections on the future of IoT security and agile adoption in hardware.

    Debugging & failure analysisEmbedded firmware
    6 chapters

The summary, chapters and topics are generated from the episode’s audio by this directory, not written by Embedded.fm. The episode itself belongs to its publisher.