Free Daily Podcast Summary
Developer Voices: Daily Summaries Delivered
by Kris Jenkins
Deep-dive discussions with the smartest developers we know, explaining what they're working on, how they're trying to move the industry forward, and what we can learn from them.You might find the solution to your next architectural headache, pick up a new programming language, or just hear some good war stories from the frontline of technology.Join your host Kris Jenkins as we try to figure out what tomorrow's computing will look like the best way we know how - by listening directly to the developers' voices.
Latest Episodes
The most recent episodes — sign up to get AI-powered summaries of each one.
- Sep 25, 20262h 21m
How Would You Type-Check 30 Million Lines of PHP? (with Julien Verlaguet)
How would you manage 30 million lines of PHP? You can't rewrite it - you'd be fired long before you delivered. That was the problem facing Facebook around 2011, and their answer was to add a type system, giving birth to the Hack language. But adding types to PHP turned out to be the easy part. The hard part was building a type checker that developers used to "edit, save, refresh" would actually tolerate. So how do you type-check tens of millions of lines of code fast enough that nobody notices? Julien Verlaguet co-designed Hack at Facebook, and has spent the fifteen years since chasing a better way to build incremental systems. We start with the internals of Hack's language server - forked OCaml workers, a shared immutable heap, lock-free dependency tracking, and the months spent hunting non-deterministic bugs. From there we follow the thread to Skip, a language designed around tracking mutability in the type system, with stops at why Haskell's monads and "reactive Java" didn't fit, functors vs type classes, and Skip's bang operator for working with immutable objects. Then it's on to the Skip reactive framework: eager vs lazy collections, a garbage collector without long pauses, a reactive SQL database that didn't find a market, TypeScript bindings, and Skipper, an AI coding agent built on a sound version of TypeScript. If you're interested in compilers, language design, or building real-time systems that stay fast as they grow, Julien has plenty of hard-won lessons to share. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join SkipLabs: https://skiplabs.io/ Skip Framework Docs: https://skiplabs.io/docs Skip on GitHub: https://github.com/SkipLabs/skip Skiplang: https://skiplang.com/ Skipper Launch Announcement: https://skiplabs.io/blog/press_release Hack: https://hacklang.org/ HHVM: https://hhvm.com/ OCaml: https://ocaml.org/ OCaml Functors: https://ocaml.org/docs/functors Haskell: https://www.haskell.org/ Clojure: https://clojure.org/ Scala Implicit Parameters: https://docs.scala-lang.org/tour/implicit-parameters.html Salsa (Incremental Computation for Rust): https://github.com/salsa-rs/salsa ReactiveX: https://reactivex.io/ SQLite: https://www.sqlite.org/ TPC-H Benchmark: https://www.tpc.org/tpch/ PostgreSQL: https://www.postgresql.org/ PostgreSQL NOTIFY: https://www.postgresql.org/docs/current/sql-notify.html Server-Sent Events: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events JavaScript Proxy Objects: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy Doxygen: https://www.doxygen.nl/ SKDB and Reactive Databases (Materialized View): https://materializedview.io/p/skdb-reactive-databases-julien-verlaguet Julien on LinkedIn: https://www.linkedin.com/in/julien-verlaguet-b5710a20/ Julien on X: https://x.com/JulienVerlaguet Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
- Aug 26, 20261h 46m
DuckDB And The Burden of Success (with Hannes Mühleisen)
Building something people actually want is supposed to be the happy ending. But it arrives with a bill attached: feature requests you didn't ask for, pull requests you'd rather not maintain forever, users demanding the one thing you swore you'd never build, and — if you're unlucky — a company where the sales team quietly starts deciding what engineering works on. DuckDB has spent the last two and a half years working through that list. So how do you stay a database engineering team when success keeps trying to turn you into something else? Hannes Mühleisen, co-creator of DuckDB, is back to talk through the answers they've landed on. Their fix for unwanted pull requests was an extension mechanism, which then forced them to make every part of the engine pluggable — including the parser, which meant ripping out 20,000 lines of Postgres' yacc grammar and rewriting SQL parsing on top of PEG. Their fix for the users demanding client-server was Quack, a protocol designed by people who'd already published a paper on why every existing database wire protocol is wrong. And their answer to Apache Iceberg, after three years of implementing it, was DuckLake: throw out the Avro-and-JSON metadata files and keep the metadata in a database, on the grounds that the Iceberg REST catalog has a Postgres in it anyway. Which brings us to the news Hannes breaks in this episode: DuckDB Labs is being acquired by AWS, while the DuckDB Foundation, the project and its licence stay where they are. There's the question of why a profitable, self-funded, 30-person company in Amsterdam would take that deal, what commitments you write into the contracts when you're worried today's promises might outlive today's management, and what it's actually like to have a boss again after five years without one. If you're curious how an open source project keeps its technical soul once the enterprise arrives — or you just want to know why parsing SQL is harder than parsing almost anything else — Hannes has some good answers. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Our previous episode with Hannes: https://youtu.be/pZV9FvdKmLc DuckDB: https://duckdb.org/ DuckDB Foundation: https://duckdb.foundation/ DuckLabs (formerly DuckDB Labs): https://ducklabs.com/ DuckLake: https://ducklake.select/ Quack (DuckDB's client-server protocol): https://duckdb.org/quack/ DuckDB v2.0: Your Database Deserves a Better Parser: https://duckdb.org/2026/08/20/duckdb-20-peg-parser Runtime-Extensible Parsers (CIDR 2025 paper): https://duckdb.org/pdf/CIDR2025-muehleisen-raasveldt-extensible-parsers.pdf Don't Hold My Data Hostage (VLDB 2017 paper): https://www.vldb.org/pvldb/vol10/p1022-muehleisen.pdf cpp-peglib: https://github.com/yhirose/cpp-peglib GNU Bison: https://www.gnu.org/software/bison/ PEP 617 – New PEG parser for CPython: https://peps.python.org/pep-0617/ PRQL: https://prql-lang.org/ Apache Iceberg: https://iceberg.apache.org/ CWI (Centrum Wiskunde & Informatica): https://www.cwi.nl/en/ DuckCon #7, Amsterdam: https://duckdb.org/events/2026/06/24/duckcon7/ Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
- Aug 12, 20261h 1m
The Enterprise AI Gap (with James Brown)
My guest this week is James Brown, an engineering lead at Schroders, and that's a useful vantage point — asset managers carry all the regulation and organisational weight of a bank, mixed with the first-to-market pressure of a startup. James starts with his own "Claude mania": months of agents running around the clock, and the wave of anxiety that hit him one morning walking to the shop without one running at home. From there, Clair — the plugin he's building to give coding agents proximal awareness of each other, using git orphan branches as a zero-infrastructure message bus; why AI behaves like oxygen in a room full of tiny fires; what "going well" actually measures inside a regulated firm; and why he thinks team sizes won't change, even when the number of teams does. There's a darker thread running under all of it. The collapse in junior hiring, the advice we no longer know how to give a 20-year-old, dark factories and evolutionary harnesses that might make the AI's ideas better than ours, and the burnout James expects to be our dominant topic for the next couple of years. If AI is working beautifully on your side projects but landing with a thud at work, James has some honest answers — including several about what he doesn't know yet. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Clair (James's multi-agent proximity plugin): https://github.com/JBJamesBrownJB/clair Clair product docs: https://github.com/JBJamesBrownJB/clair/blob/main/docs/product.md James's blog: https://medium.com/@jameskinnahbrown "Milk, Eggs and Claude Mania": https://medium.com/@jameskinnahbrown/milk-eggs-and-claude-mania-49f445c5a77e Schroders: https://www.schroders.com/ Claude Code: https://www.claude.com/product/claude-code Agent Skills & progressive disclosure: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview Git orphan branches (git checkout --orphan): https://git-scm.com/docs/git-checkout Moltbook: https://www.moltbook.com/ Team Topologies: https://teamtopologies.com/ "Expert Panel: How Far Can We Accelerate with AI?": https://youtu.be/Bg7L4vmmSKg XT26 (the conference the panel was part of): https://www.juxt.pro/xt26/ Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
- Jul 8, 20261h 5m
What If Every SQL Query Could Update Incrementally? (with Lalith Suresh)
There's a problem that's bugged the database industry since the 1980s: you run an expensive query over millions of rows, cache the result, and then a single new row arrives. Logically that's one small update, but most engines throw the cached answer away and recompute everything from scratch. Some will handle changes incrementally, but only for "simple" queries - and the rules for what counts as simple are arbitrary and brittle. So can you incrementally maintain *any* SQL query, no matter how complex? For decades the answer was no. Then an award-winning paper called DBSP proved that the answer is yes - all queries are simple enough. Joining me to explain how that works is Lalith Suresh, CEO of Feldera, the company built on top of DBSP. We start with the problem itself, then trace how a group of VMware researchers arrived at it from the unlikely direction of Kubernetes and network control planes. Lalith walks through Z-sets, the weighted data structure that turns database changes into something you can add and subtract, and the four DBSP operators - including one borrowed straight from digital signal processing - that let you compile any SQL program into an incremental version deterministically. Along the way we get into which operations need state and which don't, how the delta join falls out for free, building a standalone query engine with its own storage layer and Calcite front-end, backfills as the real Achilles heel, and how this all differs from stream processors like Kafka Streams and Flink. If you've ever fought with materialized views that won't refresh, watched a nightly batch job recompute three years of data to capture last night's changes, or you're just curious how one elegant bit of maths unifies batch and stream processing, Lalith has some genuinely satisfying answers. There's an MIT-licensed open source edition and a sandbox at try.feldera.com if you want to play along. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Feldera: https://www.feldera.com/ Feldera Sandbox (try it online): https://try.feldera.com/ Feldera on GitHub (open source): https://github.com/feldera/feldera DBSP Rust crate: https://crates.io/crates/dbsp DBSP Paper - "Automatic Incremental View Maintenance for Rich Query Languages" (VLDB 2023 Best Paper): https://arxiv.org/abs/2203.16684 Mihai Budiu - "Streaming Queries Without Compromise" (Current 2024): https://www.youtube.com/watch?v=cn1Yaxwl6x8 Mihai Budiu - DBSP talk at CMU Database Group: https://db.cs.cmu.edu/events/dbsp-incremental-computation-on-streams-and-its-applications-to-databases/ Differential Dataflow: https://github.com/TimelyDataflow/differential-dataflow Apache Calcite (Feldera's SQL front-end): https://calcite.apache.org/ Kafka Streams: https://kafka.apache.org/documentation/streams/ Apache Flink: https://flink.apache.org/ ksqlDB: https://ksqldb.io/ Apache Spark: https://spark.apache.org/ Snowflake: https://www.snowflake.com/ Databricks: https://www.databricks.com/ Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
- Mar 26, 20261h 40m
What's Worth Knowing In AI Right Now? (with Henry Garner)
AI is changing the way we all build software — that much seems clear. But the landscape is moving so fast that even the people paid to keep up are struggling. MCP or skills? Fine-tune or just prompt? LangChain or let a thousand agents loose? With almost 70 competing technologies and a shelf life of maybe six months on any advice, how do you figure out what's actually worth your time? Henry Garner is CTO of JUXT, a consultancy with about 150 senior engineers working at the coalface of AI-assisted development, including building AI platforms for tier-one banks. JUXT publishes a quarterly AI Radar — 68 technologies rated and reviewed — and Henry's been watching his own team go through the full adoption arc, from "spicy autocomplete" skepticism through to building Byzantine-fault-tolerant distributed systems over a weekend with Claude. Along the way we cover MCP vs skills, Conway's Law for LLMs, neurosymbolic AI and the unexpected return of Prolog, the "Ralph Wiggum loop" for getting agents to converge on correct implementations, and Allium — a new behavioral specification language Henry's co-authored that sits between human prose and TLA+, aiming to give LLMs just enough structure to pin down what a system should do without falling into waterfall thinking. If you're trying to make sense of the AI tooling landscape, or you've hit that wall where your agents keep drifting away from what you actually wanted, Henry's thesis — velocity through clarity of intent — might well help out yours. -- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join JUXT: https://www.juxt.pro/ JUXT AI Radar: https://www.juxt.pro/ai-radar/ Allium on GitHub: https://github.com/juxt/allium Allium Documentation: https://juxt.github.io/allium/ Composition at a Distance (Henry's blog post): https://www.juxt.pro/blog/composition-at-a-distance/ A New Vocabulary for an Old Problem (Henry's blog post): https://www.juxt.pro/blog/new-vocabulary-for-an-old-problem/ Model Context Protocol (MCP): https://modelcontextprotocol.io/ LangChain: https://www.langchain.com/ LangGraph: https://www.langchain.com/langgraph Gas Town (Steve Yegge): https://github.com/steveyegge/gastown Kiro (spec-driven AI IDE): https://kiro.dev/ Phoenix (LLM observability): https://github.com/Arize-ai/phoenix Temporal: https://temporal.io/ Taalas (LLM-on-a-chip): https://taalas.com/ Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
- Feb 19, 20261h 26m
Asciinema: Terminal Recording Done Right (with Marcin Kulik)
I have a theory that only bad projects get finished — good ones keep finding new things to do. Asciinema is a case in point. What started as a way to share terminal sessions with friends has, over 14 years, grown into a full suite of tools covering recording, hosting, playback, and live streaming — and been rebuilt multiple times along the way. So what does it actually take to record and replay a terminal session faithfully in a browser? Joining us for this conversation is Marcin Kulik, Asciinema's creator. The project's architecture has passed through almost every interesting corner of software engineering: a Python recorder built around pseudo-terminals (PTY), a ClojureScript terminal emulator for the browser that hit performance limits with immutable data structures and garbage collection pressure, a move to Rust compiled to WebAssembly, a Go experiment that didn't last, and a new Rust CLI for concurrent live streaming backed by an Elixir/Phoenix server that calls Rust code via NIFs. The same Rust terminal emulator library now powers all three components — the browser player, the server, and the CLI. If you've ever looked at those terminal animations embedded in a README and wondered what's underneath them, or if you're interested in how a passionate open-source developer navigates 14 years of language changes and rewrites, this conversation has plenty to offer. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Asciinema: https://asciinema.org Asciinema Docs: https://docs.asciinema.org Asciinema CLI (GitHub): https://github.com/asciinema/asciinema Asciinema Player (GitHub): https://github.com/asciinema/asciinema-player Asciinema Server (GitHub): https://github.com/asciinema/asciinema-server AVT - Rust terminal emulator library: https://github.com/asciinema/avt vt-clj - the original ClojureScript terminal emulator: https://github.com/asciinema/vt-clj Paul Williams' ANSI/VT100 State Machine Parser: https://vt100.net/emu/dec_ansi_parser Rust: https://www.rust-lang.org WebAssembly: https://webassembly.org SolidJS: https://www.solidjs.com Elixir: https://elixir-lang.org Phoenix Framework: https://www.phoenixframework.org Rustler (Rust NIFs for Elixir/Erlang): https://github.com/rusterlium/rustler Clojure: https://clojure.org ClojureScript: https://clojurescript.org cmatrix: https://github.com/abishekvashok/cmatrix Marcin Kulik on GitHub: https://github.com/ku1ik Marcin Kulik on Mastodon: https://hachyderm.io/@ku1ik Marcin Kulik on asciinema.org: https://asciinema.org/~ku1ik "They're Made Out of Meat" demo: https://asciinema.org/a/746358 Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ --- 0:00 Intro 2:28 What Is Asciinema? 4:48 How Asciinema Started 9:51 The Problem of Parsing Terminal Output 14:07 Building a Cross-Platform Recorder 17:01 Rewriting the Parser in ClojureScript 22:19 The Hidden Complexity of Terminals 29:28 Rendering Terminals in the Browser 39:47 When ClojureScript Can't Keep Up 45:28 Moving to Rust and WebAssembly 52:01 The Go Experiment 57:43 Adding Live Terminal Streaming 1:07:12 Can You Scrub Back in a Live Stream? 1:14:40 Editing Recordings 1:25:27 Outro
- Feb 4, 20261h 41m
Building the SpacetimeDB Database, Game-First (with Tyler Cloutier)
Eighteen months ago, Tyler Cloutier appeared on the show with what sounded like an ambitious (some might say crazy) plan: build a new distributed database from scratch, then use it to power a massively multiplayer online game. That's two of the hardest problems in software, tackled simultaneously. But sometimes the best infrastructure comes from solving your own impossible problems. The game, Bitcraft, has now launched on Steam. SpacetimeDB has hit version 1.0. And Tyler returns to share what actually happened when theory met production reality. We cover the launch day performance disasters (including a cascading failure caused by logging while holding a lock), why single-threaded execution running entirely from L1 cache can outperform sophisticated multi-threaded approaches by two orders of magnitude, and how the database's reducer model - borrowed from functional programming - enables zero-downtime code deployments. We also get into how SpacetimeDB is expanding beyond games with TypeScript support and React hooks that make building real-time multiplayer web apps surprisingly simple. If you're building anything where multiple users need to see the same data update in real time - which, as Tyler points out, describes most successful applications from Figma to Facebook - SpacetimeDB's approach of treating every app as a multiplayer game might be worth understanding. -- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join SpacetimeDB: https://spacetimedb.com/ SpacetimeDB on GitHub: https://github.com/clockworklabs/SpacetimeDB Our previous episode with Tyler: https://youtu.be/roEsJcQYjd8 Clockwork Labs: https://clockworklabs.io/ Bitcraft Online: https://bitcraftonline.com/ Bitcraft on Steam: https://store.steampowered.com/app/3454650/BitCraft_Online WebAssembly: https://webassembly.org/ Flecs (ECS for C/C++): https://www.flecs.dev/flecs/ TigerBeetle: https://tigerbeetle.com/ CockroachDB: https://www.cockroachlabs.com/ Google Cloud Spanner: https://cloud.google.com/spanner Erlang: https://www.erlang.org/ Apache Kafka: https://kafka.apache.org/ Tyler Cloutier on X: https://x.com/TylerFCloutier Tyler Cloutier on LinkedIn: https://www.linkedin.com/in/tylercloutier/ -- Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ 0:00 Intro 2:01 The Architecture of SpacetimeDB 5:01 Client-Side Prediction in Multiplayer Games 11:00 Reducers and Event Streaming 15:00 Launching Bitcraft on Steam 19:00 Debugging Launch Performance Problems 26:56 Hot-Swapping Server Code Without Downtime 30:01 In-Memory Tables and Query Optimization 42:00 Is SpacetimeDB Only For Games? 51:00 Performance Benchmarking For Web Workloads 55:00 Why Single-Threaded Beats Multi-Threaded 1:00:01 Multi-Version Concurrency Control Trade-offs 1:05:01 Sharding Data Across Multiple Nodes 1:10:56 Inter-Module Communication and Actor Models 1:17:00 Replication and the Write-Ahead Log 1:24:00 Supported Client Languages 1:29:00 Getting Started With SpacetimeDB 1:39:02 Outro
- Dec 11, 20251h 51m
Will Turso Be The Better SQLite? (with Glauber Costa)
SQLite is embedded everywhere - phones, browsers, IoT devices. It's reliable, battle-tested, and feature-rich. But what if you want concurrent writes? Or CDC for streaming changes? Or vector indexes for AI workloads? The SQLite codebase isn't accepting new contributors, and the test suite that makes it so reliable is proprietary. So how do you evolve an embedded database that's effectively frozen? Glauber Costa spent a decade contributing to the Linux kernel at Red Hat, then helped build Scylla, a high-performance rewrite of Cassandra. Now he's applying those lessons to SQLite. After initially forking SQLite (which produced a working business but failed to attract contributors), his team is taking the bolder path: a complete rewrite in Rust called Turso. The project already has features SQLite lacks - vector search, CDC, browser-native async operation - and is using deterministic simulation testing (inspired by TigerBeetle) to match SQLite's legendary reliability without access to its test suite. The conversation covers why rewrites attract contributors where forks don't, how the Linux kernel maintains quality with thousands of contributors, why Pekka's "pet project" jumped from 32 to 64 contributors in a month, and what it takes to build concurrent writes into an embedded database from scratch. -- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Turso: https://turso.tech/ Turso GitHub: https://github.com/tursodatabase/turso libSQL (SQLite fork): https://github.com/tursodatabase/libsql SQLite: https://www.sqlite.org/ Rust: https://rust-lang.org/ ScyllaDB (Cassandra rewrite): https://www.scylladb.com/ Apache Cassandra: https://cassandra.apache.org/ DuckDB (analytical embedded database): https://duckdb.org/ MotherDuck (DuckDB cloud): https://motherduck.com/ dqlite (Canonical distributed SQLite): https://canonical.com/dqlite TigerBeetle (deterministic simulation testing): https://tigerbeetle.com/ Redpanda (Kafka alternative): https://www.redpanda.com/ Linux Kernel: https://kernel.org/ Datadog: https://www.datadoghq.com/ Glauber Costa on X: https://x.com/glcst Glauber Costa on GitHub: https://github.com/glommer Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ -- 0:00 Intro 3:16 Ten Years Contributing to the Linux Kernel 15:17 From Linux to Startups: OSv and Scylla 26:23 Lessons from Scylla: The Power of Ecosystem Compatibility 33:00 Why SQLite Needs More 37:41 Open Source But Not Open Contribution 48:04 Why a Rewrite Attracted Contributors When a Fork Didn't 57:22 How Deterministic Simulation Testing Works 1:06:17 70% of SQLite in Six Months 1:12:12 Features Beyond SQLite: Vector Search, CDC, and Browser Support 1:19:15 The Challenge of Adding Concurrent Writes 1:25:05 Building a Self-Sustaining Open Source Community 1:30:09 Where Does Turso Fit Against DuckDB? 1:41:00 Could Turso Compete with Postgres? 1:46:21 How Do You Avoid a Toxic Community Culture? 1:50:32 Outro
Get Developer Voices summaries in your inbox
Free AI-powered daily recaps. Key takeaways, quotes, and mentions — in a 5-minute read.
Get Free Summaries →Free forever for up to 3 podcasts. No credit card required.
You Might Also Like
Listeners also like.
The Peterman Pod
Career stories from a former Instagram Staff engineer to help software developers grow.
Syntax - Tasty Web Development Treats
Two full stack developers discuss JavaScript frameworks, CSS updates, and web tooling advancements.
The AI XR Podcast
Insightful interviews with tech founders and executives on AI, virtual reality, augmented reality, and the future of spatial computing.
Latent Space: The AI Engineer Podcast
Conversations with AI engineers, researchers, and founders on foundation models, AI agents, infrastructure, and scientific discovery.
The Pragmatic Engineer
Insightful deep dives with experienced engineers on real-world software development challenges and lessons.
"The Cognitive Revolution"
Explores the transformative impact of artificial intelligence through interviews with innovators shaping its future.
The Deep View: Conversations
Discusses AI advancements and leadership with innovators from labs, enterprises, and startups shaping the industry.
Lenny's Podcast: Product | Career | Growth
Conversations with top product and growth leaders offering practical strategies for building, launching, and scaling successful products.
Sources with Alex Heath
A podcast offering insider interviews with influential tech leaders and rising entrepreneurs shaping Silicon Valley's future.
Cheeky Pint
John Collison interviews founders, builders, and leaders over a pint.
Everyday AI Podcast – An AI and ChatGPT Podcast
Covers practical uses of AI tools like ChatGPT and Midjourney to help people work more efficiently and advance their careers.
Intelligent Machines (Audio)
Explores the impact of artificial intelligence through conversations with pioneers shaping the future of intelligent technology.
About Developer Voices
Deep-dive discussions with the smartest developers we know, explaining what they're working on, how they're trying to move the industry forward, and what we can learn from them.You might find the solution to your next architectural headache, pick up a new programming language, or just hear some good war stories from the frontline of technology.Join your host Kris Jenkins as we try to figure out what tomorrow's computing will look like the best way we know how - by listening directly to the developers' voices.
Customized Recaps
AI-powered recaps with compact key takeaways, quotes, and insights.
Straight to Your Inbox
Get key takeaways from Developer Voices in a 5-minute read.
Save Hours Every Week
Stay current on your favorite podcasts without falling behind.
Frequently Asked Questions
What is Podzilla's Developer Voices daily summary?
It's a free AI-powered email that summarizes new episodes of Developer Voices as soon as they're published. You get the key takeaways, notable quotes, and links & mentions — all in a quick read.
How does the Developer Voices podcast summary work?
When a new episode drops, our AI transcribes and analyzes it, then generates a personalized summary tailored to your interests and profession. It's delivered to your inbox every morning.
Is this an official Developer Voices product?
No. Podzilla is an independent service that summarizes publicly available podcast content. We're not affiliated with or endorsed by Kris Jenkins.
Can I get summaries of other podcasts too?
Absolutely! The free plan covers up to 3 podcasts, any in the catalog. Basic raises that to 15, Pro to 40 and Max to 100. Browse our full catalog at /podcasts.
How often does Developer Voices release new episodes?
Developer Voices publishes biweekly. Our AI generates a summary within hours of each new episode.
What topics does Developer Voices cover?
Developer Voices covers topics including News, Technology. Our AI identifies the specific themes in each episode and highlights what matters most to you.
Start getting Developer Voices summaries tomorrow morning.
Free forever for up to 3 podcasts. No credit card required.
Free forever for up to 3 podcasts. No credit card required.