Discover the future of software from the people making it happen.Listen to some of the smartest developers we know talk about what they're working on, how they're trying to move the industry forward, and what you can learn from it. You might find the solution to your next architectural headache, pick up a new programming language, or just hear some good war stories from the frontline of technology.Join your host Kris Jenkins as we try to figure out what tomorrow's computing will look like the best way we know how - by listening directly to the developers' voices.
Similar Podcasts
The Cynical Developer
A UK based Technology and Software Developer Podcast that helps you to improve your development knowledge and career,
through explaining the latest and greatest in development technology and providing you with what you need to succeed as a developer.
New Rustacean
A show about the Rust programming language and the people who use it.
Algorithms + Data Structures = Programs
The Algorithms + Data Structures = Programs Podcast (aka ADSP: The Podcast) is an informal podcast inspired by Magic Read Along. We plan to talk about whatever we feel like - algorithms, data structures, programming languages, latest news in tech and more. Feel free to follow us on Twitter at @adspthepodcast.
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 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 enthusiast on a quest to see how far Text UIs can be pushed.–Ratatui: https://ratatui.rs/Ratatouille Tutorials: https://ratatui.rs/tutorials/Tui Realm: https://github.com/veeso/tui-realmAwesome Ratatui: https://github.com/ratatui/awesome-ratatuiRTL SDR: https://www.rtl-sdr.com/about-rtl-sdr/Rust Snake AI: https://github.com/bones-ai/rust-snake-ai-ratatuiSystemCtl-Tui: https://github.com/rgwood/systemctl-tuiGitU: https://github.com/altsem/gitu…and GitUi: https://github.com/extrawurst/gituiGitCliff Changelog Tool: https://git-cliff.org/ATAC (Postman in the Terminal): https://github.com/Julien-cpsn/ATACBubbleTea (TUIs in Golang): https://github.com/charmbracelet/bubbleteaImgcat (images in the terminal): https://github.com/danielgatis/imgcatTachyonFX: https://github.com/junkdog/tachyonfxASCIITheatre: https://ascii.theater/Rio Terminal: https://raphamorim.io/rio/–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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): https://processing.org/Vue.js: https://vuejs.org/Svelte: https://svelte.dev/Elm: https://elm-lang.org/Elm Table: https://package.elm-lang.org/packages/gribouille/elm-table/5.3.0/Hayleigh on Twitter: https://x.com/hayleighdotdevKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 does the job of turning audio-pipeline definitions into executable code.And one of the surprising parts of that compilation strategy is the decision to have it compile to multiple targets, from the expected ones like C and Rust, to the exotic destination of FPGAs (Field Programmable Gate Arrays). FPGAs are like reprogrammable circuit boards, and Romain dives into Faust’s attempts to go from a high-level description of an audio program, all the way down to instructions that tell a chip exactly how it should wire itself.So rather aptly for a technology podcast, we start this week with what your ear can hear and go all the way down to logic gates and circuit boards…–Try Faust in the Browser: https://faustide.grame.fr/Faust Online Course: https://www.kadenze.com/courses/real-time-audio-signal-processing-in-faust/infoFPGAs: https://en.wikipedia.org/wiki/Field-programmable_gate_arrayVHDL: https://en.wikipedia.org/wiki/VHDLVerilog: https://en.wikipedia.org/wiki/VerilogGrame: https://www.grame.fr/The (Strawberry Jam) Gramophone: https://www.grame.fr/articles/gramophoneGramophone Workshops: https://www.grame.fr/evenements/atelier-gramophones-65ca16b19fec4Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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/DeveloperVoicesA Fully Homomorphic Encryption Scheme (pdf): https://crypto.stanford.edu/craig/craig-thesis.pdfCUDA platform: https://developer.nvidia.com/cuda-zoneRust-CUDA: https://github.com/Rust-GPU/Rust-CUDAAnd in case anyone was wondering, A List of Hydroelectric Power Stations in France: https://en.wikipedia.org/wiki/Category:Hydroelectric_power_stations_in_France–Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 key maintainer/contributor for Melange and ReasonML, as well as several other interesting OCaml web projects.We kick off by discussing the benefits of OCaml and how it clicked with him personally, before we dive into how and why the compiler is being adapted and tweaked to take it to a whole new audience of web-hungry developers.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinSponsor Antonio’s Work: https://github.com/sponsors/anmonteiro/–The OCaml Platform: https://ocaml.org/platformOCaml on Discord: https://discuss.ocaml.org/t/ocaml-discord-server/1884ReasonML: https://reasonml.github.io/en/What is Melange? https://melange.re/v4.0.0/what-is-melange.htmlMelange for React Devs: https://react-book.melange.re/The Melange Playground: https://melange.re/v4.0.0/playground/js_of_ocaml: https://github.com/ocsigen/js_of_ocamlFUN OCaml Conference: https://fun-ocaml.com/Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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, 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 companies with near-limitless resources.But that doesn’t mean the problem can’t be cracked as an open-source project. This week we look at the open source map library Ferrostar. Joining me to discuss it is the project’s lead developer, Ian Wagner, as we explore the problem space and dive down into Ferrostar’s architecture: A core Rust library serving a suite of custom UI shells written in Kotlin, Swift, WASM and TypeScript.Along the way there are tips for anyone attempting to build a map, or wanting to interop Rust with other languages.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinFerrostar on Github: https://github.com/stadiamaps/ferrostarFerrostar user guide: https://stadiamaps.github.io/ferrostar/MapLibre: https://maplibre.org/Project OSRM: https://project-osrm.org/Dioxus (Rust UI framework): https://dioxuslabs.com/Slint: https://slint.dev/UniFFI (repo): https://github.com/mozilla/uniffi-rsUniFFI (user guide): https://mozilla.github.io/uniffi-rs/latest/Beeline (navigation device): https://beeline.co/Ian on Mastodon: https://fosstodon.org/@ianthetechieIan on Twitter: https://x.com/ianthetechieKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 “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 Warp Terminal, and how it’s put together using a combination of Rust and GPU shaders.Along the way we look at what LLMs could do to improve the terminal experience, where the boundary lies between terminal and shell, and where Go has solved some problems and created others over at Warp HQ.–Become a Supporter on Patreon: https://patreon.com/DeveloperVoicesBecome a Supporter on YouTube: https://www.youtube.com/@developervoices/joinWarp Homepage: https://app.warp.dev/referral/VQGWW3VT100 Information: https://vt100.net/Game of Life in Rust: https://github.com/krisajenkins/game-of-life-rustZed (Text editor in Rust): https://zed.dev/Flutter: https://flutter.dev/The Painter’s Algorithm: https://en.wikipedia.org/wiki/Painter%27s_algorithmZach on LinkedIn: https://www.linkedin.com/in/zachlloyd/Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins–0:00 Intro2:22 Why Create A New Terminal?7:28 Blurring the Lines Between Terminal and Shell16:04 How Do You Build A Terminal Program?24:55 Implementing a Terminal in Rust30:32 Rust Frameworks for GPU Shaders40:04 Will Any Of This Go Open Source?42:49 Managing a Mixture of Rust and Go47:52 What’s the DX of Warp?51:43 Integrating LLMs into the Terminal1:05:58 Outro
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. 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 extensible effects system works; and could make writing a new programming language as easy as defining the syntax you want, and parsing that into EYG's AST.--EYG Homepage: https://github.com/crowdhailer/eyg-langTonyGo: https://tinygo.org/Become a Supporter on Patreon: https://patreon.com/DeveloperVoicesBecome a Supporter on YouTube: https://www.youtube.com/@developervoices/joinKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 all the hidden tricks and tips that help you make the most of this. So in this episode we’re taking a practical look at DuckDB, what problems it can solve at work, and how to start getting the most out of it.–Getting Started with DuckDB (book): https://packt.link/byKYtDuckDB episode with Hannes Mühleisen: https://youtu.be/pZV9FvdKmLcDuckDB: https://duckdb.org/dplyr, the data-manipulation language: https://dplyr.tidyverse.org/duckplyr, DuckDB’s ‘native’ version: https://github.com/duckdblabs/duckplyrSubstrait: https://substrait.io/Observable (Markdown+DuckDB=Reports): https://observablehq.com/framework/DuckDB’s “friendly” SQL: https://duckdb.org/docs/sql/dialect/friendly_sql.htmlCommunity Extensions: https://community-extensions.duckdb.org/DuckCon #5: https://duckdb.org/2024/08/15/duckcon5.htmlSupport Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinSimon on Twitter: https://x.com/SimonAuburyNed on Twitter: https://x.com/nletcherKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 someone else to maintain it!Joining us this week is Justin Halsall—a chief contributor to rrweb—to teach us about some of the more barren corners of the browser spec, how he’s fought through them, and what the benefits are on the other side…–RRWeb homepage: https://www.rrweb.io/RRWeb on Github: https://github.com/rrweb-io/rrwebRecordOnce: https://recordonce.com/Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinJustin on Twitter: https://x.com/juice10Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins–0:00 Intro3:10 What is rrweb Doing?6:12 Beginning With A Naive Implementation9:49 Supporting Canvas Tags13:05 Exotic HTML 5 Tags Like Midi14:31 The Internal Data Format17:39 How Reliable Can This Be In Practice?23:04 Cross-Browser Support24:32 Exploring The Use Cases30:17 Privacy Issues33:46 Analyzing User Interactions En-Masse36:40 Is The Spec Greater Than The Tool?38:20 The Practical Benefits Of Contributing To Open Source44:45 Updating Recordings After The Website Changes49:55 Playing Well (Or Badly) With Popular Frameworks53:21 The Runtime Burden54:17 What's Coming In The Future?1:01:02 Outro
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 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, –Zig Homepage: https://ziglang.org/Zig on Github: https://github.com/ziglang/zigMingW for Windows: https://www.mingw-w64.org/All Your Codebase: https://allyourcodebase.com/Ziglang on PyPi: https://pypi.org/project/ziglang/Shout out to Whitequark: https://pypi.org/user/whitequark/Darling: https://www.darlinghq.org/WineHQ: https://www.winehq.org/PyPi Stats: https://pypistats.org/packages/__all__The Zine static site generator: https://zine-ssg.io/The Zine source code: https://github.com/kristoff-it/zineLoris’ website: https://kristoff.it/Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinElixir Homepage: https://elixir-lang.org/Elixir Docs: https://elixir-lang.org/docs.htmlNumerical Elixir: https://github.com/elixir-nxPhoenix: https://phoenixframework.org/Livebook: https://livebook.dev/José’s Livebook & Elixir Presentation: https://www.youtube.com/watch?v=pas9WdWIBHsComparing Elixir & Erlang Variables: https://dashbit.co/blog/comparing-elixir-and-erlang-variablesGleam on the BEAM: https://youtu.be/RntfkL8lUY4José on Github: https://github.com/josevalimKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
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 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 work it takes to make them work as one.–PyO3 User Guide: https://pyo3.rs/v0.22.0/PyO3 on Github: https://github.com/PyO3/pyo3Polars: https://pola.rs/Tokio: https://tokio.rs/Trio: https://trio.readthedocs.io/Robyn: https://github.com/sparckles/RobynFaster CPython: https://github.com/faster-cpythonMaturin: https://www.maturin.rs/–David on Mastodon: https://fosstodon.org/@davidhewittDavid on Twitter: https://x.com/davidhewittdevKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://x.com/krisajenkins
NATS & 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 and a request/response protocol for the third, all with a few client flags.But how does that work? What’s it doing under the hood, what features does it offer, and what do we lose in return for that flexibility? Jeremy has all the answers as we ask, what is NATS really?–NATS on Github: https://github.com/nats-io/nats-serverNATS Homepage: https://nats.io/Getting Started with NATS: https://youtu.be/hjXIUPZ7ArMDeveloper Voices Episode on Benthos: https://youtu.be/labzg-YfYKwCNCF: https://www.cncf.io/The Ballerina Language: https://ballerina.io/Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkinsSupport Developer Voices via Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices via YouTube: https://www.youtube.com/@developervoices/join
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-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 implementation something special.Smalltalk is over 50 years old, but its vision of how computing could work has only begun. Let’s see if we can mine some ideas from it to take us into the next generation of computing...--The Cuis Smalltalk Book: https://cuis-Smalltalk.github.io/TheCuisBook/Preface.htmlCuis on Github: https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-DevThe Cuis Community: https://cuis.st/communityA Short History of Cuis: https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev/blob/master/Documentation/CuisHistory.mdMonticello VCS: https://wiki.squeak.org/squeak/1287Juan’s Music Research: https://www.jvuletich.org/research.htmlBack to the Future - The Story of Squeak (pdf): https://dl.acm.org/doi/pdf/10.1145/263700.263754Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins