All Episodes
92 deep technical conversations with the smartest developers in the industry
Why Make Apache Kafka Diskless? (with Filip Yonov & Josep Prat)
How do you retrofit a clustered data-processing system to use cheap commodity storage? That’s the big question in this episode as we look at one of the many attempts to build a version of Kafka that u...
Java’s Cutting Edge Comeback (with Josh Long)
Java’s has been evolving faster than any 30 year old language has a right to do, and there’s probably no-one more pleased about it than my guest this week - Josh Long. He’s a Java & Kotlin programming...
The State & Future of Apache Kafka (with Anatoly Zelenin)
I’m joined this week by one of the authors of Apache Kafka In Action, to take a look at the state of Kafka, event systems & stream-processing technology. It’s an approach (and a whole market) that’s h...
DataFusion - The Database Building Toolkit (with Andrew Lamb)
Building a database is a serious undertaking. There are just so many parts that you have to implement before you even get to a decent prototype, and so many hours of work before you could begin workin...
Jupyter’s Architecture Unpacked (with Afshin Darian & Sylvain Corlay)
Jupyter’s become an incredibly popular programming and data science tool, but how does it actually work? How have they built an interactive language execution engine? And if we understand the architec...
Nix, The Build Everything Language (with Julian Arni)
Ever since we invented makefiles, the programming world has been wrestling with the problem of building software stacks reliably. This week we’re going to look at one of the most ambitious solutions a...
Rust-Powered Graphics Editor: How Graphite's Syntax Trees Revolutionize Image Editing
Graphite is a new image editor with an interesting architecture - it’s a classic UI-driven app, an image-manipulation language, and a library of programmable graphics primitives that any Rust coder co...
ReScript: A Better Typed JavaScript? (with Gabriel Nordeborn)
ReScript is a strongly-typed programming language that compiles to JavaScript, and that puts it squarely in competition with TypeScript. So why would a JavaScript developer choose to learn it next? Wh...
A Universal Query Engine in Rust (with Predrag Gruevski)
Trustfall is a library based on a simple question - what happens if we can query absolutely anything? If you could join REST APIs and databases with filesystems and Dockerfiles? It’s possible in theor...
Music with Raspberry Pi Hardware & A Lisp Brain (with Dimitris Kyriakoudis)
Dimitris Kyriakoudis is a researcher, programmer and musician who's combining all three talents to build dedicated music hardware. Specifically a device called the µseq, which reads Lisp programs and ...
Software Systems Aren’t Just Software (with Diana Montalion)
If you want to build really large software systems well, you have to stop thinking of them as just software systems. Beyond a certain size, everything your software touches becomes part of the wider s...
Building Fyrox: A Rust Game Engine (with Dmitry Stepanov)
To kick off 2025 we’re looking at Fyrox a game engine built in Rust, largely by one person - Dmitry Stepanov. For an individual project, it’s covered an incredible amount of ground, covering the rende...
Testing TVs At Scale With Elixir (with Dave Lucia)
Integration testing is always a tricky thing, fraught with problems setting up the right environment and attempting to control the system’s state. That’s particularly true when you’re dealing with a m...
Sonic Pi: Programming As An Expressive Instrument (with Sam Aaron)
Sam Aaron is the creator of Sonic Pi, one of the most unusual software platforms you’ll encounter. It’s a live-coding playground for making music. A tool that lets you write code that defines sounds a...
Elm & The Future of Open Source (with Evan Czaplicki)
Evan Czaplicki—the creator of the Elm programming language —joins me to discuss the state and future of Elm, the friendly, type-safe functional programming language. On many fronts Elm has been a huge...
Programmers, ADHD, And How To Manage Them Both (with Chris Ferdinandi)
This week we’re going to look at the most essential piece of firmware in a programmer’s toolkit - the brain. I’m joined by Chris Ferdinandi to explore what it’s like to be a programmer with ADHD. It’s...
MicroServices For Better And Worse (with Ian Cooper and James Lewis)
What have we learned from more than a decade of deploying microservices? Was it a good idea? Are we any better at figuring out what a microservice is, or where its boundaries lie? Does splitting thing...
Pony: High-Performance, Memory-Safe Actors (with Sean Allen)
Pony is a language born out of what should be a simple need - actor-style programming with C performance. On the face of it, that shouldn’t be too hard to do. Writing an actor framework isn’t trivial,...
Architecting Bevy - A Rust Game Engine (with Alice Cecile)
This week we take a look at Bevy, a new game engine written in Rust. And in particular, we look at a core component of Bevy that has something to teach you even if you never write a game: its Entity C...
Writing a CAD Language in Rust (with Adam Chalmers)
Given how many languages have been written in C over the years, it’s not surprising to see new languages being written in Rust. What is surprising about this week’s guest is the domain he’s writing fo...
Ratatui: Building Text User Interfaces in Rust (with Orhun Parmaksız)
For some kinds of application, there is no faster or cheaper way to build a user interface than in the terminal. Sure, it’s not going to suit every kind of user out there, but for those of us that are...
Designing The Lustre Web Framework (with Hayleigh Thompson)
Designing The Lustre Web Framework (with Hayleigh Thompson) Lustre is a web framework that takes a lot of inspiration from Elm, some from React, and a surprising amount from Erlang’s actor model, to ...
Faust: A Programming Language For Sound (with Romain Michon)
I’m always interested in what factors shape the design of a programming language. This week we’re taking a look at a language that’s wholly shaped by its need to support a very specific kind of progra...
GPUs, from Simulation to Encryption (with Agnès Leroy)
This week we take a look at what you can do with a GPU when you get away from just using it to draw polygons. Agnès Leroy has spent most of her career programming, optimizing and converting programs t...
The State of Full-Stack OCaml (with António Monteiro)
OCaml has one of the best-loved compilers available, and parts of it are surprisingly pluggable, so it’s not surprising that someone would eventually try to wed OCaml with JavaScript and the web brows...
Multiplatform Maps Built As Layers on Rust (with Ian Wagner)
Mapping is a hugely complex task to take on. Even if you moved as much of the data-management as you can out to 3rd-party services, you’d still have a tonne of work to do weaving together map tiles, r...
Building a New Terminal App (with Zach Lloyd)
The terminal might be the most used development tool in history. So it’s a little odd that it hasn’t changed that much in the decades since the terminal first came into being. Is the terminal a “compl...
Building A Programming Language From Its Core (with Peter Saxton)
A language’s AST—it’s abstract syntax tree—is nearly always a hidden implementation detail. It’s not treated as part of the language, but merely the intermediate step between parsing and compiling. Bu...
Practical Applications for DuckDB (with Simon Aubury & Ned Letcher)
DuckDB’s become a favourite data-handling tool of mine, simply because it does so many small things well. It can read and write a huge number of data formats; it can infer schemas automatically when y...
Recording and Replaying the Browser (with Justin Halsall)
RRWeb is based on a simple idea: If you capture all the DOM events in a browser session, and when they happened, you could play it back later. Play it back for diagnosing error conditions, for underst...
Zig as a Multi-OS Build System (with Loris Cro)
The ZigLang team have put an astonishing amount of effort into making Zig work an effective tool for compiling C across different architectures. Work that benefits the Zig language, but also has a cha...
Creating and Evolving Elixir (with José Valim)
Back in 2012, José Valim started building Elixir to as a way to have his ideal programming language running on the same platform as Erlang. Fast-forward 12 years and it’s become build anything from di...
PyO3: From Python to Rust and Back Again (with David Hewitt)
There’s huge pressure on Python at the moment to get faster, ideally without changing at all. One increasingly–popular way of achieving that impossible task is to push the performance critical code do...
Inter-System Messaging with NATS & Jetstream (with Jeremy Saenz)
Most message systems have an opinion on the right way to do inter-systems communication. Whether it’s actors, queues, message logs or just plain ol’ request response, nearly every tool has decided on ...
Cuis Smalltalk and the History of Computing’s Future (with Juan Vuletich)
Smalltalk is one of those programming languages that’s lived out of the mainstream, but often referenced as an influence and an important part of programming history. It’s the cornerstone of object-or...
The Inko Programming Language, and Life as a Language Designer (with Yorick Peterse)
This week we take a close look at the programming language Inko from two perspectives: The language design features that make it special, and the realities of being a language developer. Yorick Peter...
Building the Zed Text Editor (with Nathan Sobo)
I’ve often wondered how you build a text editor. Like many software projects, it’s a simple idea at the core with an almost infinite scope for features. How do you build a solid foundation to expand o...
How Warpstream Reimplemented Apache Kafka with Golang and S3
This week on Developer Voices we’re talking to Ryan Worl, whose career in big data engineering has taken him from DataDog to Co-Founding WarpStream, an Apache Kafka-compatible streaming system that us...
Extending Postgres for High Performance Analytics (with Philippe Noël)
PostgreSQL is an incredible general-purpose database, but it can’t do everything. Every design decision is a tradeoff, and inevitably some of those tradeoffs get fundamentally baked into the way it’s ...
Actor Model Programming: Building Resilient Distributed Systems (with Hugh McKee)
The actor model is a popular approach to building scalable software systems. And isn’t hard to understand when you’re just reading about the beginner’s examples. But how do you architect a complex des...
ByteWax: Rust's Research Meets Python's Practicalities (with Dan Herrera)
Bytewax is a curious stream processing tool that blends a Python surface with a Rust core to produce something that’s in a similar vein to Kafka Streams or Apache Flink, but with a fundamentally diffe...
Mojo Lang - Tomorrow's High Performance Python? (with Chris Lattner)
Mojo is the latest language from the creator of Swift and LLVM. It’s an attempt to take some of the best techniques from CPU/GPU-level programming and package them up in a Python-compatible syntax. I...
Batch Data & Streaming Data in one Atom (with Jove Zhong)
Every database has to juggle the need to process new data and to query old data. That task falls to any system that “does stuff and remembers stuff”. But it’s quite hard to really optimise one system ...
Advanced Memory Management in Vale (with Evan Ovadia)
Rust changed the discussion around memory management - this week's guest hopes to push that discussion even further. This week we're joined by Evan Ovadia, creator of the Vale programming language an...
Bringing Pure Python to Apache Kafka (with Tomáš Neubauer)
The “big data infrastructure” world is dominated by Java, but the data-analysis world is dominated by Python. So if you need to analyse and process huge amounts of data, chances are you’re in for a le...
Developing a Neovim Docker Plugin from Scratch
Time for a bit of Lua hacking. Ever since I fell down the Neovim rabbit hole I've been having a tonne of fun building little extensions and plugins. And I found that by using Telescope as a framework,...
Taking Erlang to OCaml 5 (with Leandro Ostera)
Erlang wears three hats - it’s a language, it’s a platform, and it’s an approach to making software run reliably once it’s in production. Those last two are so interesting I sometimes wonder why those...
How Apache Pinot Achieves 200,000 Queries per Second (with Tim Berglund)
The likes of LinkedIn and Uber use Pinot to power some astonishingly high-scale queries against realtime data. The numbers alone would make an impressive case-study. But behind the headline lies a fas...
Neovim: Creating, Curating and Customising Your Ideal Editor (with TJ DeVries)
TJ DeVries is a core contributor to Neovim and several of its most interesting sub-projects, and he joins us this week to go in depth into how Neovim got started, how it’s structured, and what a truly...
The Magic of Property Testing
I like well-tested code. But I don't like writing and maintaining hundreds of unit tests. So here's a quick walkthrough of one of my favourite testing techniques - property testing. Under the right ci...
Creating Hackathons that Work (with Jon Gottfried)
Done right, a Hackathon can be a fantastic place to be a programmer - you get time and space to build and learn, in a room full of like-minded people, with swag and prizes to sweeten the deal. It’s a ...
Automate Your Way to Better Code: Advanced Property Testing (with Oskar Wickström)
One of the most promising techniques for software reliability is property testing. The idea that, instead of writing unit tests we describe some property of our code that ought to always be true, then...
Bridging the Gap Between Languages (with Martin Johansen)
If you ever feel overwhelmed by the number of different programming languages, this week’s episode might just offer you some solace, as we talk about an attempt to reunify many of the most popular lan...
How do refactoring tools work? (with Jonathan Schneider)
A lot of programming is split into the mechanical work of writing what you know, and the creative work of figuring out what you don’t know. Wouldn’t it be nice to automate the mechanical stuff away? W...
DuckDB: How to Build 100x Faster Analytics Databases (with Co-Creator Hannes Mühleisen)
SQLite could do with a little competition, so when I invited the co-creator of DuckDB in to talk, I thought we'd be discussing the perils of trying to build a new in-process database engine. I quickly...
Exploring Verse, Haskell, Language Design and Teaching (with Simon Peyton Jones)
This week we talk to Simon Peyton Jones, a veteran language designer and researcher, and key figure in the development of Haskell. Haskell. Simon has made countless contributions to advancement of fun...
Shouldn't Data Connections Be Easier? (with Ashley Jeffs)
Benthos wants to be part of your Data Engineering toolkit - it’s there as a quick and easy way to set up data pipelines and start streaming data out of A and into B. In contrast to a lot of the tools ...
What can game programming teach us about databases? (with Tyler Cloutier)
The world of game programming might seem a million miles away from 'regular' programming. But they still have to deal with the same kinds of data, scale and concurrency problems that we’re all familia...
Is Odin "Programming done right"? (with Bill Hall)
Odin’s creator, Bill Hall, makes some bold claims about the language, including that it’s “programming done right”. Before that starts a war on the internet, we’d best ask him to explain what that mea...
Event-Driven Architecture: From Complexity to Simplicity (with Bobby Calderwood)
This week’s guest describes Event Sourcing as, “all I’m going to use for the rest of my career.” But what is Event Sourcing? How should we think about it, and how does it encourage us to think about w...
How Lisp is designing Nanotechnology (with Prof. Christian Schafmeister)
One of our oldest languages meets one of our newest sciences in this episode, as we talk with Professor Christian Schafmeister, an award-winning nanotech researcher who's been developing a language an...
Roc - A Functional Language looking for those Software Sweetspots (with Richard Feldman)
Sometimes, what a programming language makes harder is just as important as what it makes easier. For a simple example, think of GOTO. We’ve been wisely avoiding it for decades because it makes confus...
If Kafka has a UX problem, does UNIX have the answer? (with Luca Pette)
One of the recurring themes in the big data & data streaming worlds at the moment is developer experience. It seems like every major tool is trying to answer this question: how do we make large-scale ...
Will we be writing Hare in 2099? (with Drew DeVault)
This week we're back on systems programming with Hare. A C-like language for the ages. We talk to its creator, Drew DeVault, about what he thinks we can learn from the past 50 years of programming, an...
Startups Should Solve Real People's Real Problems (with Michael Drogalis)
A few months ago, Michael Drogalis quit his job and decided launch 4 viable startup business ideas in 4 months, publically documenting every step of the journey. Over here at Developer Voices it seeme...
Is Flink the answer to the ETL problem? (with Robert Metzger)
Integration is probably the last, hardest, and least well thought-out part of any large software project. So anything that makes the data-streaming job easier is worth knowing about. So this week we t...
What's Zig got that C, Rust and Go don't have? (with Loris Cro)
Zig is a programming language that’s attempting to become “the new C” - the language of choice for low-level systems programming and embedded hardware. Going into that space not only puts it in compet...
Why did Redpanda rewrite Apache Kafka? (with Christina Lin)
Would you ever take on a rewrite of one of the largest and most popular Apache projects? And if so, what would you keep the same and what would you change? This week we’re talking to Christina Lin, wh...
Debezium - Capturing Data the Instant it Happens (with Gunnar Morling)
This week we’re looking at Debezium - an open source project that taps into a huge number of databases and lets you stream data to other systems in real time. It’s a huge project that covers a wide ra...
When We Talk About Software (with Francesco Tisiot)
Ever read a bad README? We all have, and most of the time, we’ve just moved right along. A programmer that can’t communicate their ideas will find no-one uses their software. And that’s true even outs...
Semantic Search: A Deep Dive Into Vector Databases (with Zain Hasan)
As interesting and useful as LLMs (Large Language Models) are proving, they have a severe limitation: they only know about the information they were trained on. If you train it on a snapshot of the in...
Real Time Data - Why isn’t everyone doing it? (with Thomas Camp)
Real-time data is gradually becoming a standard requirement in systems design. Our customers are beginning to demand it, our colleagues in other departments are starting to expect it. Whether you’re l...
Databases, Ambitions, and a Testing Silver Bullet? (With Joran Dirk Greef)
How far would you go to get the kind of database you want? How deep into the stack would you dive to re-architect a system for the kind of performance, reliability and scale you believe in? Today's gu...
Starting A Tech Business. Again. And Again. And Again. (with Michael Drogalis)
Ever wanted to start a tech business? Michael Drogalis has done it successfully in the past, and now he’s trying again (and again and…) as he makes a very public attempt to start 4 new tech businesses...
How Do You Assemble a Complete Software System? (with Ben Gamble)
Ask any software developer about their favourite stack, and they'll probably have strong opinions. (They might even have a snappy acronym for it, like LAMP or JAM or...) But if you ask any business ab...
Clickhouse: Faster Queries, Faster Answers (with Alasdair Brown)
In modern systems, the amount of data keeps getting larger, and the time available keeps getting shorter. So it's almost inevitable that we're augmenting our general-purpose databases with dedicated a...
What problems does Apache Kafka Solve? (with Neil Buesing)
Neil Buesing is a seasoned Apache Kafka® user, and a respected voice from the Kafka community who specialises in helping companies make the best use of Kafka. And that makes him the ideal person to as...
What's the secret to building distributed systems? (with Benjamin Bengfort)
How do distributed systems work? If you’ve got a database spread over three servers, how do they elect a leader? How does that change when we spread those machines out across data centers, situated ar...
Getting started in programming? What's the best predictor of success? (with James Q. Quick)
How do you get started as a programmer? And how do experienced programmers help them as they start their journey? This week's guest is a developer-turned-teacher, James Q. Quick. A former coder and d...
Better database access with SQL-centric APIs (with Lukas Eder)
Sooner or later, every programmer will have to cross the gap between their programming language and their database. It feels like it should be easy, but in practice it’s always a much wider chasm than...
Inside the World of Competitive Coding (with Mathis Hammel)
Whether you’re trying to ace the coding interview, sharpen your programming skills or just have some fun learning new things, the world of competitive coding has something to offer you. Some people jo...
How Unison is Rethinking Distributed Programming (with Rúnar Bjarnason)
“Software development has not caught up with the internet age.” So says this week’s guest, Rúnar Bjarnason. But what does that mean? What would a programming language for the internet age look like? ...
The Evolution of Databases and the Future of Database Technology (with Ben Stopford)
Have you ever been overwhelmed by the number of databases on offer? This week we welcome database expert Ben Stopford as a guide to help us map the database landscape and make sense of it all! Join u...
The Open Source AI Revolution Begins Now... (with Tobi Fankhänel)
#LLMs like #ChatGPT are not just fascinating, they're becoming increasing useful in our working lives. They've graduated from novelty to valuable tool. But building those tools is still in the hands o...
Gren: The friendly, fullstack, functional future? (with Robin Heggelund Hanson)
Time to put another new #programming language - and its creator - under the spotlight, as we talk to Robin Heggelund Hansen, the creator of Gren. Gren is a Norwegian word meaning 'branch', which is ap...
PostgreSQL in the Cloud (with Raouf Chebri of Neon)
What's going on with #Postgres? Joining us for his perspective is Raouf Chebri, a Developer Advocate for #PostgreSQL and the cloud service Neon. We catch up on what's new and important in recent versi...
Building Strong Software Communities (with Ale Murray)
Are you trying to build the community around your software? And what does “building a community” really mean? How can we build stronger communities, and what are the benefits of all that work? Join u...
Bitemporal Databases: What They Are and Why They Matter (with James Henderson of XTDB)
As a developer, it's crucial to understand the various types of databases available so you can choose the right tool for the job. In this episode, we're shining a spotlight on bitemporal databases wit...
What are the fundamentals of Data Engineering? (with Joe Reis)
Every business deals in data, but the internet age has ushered in an explosion of the number of different data formats we have to process, from an increasing number of different data sources. Ask any ...
Is Kotlin the language for all platforms? (with James Ward of Google)
In this episode we're exploring the Kotlin programming language with an expert from Google. What does Kotlin have to offer? Is it just a Java alternative, or has it turned into something much more amb...
How Do You Get AI Into Production? (with Adi Polak)
AI is the new hotness, but with new approaches come new problems of scale. How do you make raw data accessible to teams of data scientists and model-builders? How do build a repeatable deployment pipe...
Is Gleam your next programming language? (with Louis Pilfold)
Louis Pilfold joins us to talk about Gleam, a new language that runs on Erlang's BEAM. In creating Gleam, Louis has tried to bring a new level of developer-friendliness to Erlang's famously fault-tole...