Episodes

  • Testing TVs At Scale With Elixir (with Dave Lucia)

    Testing TVs At Scale With Elixir (with Dave Lucia)

    · Developer Voices

    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 and a host of other tools to make it possible to test a fleet of televisions on demand.

    Sometimes good systems revolve around a single big idea; this time it’s a large combination of solutions, coordinated by the BEAM, that gets the job done.

    --

    TVLabs: https://tvlabs.ai/

    Flipper Zero: https://flipperzero.one

    ATSC 3.0 “NextGen TV”: https://en.wikipedia.org/wiki/ATSC_3.0

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

  • Programming As An Expressive Instrument (with Sam Aaron)

    Programming As An Expressive Instrument (with Sam Aaron)

    · Developer Voices

    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 at what it takes to make a programming language with enough expressivity and productivity to produce music at the speed of Sam’s imagination.

    --

    Sam’s Sonic Pi Course: https://www.patreon.com/posts/new-introductory-115404746

    Sonic Pi: https://sonic-pi.net/

    SuperCollider: https://supercollider.github.io/

    Overtone: https://github.com/overtone/overtone

    Power Gloves: https://en.wikipedia.org/wiki/Power_Glove

    Web Audio API: https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API

    Tau5: https://www.patreon.com/posts/announcing-sonic-112605951


    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join


    Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

  • Episodes manquant?

    Cliquez ici pour raffraichir la page manuellement.

  • Elm & The Future of Open Source (with Evan Czaplicki)

    Elm & The Future of Open Source (with Evan Czaplicki)

    · Developer Voices

    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-source principles and still make a decent living? Is open source being exploited by commercial software businesses? These topics and more tumble out of what has to be the first question in the podcast: What’s happening with Elm?

    --

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    ElmLang: https://elm-lang.org/

    The Economics Of Programming Languages: https://www.youtube.com/watch?v=XZ3w_jec1v8

    Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

  • Programmers, ADHD, And How To Manage Them Both (with Chris Ferdinandi)

    Programmers, ADHD, And How To Manage Them Both (with Chris Ferdinandi)

    · Developer Voices

    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 with ADHD manage themselves


    –

    ADHDFTW Homepage: https://adhdftw.com/developer-voices/

    Do I Have ADHD? https://adhdftw.com/do-i-have-adhd/

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Chris on Mastodon: https://mastodon.social/@cferdinandi

    Chris on BlueSky: https://bsky.app/profile/cferdinandi.bsky.social

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on BlueSky: https://bsky.app/profile/krisajenkins.bsky.social

  • MicroServices For Better And Worse (with Ian Cooper and James Lewis)

    MicroServices For Better And Worse (with Ian Cooper and James Lewis)

    · Developer Voices

    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 Ian Cooper of JustEat. 

    –

    Residuality Theory: https://leanpub.com/residuality

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Ian on Mastodon: https://mastodon.social/@[email protected]

    James on BlueSky: https://bsky.app/profile/boicy.bsky.social

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on BlueSky: https://bsky.app/profile/krisajenkins.bsky.social

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Pony: High-Performance, Memory-Safe Actors (with Sean Allen)

    Pony: High-Performance, Memory-Safe Actors (with Sean Allen)

    · Developer Voices

    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 novel approach to memory management called reference capabilities.

    In this week’s Developer Voices, Sean Allen joins us from the Pony team to explain what reference capabilities are, how Pony uses them in its high-performance actor framework, and how they implement a garbage collector without stop-the-world pauses. The result is a language for performant actors, and a set of ideas bigger than the language itself


    –

    Pony: https://www.ponylang.io/

    The Pony Tutorial: https://tutorial.ponylang.io/

    The Pony Playground: https://playground.ponylang.io/

    Azul Garbage Collector: https://www.azul.com/products/components/pgc/

    Shenandoah Garbage Collector: https://wiki.openjdk.org/display/shenandoah/Main

    A String of Ponies (Distributed Actors Paper): https://www.doc.ic.ac.uk/~scb12/publications/s.blessing.pdf

    Garbage Collection with Pony-ORCA: https://tutorial.ponylang.io/appendices/garbage-collection.html

    –

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Architecting a Rust Game Engine (with Alice Cecile)

    Architecting a Rust Game Engine (with Alice Cecile)

    · Developer Voices

    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 foundation, which is charting a course from data-management and rendering tool to fully-featured game development environment. A journey they’ve made huge progress on, but still expect to take another decade to come to full fruition. We look at the core ECS, and the wider project-management approaches they need to make the journey.

    –

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Bevy: https://bevyengine.org/

    Bevy Examples: https://bevyengine.org/examples/

    Flecs (C++): https://github.com/SanderMertens/flecs

    Tiny Glade (game): https://store.steampowered.com/app/2198150/Tiny_Glade/

    Alice on Mastodon: https://mastodon.gamedev.place/@alice_i_cecile

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Writing a CAD Language in Rust (with Adam Chalmers)

    Writing a CAD Language in Rust (with Adam Chalmers)

    · Developer Voices

    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-and-click modelling. So, how does that all fit together?

    In this episode we look at the design and implementation of a programming language in Rust; how KittyCAD creates that hybrid environment for text-based programming and point-and-click modelling; and how we can learn to write our own Rust-interpreted languages.

    –

    Adam’s Blog: https://adamchalmers.com/

    Adam’s Guide To Writing Parsers: https://www.youtube.com/watch?v=QF3kMyzMC40

    Zoo’s Modelling App: https://zoo.dev/modeling-app

    Mechanical CAD: https://zoo.dev/blog/mechanical-cad-yesterday-today-and-tomorrow

    A Lego brick in KCL: https://zoo.dev/docs/kcl-samples/lego

    Winnow: https://docs.rs/winnow/latest/winnow/

    Nom: https://docs.rs/nom/latest/nom/

    Factorio: https://www.factorio.com/

    Satisfactory: https://store.steampowered.com/app/526870/Satisfactory/

    Crafting Interpreters: https://craftinginterpreters.com/

    Coding in Antarctica: https://brr.fyi/

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Adam on Mastodon: https://mastodon.social/@[email protected]

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Text User Interfaces in Rust (with Orhun Parmaksız)

    Text User Interfaces in Rust (with Orhun Parmaksız)

    · Developer Voices

    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-realm

    Awesome Ratatui: https://github.com/ratatui/awesome-ratatui

    RTL SDR: https://www.rtl-sdr.com/about-rtl-sdr/

    Rust Snake AI: https://github.com/bones-ai/rust-snake-ai-ratatui

    SystemCtl-Tui: https://github.com/rgwood/systemctl-tui

    GitU: https://github.com/altsem/gitu

    
