Hardware Podcasts

190: Trust Me, I'm Right (Repeat)

Embedded.fm · 7 May 2020 · 1h 08m · Episode 190

What this episode covers

Matt Godbolt, a software engineer at DRW and creator of Compiler Explorer, discusses the evolution and utility of his open-source tool for comparing compiler outputs. He explains how the project started as a shell script to settle arguments about C++ features and grew into a web platform supporting multiple languages and architectures, including ARM and X86. Godbolt details the technical challenges of running compilers securely on AWS, the impact of recent AWS outages, and the benefits of using modern C++ features like constexpr for embedded systems.

Most relevant to

makers and hobbyists

Topics

Mentioned

Companies
DRW, Amazon Web Services, Argonaut Games, Google, GitHub, Patreon
Products
Compiler Explorer, Commodore 64
Chips
6502
Tools
GCC, Clang, Visual Studio Code
Also
Rust, C++, Jason Turner

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

  • 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 · 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

  • Oxide and Friends · 1h 44m

    Across the Chasm with Rust

    Steve Klabnik and Luqman Aden, engineers at Oxide Computer Company, discuss the evolution of the Rust programming language, focusing on the stabilization of features like `let_chains` and `async/await` as the catalyst for crossing the chasm from early adopters to mainstream systems programming. They analyze how Rust's strict stability guarantees, enforced by tools like Crater, contrast with the burnout risks seen in other language communities, while highlighting specific language features such as inline assembly, const generics, and captured identifiers in format strings that improve developer experience. The conversation also covers the psychological shift required to trust the compiler, the importance of tooling like Rust Analyzer and Clippy, and the community's approach to managing experimental features via nightly builds and RFCs.

    Embedded firmwareAI & machine learning
    10 chapters

  • Oxide and Friends · 1h 30m

    Debugging Methodologies

    Jordan Hendricks and Luqman Aden of Oxide Computer Company detail their methodologies for debugging complex hardware and compiler issues. Hendricks explains how he used the KMDB in-situ debugger to diagnose an NVMe reset hang, discovering that switching from abrupt to normal shutdown notifications resolved the issue. Aden describes his process for debugging a rustc segfault involving inline assembly in async blocks, using LLVM IR analysis and Rust Analyzer to isolate a bug in the compiler's code generation. The episode also covers a third case involving a triple fault caused by undefined behavior in a bare-metal bootloader, highlighting the importance of tooling and collaborative debugging culture at Oxide.

    Debugging & failure analysisEmbedded firmware
    5 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.