Developer Voices

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/

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/

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/

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/

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/