Hardware Podcasts

116: You Have to Care

Embedded.fm · 2 Sept 2015 · 1h 21m

What this episode covers

Glenn Scott, a principal engineer at PARC, discusses the philosophy and tactics of API design, emphasizing that naming, modeling, and abstraction are the foundational pillars of good software. He argues for reducing cyclomatic complexity, avoiding premature feature addition ('you ain't gonna use it'), and treating code as a communication tool for other humans rather than just machines. Scott also touches on the legal implications of API copyright, the importance of professional judgment over rigid processes, and his interest in drone-based data acquisition for Mars and ocean exploration.

Most relevant to

large enterprises

Topics

Mentioned

Companies
PARC, Oracle, Google, Sun, Cisco
Products
CCN, Java
Tools
LongBow, Doxygen, Xcode, Emacs, Vi, Eclipse, Visual Studio, Oxygen, JavaDoc
Also
Bob Martin, Knuth, POSIX, Embedded.fm

Related episodes from other shows

Other shows on the same ground, closest first.

  • The Pragmatic Embedded Podcast · 41m

    Magic is Bad

    Hosts Jeff Gable and Luca Ingianni discuss the dangers of 'magic' in software abstractions, arguing that while tools like Arduino are useful for beginners, overly complex or opaque systems like CMake and vendor IDEs create long-term maintenance risks. They contrast these with good abstractions such as TCP sockets, Miro Samek's QP framework, and the 'data model pattern,' emphasizing that effective design prioritizes testability, composability, and transparency over reducing typing. The conversation highlights how 'magical' tools often fail when users hit their limits, leading to brittle code and increased project risk.

    Embedded firmwareEDA & CAD tools
    6 chapters

  • Oxide and Friends · 54m

    Software Engineering Past, Present, and Future with Grady Booch

    Grady Booch, software engineering pioneer and co-founder of Rational Software, joins Bryan Cantrill and Adam Leventhal to trace the history and future of software engineering. Booch details the evolution from the 'software crisis' of the 1970s and the creation of UML to the current 'third golden age' driven by distributed systems and LLMs. He argues that while LLMs are powerful tools for increasing abstraction, they are architecturally incapable of abductive reasoning and require experienced engineers to guide them, emphasizing that fundamentals like coupling, cohesion, and judgment remain essential.

    Embedded firmwareAI & machine learning
    7 chapters

  • The Pragmatic Embedded Podcast · 42m

    Code Reviews

    Jeff Gable and Luca discuss the purpose, process, and culture of code reviews in embedded software development. They argue that reviews are primarily for knowledge transfer, shared understanding, and mentoring rather than just bug detection, warning against 'bike shedding' on trivial syntax issues. The hosts advocate for early design reviews, small atomic commits, and empathetic communication to maintain team cohesion and prevent bottlenecks.

    Careers & educationLeadership, teams & culture
    7 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 Pragmatic Embedded Podcast · 32m

    The Matthew Test with Matthew Eshleman - Part 2

    Matthew Eshleman, founder of Cove Mountain Software, joins Jeff Gable and Luca Engineer to discuss Part 2 of his 'Matthew Test,' a framework for better embedded software. They cover the balance between upfront design and agile development, the importance of Test-Driven Development (TDD) in C/C++, and the value of investing in high-quality engineering tools. The conversation also addresses hiring practices, realistic scheduling under business constraints, peer code reviews, and the role of dedicated QA teams in preventing bugs.

    Embedded firmwareCareers & education
    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.