Hardware Podcasts

193: Axiomatically Did Not Happen

Embedded.fm · 29 Mar 2017 · 1h 10m

What this episode covers

Owen Anderson, an engineering manager at Oculus and long-time LLVM contributor, explains the architecture of compilers, focusing on the role of Intermediate Representation (IR) in enabling optimization and multi-target support. He details how LLVM uses SSA form to simplify analysis, discusses the trade-offs between RISC and VLIW instruction sets, and describes the unique batch-oriented nature of GPU architectures compared to CPUs. Anderson also shares a specific debugging story involving undefined behavior and the subtle differences between C and C++ volatile semantics, concluding with advice for students entering the field.

Most relevant to

large enterprises

Topics

Mentioned

Companies
Oculus, Nvidia
Products
Jetson TX 2
Chips
RISC-V, ARM
Tools
LLVM, Clang, GCC, OpenCL
Also
Haskell

Related episodes from other shows

Other shows on the same ground, closest first.

  • 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

  • Oxide and Friends · 1h 54m

    Heterogeneous Computing with Raja Koduri

    Raja Koduri, former chief architect at Intel and AMD, joins Bryan Cantrill and Adam Leventhal to explain the differences between CPUs, GPUs, FPGAs, and ASICs through historical and analogical lenses. Koduri traces the evolution from 3dfx and Direct3D to CUDA, arguing that NVIDIA’s success stems from a tight coupling of programming and execution models, which creates a sticky ecosystem. He uses transportation analogies to categorize these technologies—cars for CPUs, buses for GPUs, and construction vehicles for FPGAs—and discusses how advanced packaging and memory bandwidth are becoming the primary constraints in modern AI hardware.

    Chips, FPGAs & semiconductorsMicrocontrollers & dev platforms
    8 chapters

  • Oxide and Friends · 1h 32m

    Engineering Rigor in the LLM Age

    Bryan Cantrill, Adam Leventhal, Rain Paharia, and David Crespo of Oxide Computer Company discuss using LLMs like Claude Code and Opus 4.5 to increase engineering rigor rather than just velocity. They share specific examples of using AI to refactor the Helios kernel, build the 'iddqd' Rust map library, debug the Ghostty terminal in Zig, and manage type drift in Oxide's APIs. The group argues that rigorous documentation and strong typing are essential for effective LLM collaboration, contrasting this with the 'vibe coding' narrative.

    AI & machine learningEmbedded firmware
    6 chapters

  • The Amp Hour · 1h 45m

    An Interview with Scott Shawcroft

    Chris Gammell, a software engineer at Adafruit, explains the architecture and philosophy behind CircuitPython, the fork of MicroPython designed for beginners. He details the technical differences between interpreted and compiled languages, the use of a virtual machine to execute byte code, and the uniform API that allows drivers to work across different microcontroller families like the SAMD21 and SAMD51. Gammell also walks through the low-level debugging process using J-Link and GDB, explaining how hardware breakpoints and the Micro Trace Buffer help troubleshoot firmware issues.

    Embedded firmwareMicrocontrollers & dev platforms
    5 chapters

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