and GitUi: https://github.com/extrawurst/gitui

    GitCliff Changelog Tool: https://git-cliff.org/

    ATAC (Postman in the Terminal): https://github.com/Julien-cpsn/ATAC

    BubbleTea (TUIs in Golang): https://github.com/charmbracelet/bubbletea

    Imgcat (images in the terminal): https://github.com/danielgatis/imgcat

    TachyonFX: https://github.com/junkdog/tachyonfx

    ASCIITheatre: https://ascii.theater/

    Rio Terminal: https://raphamorim.io/rio/

    –

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Designing The Lustre Web Framework (with Hayleigh Thompson)

    Designing The Lustre Web Framework (with Hayleigh Thompson)

    · Developer Voices

    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/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join

    –

    Lustre: https://hexdocs.pm/lustre/index.html

    Gleam: 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/hayleighdotdev

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Faust: A Programming Language For Sound (with Romain Michon)

    Faust: A Programming Language For Sound (with Romain Michon)

    · Developer Voices

    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/info

    FPGAs: https://en.wikipedia.org/wiki/Field-programmable_gate_array

    VHDL: https://en.wikipedia.org/wiki/VHDL

    Verilog: https://en.wikipedia.org/wiki/Verilog

    Grame: https://www.grame.fr/

    The (Strawberry Jam) Gramophone: https://www.grame.fr/articles/gramophone

    Gramophone Workshops: https://www.grame.fr/evenements/atelier-gramophones-65ca16b19fec4

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • GPUs, from Simulation to Encryption (with AgnĂšs Leroy)

    GPUs, from Simulation to Encryption (with Agnès Leroy)

    · Developer Voices

    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/DeveloperVoices

    A Fully Homomorphic Encryption Scheme (pdf): https://crypto.stanford.edu/craig/craig-thesis.pdf

    CUDA platform: https://developer.nvidia.com/cuda-zone

    Rust-CUDA: https://github.com/Rust-GPU/Rust-CUDA

    And 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/@krisajenkins

    Kris 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)

    The State of Full-Stack OCaml (with António Monteiro)

    · Developer Voices

    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/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Sponsor Antonio’s Work: https://github.com/sponsors/anmonteiro/

    –

    The OCaml Platform: https://ocaml.org/platform

    OCaml on Discord: https://discuss.ocaml.org/t/ocaml-discord-server/1884

    ReasonML: https://reasonml.github.io/en/

    What is Melange? https://melange.re/v4.0.0/what-is-melange.html

    Melange 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_ocaml

    FUN OCaml Conference: https://fun-ocaml.com/

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris 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)

    Multiplatform Maps Built As Layers on Rust (with Ian Wagner)

    · Developer Voices

    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/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Ferrostar on Github: https://github.com/stadiamaps/ferrostar

    Ferrostar 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-rs

    UniFFI (user guide): https://mozilla.github.io/uniffi-rs/latest/

    Beeline (navigation device): https://beeline.co/

    Ian on Mastodon: https://fosstodon.org/@ianthetechie

    Ian on Twitter: https://x.com/ianthetechie

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Building a New Terminal App (with Zach Lloyd)

    Building a New Terminal App (with Zach Lloyd)

    · Developer Voices

    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/DeveloperVoices

    Become a Supporter on YouTube: https://www.youtube.com/@developervoices/join

    Warp Homepage: https://app.warp.dev/referral/VQGWW3

    VT100 Information: https://vt100.net/

    Game of Life in Rust: https://github.com/krisajenkins/game-of-life-rust

    Zed (Text editor in Rust): https://zed.dev/

    Flutter: https://flutter.dev/

    The Painter’s Algorithm: https://en.wikipedia.org/wiki/Painter%27s_algorithm

    Zach on LinkedIn: https://www.linkedin.com/in/zachlloyd/

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

    –

    0:00 Intro

    2:22 Why Create A New Terminal?

    7:28 Blurring the Lines Between Terminal and Shell

    16:04 How Do You Build A Terminal Program?

    24:55 Implementing a Terminal in Rust

    30:32 Rust Frameworks for GPU Shaders

    40:04 Will Any Of This Go Open Source?

    42:49 Managing a Mixture of Rust and Go

    47:52 What’s the DX of Warp?

    51:43 Integrating LLMs into the Terminal

    1:05:58 Outro

  • Building A Programming Language From Its Core (with Peter Saxton)

    Building A Programming Language From Its Core (with Peter Saxton)

    · Developer Voices

    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-lang

    TinyGo: https://tinygo.org/

    Become a Supporter on Patreon: https://patreon.com/DeveloperVoices

    Become a Supporter on YouTube: https://www.youtube.com/@developervoices/join

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Practical Applications for DuckDB (with Simon Aubury & Ned Letcher)

    Practical Applications for DuckDB (with Simon Aubury & Ned Letcher)

    · Developer Voices

    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/byKYt

    DuckDB episode with Hannes MĂŒhleisen: https://youtu.be/pZV9FvdKmLc

    DuckDB: https://duckdb.org/

    dplyr, the data-manipulation language: https://dplyr.tidyverse.org/

    duckplyr, DuckDB’s ‘native’ version: https://github.com/duckdblabs/duckplyr

    Substrait: https://substrait.io/

    Observable (Markdown+DuckDB=Reports): https://observablehq.com/framework/

    DuckDB’s “friendly” SQL: https://duckdb.org/docs/sql/dialect/friendly_sql.html

    Community Extensions: https://community-extensions.duckdb.org/

    DuckCon #5: https://duckdb.org/2024/08/15/duckcon5.html

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Simon on Twitter: https://x.com/SimonAubury

    Ned on Twitter: https://x.com/nletcher

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Recording and Replaying the Browser (with Justin Halsall)

    Recording and Replaying the Browser (with Justin Halsall)

    · Developer Voices

    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/rrweb

    RecordOnce: https://recordonce.com/

    Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Justin on Twitter: https://x.com/juice10

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

    –

    0:00 Intro

    3:10 What is rrweb Doing?

    6:12 Beginning With A Naive Implementation

    9:49 Supporting Canvas Tags

    13:05 Exotic HTML 5 Tags Like Midi

    14:31 The Internal Data Format

    17:39 How Reliable Can This Be In Practice?

    23:04 Cross-Browser Support

    24:32 Exploring The Use Cases

    30:17 Privacy Issues

    33:46 Analyzing User Interactions En-Masse

    36:40 Is The Spec Greater Than The Tool?

    38:20 The Practical Benefits Of Contributing To Open Source

    44:45 Updating Recordings After The Website Changes

    49:55 Playing Well (Or Badly) With Popular Frameworks

    53:21 The Runtime Burden

    54:17 What's Coming In The Future?

    1:01:02 Outro

  • Zig as a Multi-OS Build System (with Loris Cro)

    Zig as a Multi-OS Build System (with Loris Cro)

    · Developer Voices

    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/zig

    MingW 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/zine

    Loris’ website: https://kristoff.it/

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Creating and Evolving Elixir (with JosĂ© Valim)

    Creating and Evolving Elixir (with José Valim)

    · Developer Voices

    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/DeveloperVoices

    Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join

    Elixir Homepage: https://elixir-lang.org/

    Elixir Docs: https://elixir-lang.org/docs.html

    Numerical Elixir: https://github.com/elixir-nx

    Phoenix: https://phoenixframework.org/

    Livebook: https://livebook.dev/

    José’s Livebook & Elixir Presentation: https://www.youtube.com/watch?v=pas9WdWIBHs

    Comparing Elixir & Erlang Variables: https://dashbit.co/blog/comparing-elixir-and-erlang-variables

    Gleam on the BEAM: https://youtu.be/RntfkL8lUY4

    José on Github: https://github.com/josevalim

    Kris on Mastodon: http://mastodon.social/@krisajenkins

    Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

    Kris on Twitter: https://twitter.com/krisajenkins

  • Montre plus