Podcast

SE Radio

Software Engineering Radio is a podcast for professional software developers, published by IEEE Software. It has been running since 2006, and the format is a long interview with someone who has actually built the thing being discussed.

I host a handful of episodes a year. My job on the show is to pull the reasoning out of a guest rather than the pitch: why the architecture is shaped that way, what it costs, and what they would not do again. Below is every episode I have hosted, newest first, with three things worth keeping from each.

Episode 717

Eric Tschetter on Decoupling Observability

with Eric Tschetter, Chief Architect at Imply

Logs, metrics, and traces started life inside a single vendor stack that owned collection, storage, querying, and dashboards all at once. Microservices made that arrangement expensive and hard to leave. Eric argues for pulling the stack apart the way business intelligence pulled the warehouse away from the dashboard, and we work through what that costs you as well as what it buys.

Three things worth keeping

  1. The proposed split is four layers: ingest and routing, storage, query and compute, and visualization. The parallel Eric draws is to business intelligence, where the warehouse and the dashboard stopped being one product. A coupled observability vendor sells all four together, and that bundling is where both the lock-in and the shape of the scaling bill come from, not from any one layer being bad.

  2. Portability is a schema problem before it is a storage problem. OpenTelemetry earns its place in this architecture mainly as a shared schema: if telemetry is written in a form more than one backend can read, then changing the query layer is a configuration change rather than a re-instrumentation project across every service.

  3. Query and compute is where the difficulty concentrates, because observability data wants real-time analytics behavior rather than batch. That drives the discussion into Druid's indexing choices and into returning one unified result across hot and cold storage, so an engineer chasing an incident does not have to know which tier their time range happens to live in.

Episode 715

Sahaj Garg on Designing for Ambiguity in Human Input

with Sahaj Garg, Co-founder and CTO at Wispr Flow

Every system that takes human input, whether text or voice or both, receives input that has more than one correct reading. Sahaj and I go through where ambiguity comes from, what you can do about it at training time, how personalization changes the calculus, and how to tell whether any of it worked.

Three things worth keeping

  1. The first cut is between ambiguity that is reducible and ambiguity that is inherent. Reducible ambiguity yields to more context, and the categories worth separating are lexical, syntactic, and pragmatic, with voice adding homophones and accent variation on top. Inherent ambiguity does not yield to any amount of context, and treating the two the same is how systems end up confidently guessing.

  2. Personalization runs on revealed preferences rather than explicit feedback: what a user keeps, edits, or throws away says more than a thumbs-up they were never going to click. That behavioral signal is also the antidote to output that regresses to the mean, where a model tuned to be acceptable to everyone writes prose that sounds like nobody in particular.

  3. Surfacing uncertainty is a product decision, not just a modeling one. Flagging every low-confidence span turns the interface into a proofreading assignment, so the useful question is which uncertainties are worth a user's attention. Evaluation follows the same split: offline sets for whether ambiguity was resolved correctly, online signals for whether the resolution held up in real use.

Fear has killed more dreams than failure ever will.
© 2026 Amey Ambade
Houston, TX
currently obsessing over: the long catalog of bossa nova standards