Hardware Podcasts

What's a bug? What's a debugger?

Oxide and Friends · 22 Jun 2021 · 1h 06m · Episode 7

What this episode covers

Bryan Cantrill and Adam Leventhal of Oxide Computer Company discuss the philosophy and mechanics of debugging, arguing that the term 'debugger' is regrettable and that tools should focus on observability and understanding system behavior rather than just fixing reproducible errors. They critique traditional in-situ breakpoint debugging for its fragility ('killing the patient') and advocate for post-mortem analysis, memory forensics, and tools like DTrace and Hubris. The conversation highlights how modern practices like CI/CD and languages like Rust have shifted the debugging landscape, making traditional debuggers less relevant for simple errors but more critical for complex, distributed system pathologies.

Most relevant to

early-stage companies

Topics

Mentioned

Companies
Oxide Computer Company
Products
Hubris
Tools
DTrace, MDB, Ghidra, GDB
Also
Rust

Related episodes from other shows

Other shows on the same ground, closest first.

  • Embedded.fm · 58m

    141: Malevolent and Trying to Trick You

    Julia Evans, a software engineer at Stripe, discusses using Linux system-level tools like `strace`, `perf`, and `top` to debug applications as black boxes. She explains how `strace` reveals system calls to understand program behavior without reading source code, and how `perf top` identifies CPU-intensive functions like garbage collection. Evans also shares her philosophy on debugging, emphasizing the importance of maintaining confidence and understanding that computers are logical machines, even when bugs seem impossible.

    Debugging & failure analysisTest & measurement
    7 chapters

  • Embedded.fm · 55m

    422: It's Not a Bug, It's a Feature

    Hosts Elecia White and Chris White discuss the 'Zone of Proximal Development' using origami as an analogy for learning to code from scratch. They review news about reanimating dead spiders for robotics and continuous ultrasound imaging, while also addressing the semiconductor inventory glut. The conversation shifts to practical tooling, specifically Elecia's disappointment that her SEGGER J-Link debugger is no longer supported, leading to a debate on future-proofing hardware purchases versus buying cheap.

    Debugging & failure analysisTest & measurement
    8 chapters

  • Embedded.fm · 1h 12m

    215: Heisenbugs

    Guest Alvaro Prieto joins hosts Alicia White and Christopher White to discuss the fundamentals of debugging embedded systems, distinguishing between software debuggers, hardware programmers, and microprocessor debug support. They cover the evolution from print-based debugging to using tools like GDB, LLDB, and Visual Studio Code, while explaining the roles of hardware interfaces like J-Tag, SWD, and Trace. The conversation highlights the trade-offs between open-source toolchains (GCC, OpenOCD) and paid professional IDEs (Keil, IAR, Code Composer Studio), emphasizing how paid tools simplify setup for complex chip architectures. Prieto also shares anecdotes about his personal projects, including a cheese-aging cave and a new reverse engineering podcast.

    Debugging & failure analysisEDA & CAD tools
    9 chapters

  • The Amp Hour · 1h 04m

    Debugger vs Printeffer

    Dave Jones of EEVblog discusses the significant challenges he faced during the Kickstarter launch of his new digital multimeter, including manufacturing defects, logistical bottlenecks, and component sourcing issues. He details specific failures such as intermittent contacts in the range switch due to injection molding tolerances and units stuck in US customs due to reshipper ownership discrepancies. The conversation also covers the broader industry context of passive component shortages, the historical shift from mask ROM to reprogrammable microcontrollers, and debugging methodologies like using square waves for control loop stability.

    Crowdfunding & preordersQuality & yield
    7 chapters

  • Embedded.fm · 53m

    209: Debuggerception

    Pierre-Marie de Rodat, a software engineer at AdaCore, explains the inner workings of debuggers, focusing on how GDB uses DWARF debug information to interpret program state. He details how compilers generate this metadata to allow debuggers to handle optimizations and complex types, and discusses the use of Python scripting in GDB for custom pretty printers. The conversation also covers code coverage tools like GNATcoverage and the AdaCore-sponsored Make with Ada competition.

    Debugging & failure analysisEmbedded firmware
    6 chapters

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