Hardware Podcasts

215: Heisenbugs

Embedded.fm · 14 Sept 2017 · 1h 12m · Episode 215

What this episode covers

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.

Most relevant to

makers and hobbyists

Topics

Mentioned

Companies
Nordic, ST, Texas Instruments
Products
Arduino
Chips
AVR
Tools
SEGGER J-Link, Black Magic Probe, GDB, LLDB, Visual Studio Code, OpenOCD, PlatformIO, Keil, IAR, Code Composer Studio

Related episodes from other shows

Other shows on the same ground, closest first.

  • Unnamed Reverse Engineering Podcast · 35m

    010 - T0015! Part 0x3 - Debug Interfaces

    Hosts Alvaro Prieto and Jen Castilla discuss debugging interfaces like JTAG and SWD, explaining their history from boundary scan testing to modern in-circuit emulation. They review key hardware tools including Segger J-Link, BlackMagicProbe, ST-Link, and the BusBlaster, noting how open-source alternatives have drastically reduced costs. The conversation highlights the JTAGulator for finding hidden debug pins and argues that affordable, accessible tools have lowered barriers for hardware startups and security researchers.

    Debugging & failure analysisMicrocontrollers & dev platforms
    7 chapters

  • Moore's Lobby · 49m

    Creating Next-Gen Microcontroller Developer Tools and Equipping the People Who Use Them

    Rodger Richey, Vice President of Development Tools and Academic Programs at Microchip Technology, discusses the evolution of embedded development tools over his 30-year tenure. He explains how Microchip shifted its IDE support from NetBeans to VS Code to align with developer habits and details the integration of AI as an assistant for code generation and debugging rather than a replacement. Richey also highlights Microchip's academic initiatives, including virtual internships and hardware labs in India, designed to bridge the gap between theoretical education and practical engineering skills.

    Embedded firmwareAI & machine learning
    7 chapters

  • The Spark Gap · 43m

    The Spark Gap - Episode 17

    Hosts Carl and Corey discuss the fragmented landscape of in-circuit programmers and debuggers for embedded systems, highlighting the pain of dealing with incompatible protocols like JTAG, SWD, and proprietary interfaces from vendors such as NXP, Microchip, and ST. They detail the high cost of commercial tools like the SEGGER J-Link and the risks of relying on bootloaders, citing a $58,000 loss by SparkFun on their MicroView Kickstarter due to a bootloader overwrite error. The hosts advocate for understanding memory maps and linker scripts, and suggest building custom programmers or using open-source tools like OpenOCD to gain deeper knowledge of microcontroller internals and avoid vendor lock-in.

    Embedded firmwareMicrocontrollers & dev platforms
    8 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

  • Oxide and Friends · 1h 06m

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

    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.

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