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 understanding your user’s journey, or for creating demo videos that can be edited element-by-element instead of frame-by-frame. Unfortunately, the simple idea gets tricky when you try to implement, for a whole host of browser specific glitches, differences, and places where the HTML5 spec ran out. It’s exa...
Jul 24, 2024•1 hr 3 min
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 chance to benefit languages like Python and Rust. Or indeed, any language that uses native C libraries somewhere in its stack. So this week we’re joined by Loris Cro of the Zig team to dive into how you make a reliable, cross-platform toolchain that can compile C anywhere it finds it. And in doing so, ...
Jul 17, 2024•1 hr 19 min
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 distributed infrastructure to notebooks and websites. In this week’s Developer Voices, José joins us to tell the history of Elixir in a series of design choices. Which features mattered to him in the early days, and which ones excite him most now. What’s going on under the hood to make Elixir tick, an...
Jul 10, 2024•1 hr 42 min
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 down into C, C++, or Rust. And this week we’re focussing on the Python route, as we take a look at PyO3. David Hewitt’s the principal committer to PyO3, and he joins us to go through the easy parts, the hard parts, and the works in progress, giving us an insight into how Python and Rust work under the...
Jul 03, 2024•1 hr 34 min
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 The Right Way to do messaging, and it optimises heavily for that specific approach. But NATS is absolutely running against that trend. In this week’s episode, Jeremey Saenz joins us to talk about NATS, the Cloud Native Computing Foundation’s configurable message-passing and data-transfer system. The...
Jun 26, 2024•1 hr 11 min
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-oriented programming, it was into message passing before actors were cool, and it blurs the line between operating system, programming language and personal notebook. But what is it? Joining us to discuss it is Juan Vuletich, the creator of one of Smalltalk’s latest incarnations, Cuis. In this episode...
Jun 19, 2024•1 hr 19 min
This week we take a close look at the language Inko from two perspectives: The language design features that make it special, and the realities of being a language developer. Yorick Peterse joins us to discuss why he’s building Inko, and which design sweetspots he’s looking for. We begin with memory management, aiming for the kind of developer who wants control, but without the complexities of Rust. Then we look at the designing for concurrency with typed channels, and handling exceptions by rem...
Jun 12, 2024•1 hr 24 min
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 on? Which features matter for launch? And how do you hope to satisfy the needs of every programmer, working in every language? My guest for this episode is Nathan Sobo. He’s tackled this problem once before with the Atom editor, and he’s back older & wiser with Zed - a new editor written complete...
Jun 05, 2024•1 hr 24 min
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 uses Golang for the brains and S3 for the storage. Ryan tells us about his time at DataDog, along with the things he learnt from doing large-scale systems migration bit-by-bit, before we discuss how and why he started WarpStream. Why re-implement Kafka? What are the practical challenges and cost benef...
May 29, 2024•1 hr 23 min
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 built. Take storage for instance - Postgres tables are row-oriented; great for row-by-row access, but when it comes to analytics, it can’t compete with a dedicated OLAP database that uses column-oriented storage. Or can it? Joining me this week is Philippe Noël of ParadeDB, who’s going to take us on...
May 22, 2024•1 hr 8 min
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 design using the actor model? Which patterns work well? How do you think through it? Joining me to take us through it is Hugh McKee. Hugh’s a total actor-model fan, and a Developer Advocate for Lightbend (the company that created the popular actor framework Akka). He takes us from his definition of act...
May 15, 2024•1 hr 12 min
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 different implementation. This week we’re going to take a look at what it does, how it works in theory, and how the marriage of Python and Rust works in practice… – The original Naiad Paper: https://dl.acm.org/doi/10.1145/2517349.2522738 Timely Dataflow: https://github.com/TimelyDataflow/timely-dataflow ...
May 08, 2024•1 hr 2 min
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. In this episode we explore why Mojo was created, and what it offers to Python programmers and non-Python programmers alike. How is it built for performance, and which performance features matter? What’s its take on functional programming and type systems? And can it marry the high-level programming of...
May 01, 2024•1 hr 25 min
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 for both use cases. There are different constraints on new and old data, and as a system gets larger and larger, those differences multiply to breaking point. That’s something Twitter’s engineers were figuring out in the 2010s. One solution that came up in those years was the Lambda Architecture. A ...
Apr 24, 2024•52 min
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 and collector of memory management techniques from far and wide. He takes us through his most important ones, including linear types, generation references and regions, to see what Evan hopes the future of memory management will look like. If you've been interested in Rust's borrow-check and want more ...
Apr 17, 2024•1 hr 10 min
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 less-than-ideal time. The impedance mismatch will probably make your life hard somehow. So there are a lot of projects and companies trying to solve that problem. To bridge those two worlds seamlessly, and many of the popular solutions see SQL as the glue. But this week we’re going to look at another ...
Apr 03, 2024•1 hr 7 min
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 ideas haven’t been ported to every language going. How much work would it be? This week we’re going to dig right down into that question with Leandro Ostera. He’s been working on Riot - a project to bring the best of Erlang’s runtime system and philosophy to OCaml. But why OCaml? Is it possible to ...
Mar 27, 2024•1 hr 4 min
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 fascinating set of architectural decisions and constraints to get there. So how does Pinot work? How does it process queries? How are the various roles split across a cluster? And equally important - what does it *not* try to achieve. Joining me to go through the nuts and bolts of how Pinot handles SQL...
Mar 20, 2024•1 hr 14 min
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 programmable editor has to offer programmers who want the perfect environment. Along the way we look at what we can learn from Neovim’s successful fork of the 30-year old codebase from Vim, how it still collaborates with the original project, and what putting Lua at the heart of the system has done...
Mar 13, 2024•1 hr 8 min
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 great way to pick up new ideas and run with them. But done wrong it can be a waste of time. What’s the difference between a good hackathon and a bad one? What do the good ones do right, and what can we learn from that? This week we’re talking about the Joy of Hacks with Major League Hacking Co-Found...
Mar 06, 2024•1 hr 3 min
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 have the computer figure out thousands of unit tests that try to break that rule. For example, you might say, “No matter which page you visit on my website, there should always be a login button or a logout button.” Then the test’s job is to try to break that rule, but clicking around until it find...
Feb 28, 2024•1 hr 7 min
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 languages by focussing on the bread & butter things that every language supports. I’m joined by Martin Johansen, who’s been working on a new tool called Progsbase. With it, he’s created a spec based on all the things programming languages can agree on, and is building a library that can cross-compi...
Feb 21, 2024•49 min
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? Well the good news is we’re already automating a lot of it. Every time you run a refactoring tool or a pretty-printer, you’re handing boring work off to the computer. But how does that magic work, and how can we do more of it? This week we’re joined by one of the authors of OpenRewrite—Jonathan Schne...
Feb 14, 2024•1 hr 3 min
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 realised things went much deeper than just a tech refresh. Hannes Mühleisen joins me this week to blend his academic credentials as a database researcher with his vehement need to make that research practical. And so we dive into what modern database literature has to say on making queries faster, ...
Feb 07, 2024•1 hr 20 min
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 functional programming, and computer programming in general, and is currently working at Epic Games, working on the foundations of their new programming language, Verse. We discuss how programming languages are made, focussing on a big design idea from both Haskell and Verse: building a large language ...
Jan 31, 2024•1 hr 23 min
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 we’ve talked about on Developer Voices, Benthos seems focussed on cutting development time down to a minimum, so you can quickly configure a new pipeline and test it out, without making a whole sprint of the task. As quick as a quick-and-dirty shell script, without the dirt. 😉 So this week we’re ta...
Jan 24, 2024•1 hr 15 min
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 familiar with in the software world. And that makes the gaming world an interesting place for new ideas - under the hood they’re solving those same problems we face, but often with some novel ideas about the solutions. So this week we’re off to the massive open world that is game development, to see what w...
Jan 17, 2024•1 hr 6 min
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 means, and how Odin tries to achieve it. And while we get deep into the details, overall his answer seems to be, “By gathering masses of feedback and then refining C until it feels joyous again. Of all the C-like languages we’ve looked at on Developer Voices, Odin seems to be the most at-ease with its ...
Jan 10, 2024•1 hr
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 writing software? In this episode we take a close look at systems designed around the idea of Events, with guest Bobby Calderwood. Bobby’s been designing (and helping others design) event based architectures for many years, and enthusiastically recommends it not only as a system-design technique, but...
Jan 03, 2024•1 hr 10 min
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 and a design suite to help research the future molecular machines. In this episode Christian gives us a quick chemistry lesson to explain what his research is trying to achieve, then we get into the software that's doing it: A new flavour of Common Lisp. But why Lisp? What advantages does a 60 year ol...
Dec 27, 2023•53 min
