Shows
Developer VoicesBuilding 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...
2026-02-041h 41Developer VoicesWill 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...
2025-12-111h 51Developer VoicesCan Google's ADK Replace LangChain and MCP? (with Christina Lin)How do you build systems with AI? Not code-generating assistants, but production systems that use LLMs as part of their processing pipeline. When should you chain multiple agent calls together versus just making one LLM request? And how do you debug, test, and deploy these things? The industry is clearly in exploration mode—we're seeing good ideas implemented badly and expensive mistakes made at scale. But Google needs to get this right more than most companies, because AI is both their biggest opportunity and an existential threat to their search-based business model.Christina Lin from Google joins us...
2025-11-201h 05Developer VoicesBuilding Observable Systems with eBPF and Linux (with Mohammed Aboullaite)How do you monitor distributed systems that span dozens of microservices, multiple languages, and different databases? The old approach of gathering logs from different machines and recompiling apps with profiling flags doesn't scale when you're running thousands of servers. You need a unified strategy that works everywhere, on every component, in every language—and that means tackling the problem from the kernel level up.Mohammed Aboullaite is a backend engineer at Spotify, and he joins us to explore the latest in continuous profiling and observability using eBPF. We dive into how eBPF lets you programmatically peek into th...
2025-10-311h 11Developer VoicesSolving Git's Pain Points with Jujutsu (with Martin von Zweigbergk)Git might be the most ubiquitous tool in software development, but that doesn't mean it's perfect. What if we could keep Git compatibility while fixing its most frustrating aspects—painful merges, scary rebases, being stuck in conflict states, and the confusing staging area?This week we're joined by Martin von Zweigbergk, creator of Jujutsu (JJ), a Git-compatible version control system that takes a fundamentally different approach. Starting from a simple idea—automatically snapshotting your working copy—Martin has built a tool that reimagines how we interact with version control. We explore the clever algebra behind Jujutsu's conflict handli...
2025-10-091h 11Developer VoicesGetting New Technology Adopted (with Dov Katz)Getting new technology adopted in a large organization can feel like pushing water uphill. The best tools in the world are useless if we're not allowed to use them, and as companies grow, their habits turn into inertia, then into "the way we've always done things." So how do you break through that resistance and get meaningful change to happen?This week's guest is Dov Katz from Morgan Stanley, who specializes in exactly this challenge - driving developer productivity and getting new practices adopted across thousands of developers. We explore the art of organizational change from every...
2025-09-241h 05Developer VoicesFrom Unit Tests to Whole Universe Tests (with Will Wilson)How confident are you when your test suite goes green? If you're honest, probably not 100% confident - because most bugs come from scenarios we never thought to test. Traditional testing only catches the problems we anticipate, but the 3am pager alerts? Those come from the unexpected interactions, timing issues, and edge cases we never imagined.In this episode, Will Wilson from Antithesis takes us deep into the world of autonomous testing. They've built a deterministic hypervisor that can simulate entire distributed systems - complete with fake AWS services - and intelligently explore millions of possible states to...
2025-09-101h 12Developer VoicesBuilding Render: Inside a Modern Cloud Platform (with Anurag Goel)How would you build a Heroku-like platform from scratch? This week we're diving deep into the world of cloud platforms and infrastructure with Anurag Goel, founder and CEO of Render.Starting from the seemingly simple task of hosting a web service, we quickly discover why building a production-ready platform is far more complex than it appears. Why is hosting a Postgres database so challenging? How do you handle millions of users asking for thousands of different features? And what's the secret to building infrastructure that developers actually want to use?We explore the technical challenges...
2025-08-221h 24Developer VoicesInfluxDB: The Evolution of a Time Series Database (with Paul Dix)How hard is it to write a good database engine? Hard enough that sometimes it takes several versions to get it just right. Paul Dix joins us this week to talk about his journey building InfluxDB, and he's refreshingly frank about what went right, and what went wrong. Sometimes the real database is the knowledge you pick up along the way....Paul walks us through InfluxDB's evolution from error logging system to time-series datasbase, and from Go to Rust, with unflinching honesty about the major lessons they learnt along the way. We cover technical details like Time-Structure...
2025-07-301h 49Developer VoicesBeyond AI Hype, What Will Developers Actually Use? (with Zach Lloyd)If AI coding tools are here to stay, what form will they take? How will we use them? Will they be just another window in our IDE, will they push their way to the centre of our development experience, displacing the editor? No one knows, but Zach Lloyd is making a very interesting bet with the latest version of Warp.In this deep dive, Zach walks us through the technical architecture behind agentic development, and how it's completely changed what he & his team have been building. Warp has gone from a terminal built from scratch, to what...
2025-07-171h 18Developer VoicesThe $500 Billion Integration Problem, And One Possible Solution (with Marty Pitt)Ever wondered why data integration is still such a nightmare in 2025? Marty Pitt has built something that might finally solve it.TaxiQL isn't just another query language - it's a semantic layer that lets you query across any system without caring about field names, API differences, or where the data actually lives. Instead of writing endless mapping code between your microservices, databases, and APIs, you describe what your data *means* and let TaxiQL figure out how to get it.In this conversation, Marty walks through the “All Powerful Spreadsheet” moment that sparked TaxiQL, how semantic type...
2025-07-041h 31Developer VoicesMaking Software Crash Before It Breaks (with Isaac Van Doren)At 23, Isaac is already jaded about software reliability - and frankly, he's got good reason to be. When your grandmother can't access her medical records because a username change broke the entire system, when bugs routinely make people's lives harder, you start to wonder: why do we just accept that software is broken most of the time?Isaac's answer isn't just better testing - it's a whole toolkit of techniques working together. He's advocating for scattering "little bombs" throughout your code via runtime assertions, adding in the right amount of static typing, building feedback loops that page...
2025-06-1957 minDeveloper VoicesMaking 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 uses object storage services like S3 as its main disk, sacrificing a little latency for cheap, infinitely-scalable disks.There are several companies trying to walk down that road, and it’s clearly big business - one of them recently got bought out for a rumoured $250m. But one of them is actively trying to get those changes back into the comm...
2025-06-051h 29Developer VoicesJava'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, a JVM enthusiast in general, and an advocate for Spring, and he has chapters full of news about what’s been happening in Javaland over the past few years. Everything from new threading models to C interop changes, custom primitives to high performance computing and all the ways in which Java is modernising for age of AI workloads.
2025-05-231h 24Developer VoicesThe 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 had at least a decade to mature, so how has it done? What does Kafka offer to developers and businesses, and which parts do they actually care about? What have streaming data systems promised and what have they actually delivered? What’s still left to build?–Apache Kafka in Action: https://www.manning.com/books/apache-kafka-in-actionPat Hell...
2025-05-081h 12Developer VoicesDataFusion - 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 working on the ideas that would make your database unique. Apache DataFusion is a project that hopes to change all that, but building an extensible, composable toolkit of database pieces, which could let you build a viable database extremely quickly, and then innovate from that starting point. And even if you’re not building a database, it’s a fascinating project to explain how...
2025-04-251h 32Developer VoicesJupyter'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 architecture, what else could it be used for?Joining me to look inside the Jupyter toolbox are Afshin Darian and Sylvain Corlay, two of Jupyters long-standing contributors and project-steerers. They’ve going to take us on a journey that starts with today’s userbase, goes through the execution protocol and ends with a look at what Jupyter will be in the future - an ambitious framework for in...
2025-04-101h 29Developer VoicesNix, 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 available - Nix. Nix tries to do everything from invoking your compiler to installing your language, and even providing your operating system. But how does it work in theory, and how well does it work in practice?Joining me to discuss is Julian Arni, a Nix-enthusiast and creator of a build/test/deploy service called Garnix.Nix has been one of my go...
2025-03-271h 20Developer VoicesGraphite: Image Editing as a Syntax Tree (with Keavon Chambers & Dennis Kobert)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 could use, extend or add to. The result is something that you can use like Photoshop or Inkscape, or make use of in batch pipelines, a bit like ImageMagick.Joining me to discuss it are Keavon Chambers & Dennis Kobert, who are hammering away on building a project that’s potentially as demanding as Photoshop, but with a more ambitious architecture. How can they hope to compete? Perh...
2025-03-131h 17Developer VoicesReScript: 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? What does it offer that makes it a tempting proposition? And how are the ReScript developers making life easier for anyone who wants to make the switch?To answer all these questions and more, I’m joined this week by Gabriel Nordeborn, one of ReScript’s compiler contributors. --ReScript: https://rescript-lang.org/ReScript & React: https://rescript-lang.org/docs/react/latest/intro...
2025-02-201h 32Developer VoicesA 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 theory because those are all just datasources. Predrag Gruevski is trying to make it easy by building a universal query engine, with pluggable datasources, all in Rust.This week we dive into Trustfall to figure out how it works. How do you model nearly anything as a datasource? How do you make it easy to extend? And what does it take to optimize a...
2025-02-071h 15Developer VoicesRaspberry 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 uses them to drive synthesizers to make music. In this episode we go through the full platform that he's building, from soldering resistors to an RPi chip, up through writing a Lisp interpreter, to the design ideas that make Lisp a good choice for composing both software and music.–uSeq Homepage: https://www.emutelabinstruments.co.uk/useq/Emute Lab’s Homepage: https://www.emutelab.org/
2025-01-231h 34Developer VoicesSoftware 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 system. You’re part of the system, your users are part of the system, and every other employee & department & priority eventually forms part of that system. And that can make it incredibly difficult to make changes, or even to understand which changes will actually matter.That might be overwhelming, but there's hope. Understanding how systems work and how to improve them is something th...
2025-01-161h 50Developer VoicesBuilding 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 rendering and animation features you’d expect from a game engine, with some features that might surprise you - like Rust scripting support with hot-reloading.As we dive into Fyrox, Dmitry explains what it takes to build a game engine, why he chose Rust (and why he’s happy with the choice), and how one person can hope to build a project of that...
2025-01-091h 43Developer VoicesTesting 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 mix of software and hardware, and even worse when you don’t have control of what the hardware can do.This week I’m joined by Dave Lucia of TVLab’s, who’s building systems for testing television software at scale, and it’s a problem that needs a huge variety of techniques to crack it. He’s using cameras, real time video processing, Erlang & Elixir an...
2024-12-191h 16Developer VoicesProgramming 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 and musical phrases, and build up a hole program that plays anything from a short bleep to a whole nightclub set. And Sam’s creator has been using it live for years, weaving drum & bass nights out of thin air, all driven by the Ruby-esque he writes.In this episode we go through Sam’s career path and design journey as we look...
2024-12-051h 50Developer VoicesElm & 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 success: it’s been popular with new and seasoned programmers alike; it’s helped push several language ideas into the mainstream; it’s been a key part of several successful software businesses and he even found himself employed as a kind of Language Designer in Residence. And yet, the material rewards of a successful open-source project were…lacking. Was he naive? Can an open-source developer stay true to open...
2024-11-2850 minDeveloper VoicesProgrammers, 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 an unusual topic for the channel, but the more I spoke to him, the more I wanted to know what coding is like when your brain is wired differently, how we can work more effectively with people with ADHD, and critically, how you manage coders with ADHD. And the answer to that comes full circle, in understanding how coders...
2024-11-211h 39Developer VoicesMicroServices 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 things up create fragmentation problems? And is it too late to put the genie back in the bottle? This week we’re going to look at all these questions and more as we reflect on the lessons learnt from this big architectural idea.This interview was recorded live at GOTO Copenhagen, with two microservice experts and thinkers: James Lewis of Thoughtworks and Ia...
2024-11-1447 minDeveloper VoicesPony: 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, but it’s well-trodden ground. The hard part is balancing performance and memory management. When your actors start passing hundreds of thousands of complex messages around, either you need some complex rules about who owns and frees which piece of memory, or you just copy every piece of data and kill your performance. Pony’s solution is a third way - a nove...
2024-10-311h 13Developer VoicesArchitecting 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 Component System, or ECS. An ECS is an approach to managing complex systems with large numbers of moving parts, that takes some inspiration from the Relational Database world, and a little from Functional Programming to build something entirely unique and surprisingly high-performance.Joining us to explain all is Alice Cecile. She’s part of the Bevy fo...
2024-10-231h 18Developer VoicesWriting 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 for: Computer Aided Design (CAD). Could Rust be sneaking its way into the CAD world too?Joining me to discuss the design and implementation of a CAD programming language is Adam Chalmers. He works at Zoo, developing KCL - a language that looks like JavaScript, runs on Rust, and offers users a seamless hybrid experience of both coding and point...
2024-10-161h 22Developer VoicesText 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 happy on the command line, rich Text User Interfaces (or TUIs) open all the exploration and discoverability benefits of a GUI are a fraction of the development time.This week we’re looking at a Rust TUI library with the excellent name ‘ratatui’. We’re joined by Orhun Parmaksız, one of the lead developers and a huge TUI...
2024-10-091h 06Developer VoicesDesigning 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 provide a library that blurs the lines between executing on the client, or on the server.Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join–Lustre: https://hexdocs.pm/lustre/index.htmlGleam: https://gleam.run/Join the Gleam Community: https://gleam.run/community/Processing (AV Framework for Java...
2024-10-021h 04Developer VoicesFaust: 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 program - audio processing. Anything from creating a simple echo sound effect, to building an entire digital instrument based on a 17th-century harpsichord.The language in question is Faust, and this week we’re joined by Romain Michon, who works on and teaches Faust, as we look at how it’s designed, what kind of programmers it's for, and how it doe...
2024-09-251h 18Developer VoicesGPUs, 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 to run on that oh-so-curious piece of specialised processing hardware, and we go through all the places that journey has taken her. From simulating the flow of fluids in hydroelectric powerstations, to figuring out how to make a new approach to encryption run fast enough to make it practical…–Become a Developer Voices supporter! https://patreon.com/D...
2024-09-181h 03Developer VoicesThe 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 browser. In fact, the ecosystem has gone further, and there are now a bevvy of options for people who want to write OCaml and run it in the browser, or want to write OCaml in the browser, or want to write something that looks like JavaScript but runs OCaml on the backend.Joining me to explore the OCaml-meets-JavaScript world is Antonio Montiero. He’s a ke...
2024-09-111h 27Developer VoicesMultiplatform 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, routing information, GPS data, points of interest, search and more. And as if that wasn’t enough, you’d probably want that software to work on a whole range of platforms, so you have to build something that works on iOS, Android and more. It’s little wonder that the space is dominated by a few closed-source projects owned by huge com...
2024-08-211h 01Developer VoicesBuilding 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 “completed” project? Or are there new ways to look at it that might make it even more useful?This week’s guest—Zach Lloyd—is convinced the terminal is ripe for a new approach that’s more than just a new coat of paint. And in this episode we dive into what that approach is, what he’s trying to do with the War...
2024-08-141h 07Developer VoicesBuilding 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. But this week’s guest aims to flip that relationship on its head... Peter Saxton joins me to talk about EYG - an AST-first language that defines the fundamental capabilities first, and then stretches out from there to surface syntax and final execution. The result is something that can teach us a lot about how a typed, functional programming language works; how an exten...
2024-08-071h 01Developer VoicesPractical 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 you just want to move quickly; and it can interface with most languages, run like lightning on the desktop or be embedded into a webpage. I’m a huge fan.But I’m not nearly as knowledgeable as this week’s two fans, Simon Aubury and Ned Letcher, who’ve just written a book on all the many ways you can use DuckDB and...
2024-07-311h 08Developer VoicesRecording 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 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 exactly the kind of project where might want to use it, but you want...
2024-07-241h 02Developer VoicesZig 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 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, –...
2024-07-171h 19
Developer VoicesCreating 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 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, and what does its future hold?–Support De...
2024-07-101h 42Developer VoicesPyO3: 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 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 hood, and quite how much...
2024-07-031h 34Developer VoicesNATS & Jetstream: The System Communication Toolkit (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 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 promise is a tool that can happily behave like a queue for one channel, a log like another a...
2024-06-261h 11Developer VoicesCuis 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-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 we cover Smalltalk’s history, its design ideas, Cuis’s unique implementation and what makes this modern imp...
2024-06-191h 18Developer VoicesThe Inko Programming Language, and Life as a Language Designer (with Yorick Peterse)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 removing them and leaning heavily into ADTs and pattern matching.Mixed in w...
2024-06-121h 24Developer VoicesBuilding 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 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 completely from scratch in Rust. It has a...
2024-06-051h 23Developer VoicesReimplementing Apache Kafka with Golang and S3This 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 benefits of moving all your storage to S3? And would he choose Go a second time around?...
2024-05-291h 23Developer VoicesExtending 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 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 a tour of Postgres’ extension mechanism, from creating custom functions and indexes to Rust cod...
2024-05-221h 07Developer VoicesDesigning Actor-Based Software (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 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 actors to the designs he’s worked on, the patterns h...
2024-05-151h 12Developer VoicesByteWax: 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 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.2522738Timely Dataflow: https://github.com/TimelyDataflow/timely-dataflowBytewax the Library: https://github.com/bytewax/bytewaxBytewa...
2024-05-081h 01Developer VoicesMojo 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.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 Python with the low-level programming of LLVM/MLIR?If you’re a Pyth...
2024-05-011h 24Developer VoicesBatch 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 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 two-pronged approach that recognises the divide between new and ol...
2024-04-2451 minDeveloper VoicesAdvanced 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 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 (or want different!) then Evan has some big ideas for you to sink your teeth into.
2024-04-171h 09Developer VoicesBringing 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 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 solution - ignore Java, treat Kafka as a protocol...
2024-04-031h 06Developer VoicesTaking 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 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 marry together...
2024-03-271h 03Developer VoicesHow 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 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 queries is Tim Berglund, veteran technology explainer of the realtime-data world. He...
2024-03-201h 14Developer VoicesNeovim: 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 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 for casual tinkerers and hardcore plugin writ...
2024-03-131h 07Developer VoicesCreating 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 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...
2024-03-061h 02Developer VoicesAutomate 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 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 finds some combination of clicks fails that a...
2024-02-281h 07Developer VoicesIf You Want Better Code, Do It For Me (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?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 OpenRewrit...
2024-02-141h 02Developer VoicesImplementing Hardware-Friendly Databases (with DuckDB 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 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, more parallelizable, and closer to the metal, and how it a...
2024-02-071h 20Developer VoicesVerse, Haskell & Core Language Design (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 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 from a small, tightly designed core. Then we move into Simon's current work exploring Functional Logic Programming, the big new...
2024-01-311h 23
Developer VoicesShouldn'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 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 talking to the cr...
2024-01-241h 15Developer VoicesWhat 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 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 we can learn that might make lives easier in the...
2024-01-171h 05Developer VoicesIs Odin, "programming done right"? (with 'Ginger' 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 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 progenitor. It’s not trying to be a r...
2024-01-101h 00Developer VoicesCan Event-Driven Architecture make Software Design Easier? (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 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 as a way of solving business problems faster and more reliably.
2024-01-031h 09Developer VoicesHow 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 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 old language design offer? How does he strike a balance between high-level language features...
2023-12-2752 minDeveloper VoicesRoc - 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 confusing control flow desperately easy. Types and tests are other examples - they’re as much about specifying what shouldn’t work as what should. And perspective is what makes this week’s topic particularly interesting: Roc is a language that’s functional, fast, friendly, and extremely interested in making your life easier by enabling some possibilities and restricting others.So this week we’re join...
2023-12-201h 01Developer VoicesIf 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 data processing feel trivial?In some places the answer is any library you like as long as it’s Python. In other realms, a mixture of Java and SQL shows promise. But as this week’s guest—Luca Pette—would say, the Unix design metaphor has plenty to give and keep on giving.So in this episode of Developer Voices we look...
2023-12-131h 19Developer VoicesWill 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, and how we can build that hindsight into a new language that will last for the next 100. In among all that long-term ambition we talk cover everything from error handling, typed unions and linear types, to metaprogramming and Drew's microkernel operating system. It's called Ares, and it is, of course, built in Hare.--Drew's Homepage: https://drewdevault.c...
2023-12-0654 minDeveloper VoicesStartups 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 seemed fun, inspired, and just crazy enough to work.We had him on the podcast a few months back just as that journey was beginning, and since he launched his first startup things have changed,. The reception has been better than he expected and the plan has been updated to go all-in on idea number one. But why? What's changed? What happened between brainstorming 4 ideas and...
2023-11-2951 minDeveloper VoicesIs 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 turn our attention to Apache Flink, a flexible system for grabbing, transforming and shipping data between systems using Java, Python or good ol’ SQL. So this week Robert Metzger—Apache Flink expert and PMC member—joins us to explain what problems Flink solves and how it solves them reliably. We cover the range from simple use cases to realtime aggregations & joins to its high availability strate...
2023-11-221h 04Developer VoicesWhat'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 competition with C and C++, but also other newcomers like Rust and Go. So what makes Zig special?Joining us to discuss it is Loris Cro from the Zig Foundation. We talk through Zig’s reasons to exist, its language design features, which parts of the C ecosystem it's tackling, and how the Zig Foundation is set up for the long-term health of the lang...
2023-11-151h 23Developer VoicesWhy 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, who’s part of Redpanda, a company that’s rewriting parts of the Apache Kafka ecosystem in C++, with the aim of getting performance gains that aren’t feasible in Java. It seems like a huge mountain to climb, and a fascinating journey to be on, so let’s ask why and how they’ve taken on this challenge…
2023-11-0849 minDeveloper VoicesDebezium - 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 range of uses: Some people use it to replicate from Oracle to MySQL, others to do smart cache invalidation, and others to build a bridge from an existing relational database to the event-sourcing world. If you’re working on a system that has more than one kind of database, it may be an essential tool. But what exactly does it do...
2023-11-011h 02Developer VoicesWhen 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 outside of the open-source world. The best software doesn’t win - the best software _that people can understand_ wins. So how do we get better at communicating our code? What do we talk about when we talk about software?Joining to discuss that question is a data-streaming expert and skilled communicator, Francesco Tisiot. Unusually, this episode is recorded on locat...
2023-10-2532 minDeveloper VoicesSemantic 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 internet from 2023, it’ll think it’s 2023 forever. So what do you do if you want to teach it some new information, but don’t want to burn a million AWS credits to get there?In exploring that answer, we dive deep into the world of semantic search, augmented LLMs, and exactly how vector databases bridge that gap from the old dog to the...
2023-10-181h 02Developer VoicesThe Future of Data is Now is the Future of Data (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 letting people book a taxi, recommending their next binge-watch, or delivering business reports to management, faster data is just obviously better. Or is it?Does real-time data matter everywhere, or does it just have sweet spots in some sectors and some use-cases? Is it a cost-benefit question - is the idea great in theory, but still too hard to adopt in practice? Would everyone be streaming th...
2023-10-111h 01Developer VoicesDatabases, 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 guest has decided to go all in, as he’s tackling the database problem from the fsync up. In this week’s Developer Voices we talk to Joran Dirk Greef, whose ambitions—combined with the lacklustre performance of his project's payment system—have led him to build a new database called TigerBeetle, that tackles some meaty problems. They’re attempting to build a...
2023-10-041h 06Developer VoicesStarting 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 in the next 4 quarters.He’d sound completely mad, except he’s got form: His last Kafka-based company got bought out by a tech giant, giving him enough of a safety net to try something new. And for his new approach, he’s doing the exact opposite of ‘stealth mode’. He’s publishing every step of his 4-by-4 challenge, wins and losses, for...
2023-09-2754 minDeveloper VoicesHow 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 about their stack, things aren’t so clear. They'll probably tell you the key components, and then add a laundry list of extra parts that got glued on later. The reality is, assembling large systems gets complicated. And with more and more options coming out every year, that potential complexity is only growing. These days, a good software developer must also be part researcher, and pa...
2023-09-201h 10Developer VoicesClickhouse: 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 analytics databases.This week we dive into the world of OLAP with a thorough look at Clickhouse, a high-performance, columnar database designed to "query billions of rows in microseconds."Alasdair Brown joins us to discuss what Clickhouse is, how it performs queries so quickly, and where it fits into a wider system. We talk about its origins as a Google Analytics-like, and how it's grown into...
2023-09-131h 15Developer VoicesWhat 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 ask the $64,000 question: What problems can Kafka actually solve for me? Because Kafka's definitely interesting, and it can be fun, but to earn a place in the toolbox it has to make life easier. In answering that question, Neil covers a tonne of ground, from queuing and quasi-databases, transitioning from batch to real-time, and solving general software integration headaches. If you...
2023-09-061h 02Developer VoicesDIY Consensus: Crafting Your Own Distributed Code (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 around the globe? Do we even need to understand how it works, or can we relegate those problems to an off the shelf tool like Zookeeper?Joining me this week is Distributed Systems Doctor—Benjamin Bengfort—for a deep dive into consensus algorithms. We start off by discussing how much of “the clustering problem” is your problem, and how much can be handled by...
2023-08-301h 07Developer VoicesTeaching, Guiding & Inspiring The Next Generation of Programmers (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 developer advocate, he's s been been working on tutorials, courses and bootcamps to teach aspiring developers how to get started with JavaScript. We talk about why people get into programming as a new career, what they need to succeed, and what James thinks is the best indicator of success.We also discuss what's new and exciting in JavaScript, James' favourite up & coming...
2023-08-2353 minDeveloper VoicesjOOQ - Crossing the Object-Relational Bridge (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 it seems, and every tool that bridges that gaps comes with its own strengths, weaknesses and opinions.This week we take a look at a relatively new library for database access—jOOQ—by chatting with its author, Lukas Eder. This episode takes in the simple questions like syntax, the thornier ones like supporting multiple databases, and the deeply philosophical ones like how we...
2023-08-0949 minDeveloper VoicesInside 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 join with dreams of hitting the podium, and plenty of others are just competing to be their better selves.Either way, Mathis Hammel is a veteran of the competitive coding scene and he’s going to give us a view into that world, tell a few war stories and share some tips how you can play better, faster and stronger…ICPC: https://icpc.g...
2023-07-2655 minDeveloper VoicesUnison: A Programming Language for Distributed Computing“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?Rúnar’s answer is Unison. A language that completely rethinks the way distributing computing can work, from the source code up. Borrowing some key ideas from git, it challenges the way we think about code-sharing, compilation, versioning and more. --Kris on Twitter: https://twitter.com/krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Rúnar on...
2023-07-191h 02Developer VoicesThe Evolution of Databases & 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 us as we embark on a journey through the history of databases, tracing the path from Edgar Codd to the multitude cloud-era of options available today. Discover the strengths of various database styles and explore the tradeoffs between general-purpose databases like #PostgreSQL and highly customised ones like #Cassandra or #Snowflake.We delve into the realm of the cloud...
2023-07-1249 minDeveloper VoicesThe Open Source AI Revolution Begins Now...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 of huge companies. Or is it?In this week's episode of Developer Voices, we're learning how you can run LLMs on your own laptop, and how you can customize the system to make a tailored research assistant, a better documentation-searcher, and much more. All you need is a guide on which pieces you need, and how they fit together, and that's exactly what this week's guest—To...
2023-07-0548 minDeveloper VoicesGren: The friendly, fullstack, functional future?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 appropriate for a language that started as a fork from its roots in Elm.With Gren, Robin's trying to create a safe, sane, #fullstack language that puts the power and elegance of functional programming working seamlessly on the server and the browser. But how and why do you do that? What design choices to do make, how much time do you spend...
2023-06-281h 02Developer VoicesPostgreSQL in the CloudWhat'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 versions of Postgres, what Neon have been doing to make Postgres work well in the Cloud, and what Raouf's life is like as a professional singer of Postgres's virtues.Neon: https://neon.tech/Neon’s architecture: https://neon.tech/docs/introduction/architecture-overviewThat CEO quote: https://twitter.com/nikitabase/status/1563913187862335489Raouf on Twitter: https://twitter.com/raoufdevrelKris on Tw...
2023-06-2133 minDeveloper VoicesBuilding a Thriving Community Around Your Software with Ale MurrayAre you trying to build the community around your software? And what does “building a community” really mean? What are we building communities for?Join us on Developer Voices as host Kris Jenkins sits down with Ale Murray, a seasoned community manager with nearly a decade of experience, to discuss her tips for building a thriving tech community. Ale shares her insights on why community building is essential, how to identify your target audience, and how to approach community building with the right mindset. She also offers practical advice on how to handle challenging situations, such...
2023-06-1355 minDeveloper VoicesBitemporal Databases: What They Are and Why They Matter, with James Henderson of XTDBAs 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 with James Henderson, lead developer of of a new bitemporal database called XTDB.You may have already created an ad-hoc bitemporal database without realizing it, but James and his team have been hard at work building a custom database that's tailor-made for situations where having two notions of time are essential. Join us to learn about the what and why of bitemporality and explore...
2023-06-0756 minDeveloper VoicesCan Kotlin take you everywhere?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 ambitious? Along the way we manage to discuss Scala, Function Programming vs. Object Orientation, Editors, Higher Kinded Types, Elm, React, UI architectures and multiplatform programming. A very full episode!Happy Path Programming - Haskell is not as scary as you think: https://pod.link/1531666706/episode/710a605d605fda251f2e83b8858615b8The Kotlin Programming Language: https://kotlinlang.org/Android Studio...
2023-05-241h 01Developer VoicesHow Do You Get AI Into Production?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 pipeline? And how do you monitor your models once they're in production? Today's episode goes through all these reality checks with author and expert Adi Polak, who's just released a new book on the subject.Scaling Machine Learning With Spark (book): https://www.oreilly.com/library/view/scaling-machine-learning/9781098106812/Kris on Twitter: https://twitter.com/krisajenkinsKris on LinkedIn: https://www.linkedin...
2023-05-1647 minDeveloper VoicesIs Gleam your next programming language?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-tolerant platform.If you're interested in building reliable distributed systems, exploring functional programming, learning new languages or finding out what it takes to design your own language, Louis is here to talk us through it all.The Gleam language: https://gleam.run/Gleam’s package repo: https://packages.gleam.run/Gleam on Twitter: https://twitter.com/gleamlangKris on Twitter: ht...
2023-05-1053 min