BEAM There, Done That

Plangora

BEAM There, Done That is a podcast about building real systems with Elixir, Erlang, and the BEAM. We’ve built it before — distributed systems, fault‑tolerant services, event pipelines, real‑time apps, production nightmares, and the supervision trees that saved them. Each episode dives into practical lessons from shipping software on the BEAM: architecture decisions, scaling challenges, operational failures, and the patterns that actually work. No hype. No theory without scars. Just hard‑won experience from engineers who’ve been there.

  1. AI Found 5 CVEs in One Afternoon — The BEAM Security Wake-Up Call | Peter Ullrich & Jonathan Machen

    3d ago

    AI Found 5 CVEs in One Afternoon — The BEAM Security Wake-Up Call | Peter Ullrich & Jonathan Machen

    The BEAM ecosystem spent decades flying under the radar - too niche to attract serious attackers. That era is over. In this episode, we sit down with Peter Ullrich, the developer who ran a $10 experiment at ElixirConf EU in Málaga and discovered a vulnerability that could crash the BEAM with a 13-character string - with zero prior security experience. Then we hear from Jonathan Machen, CISO of the Erlang Ecosystem Foundation, whose job is to catch and coordinate everything Peter finds. We cover: How Peter built a simple bash script that scanned the most-downloaded Hex packages - and what he found Why LLMs have changed the cost and skill floor for vulnerability research forever The CVE disclosure process: what happens from the moment a bug is found to the moment it's published How the EEF's CNA went from 9 CVEs in a year to more in a single week What library maintainers should do right now (spoiler: it's three clicks on GitHub) The AGES initiative, supply chain security, and the gap between what's been built and what the moment demands Why paying a vendor like Trivy isn't enough - and what actually needs to happen If you run Phoenix in production, this episode is required listening. Resources mentioned: Peter's blog post and prompts: github.com/pultrich (linked in post) Linux Foundation's Scrutineer project Report vulnerabilities: cna@erlef.org Support the Erlang Ecosystem Foundation: erlef.org

    1h 2m
  2. Inside the BEAM: Björn Gustavsson on Maps, Records, and Runtime Design

    May 22

    Inside the BEAM: Björn Gustavsson on Maps, Records, and Runtime Design

    For the first time in over a decade, the Erlang runtime is gaining a new native data type — and on this episode of BEAM There, Done That, hosts Francesco Cesarini and Allan Wyma sit down with Björn Gustavsson, known by many as the “B” in BEAM. Björn takes listeners deep into the history of records, maps, tag bits, and the architectural trade-offs that shaped the Erlang runtime from the 1990s to today. The discussion explores why records were originally implemented as a hack, why maps never fully replaced them, and what finally made native records possible after nearly 30 years. Along the way, the episode becomes a rare tour through BEAM internals, compiler design, runtime tagging, and the practical realities of evolving a production VM used at massive scale. If you care about language design, runtime systems, or the history and future of Erlang/OTP, this is one of the deepest technical conversations the podcast has released.

    55 min
  3. Inside Phoenix: A Plug, a Macro, and What You Need to Know To Build Your Own Framework

    May 15

    Inside Phoenix: A Plug, a Macro, and What You Need to Know To Build Your Own Framework

    Three and a half years, one book, and a clearer answer to what Phoenix is actually doing under the hood. Phoenix makes building web apps in Elixir feel effortless, but how much of that is genuine elegance and how much is metaprogramming hiding the complexity? Adi Iyengar spent three and a half years writing Build Your Own Web Framework in Elixir to find out, and in this episode he sits down with Francesco and Allen to share what he learned by rebuilding Phoenix from the ground up. We dig into Plug as the real heart of the framework, when metaprogramming is the right tool and when it quietly becomes a liability, and why understanding the layers underneath Phoenix is what separates a productive developer from a senior one. Along the way Francesco brings out the BEAM web-server history most listeners have never heard — Yaws, Bluetail, Mochiweb, Inets — and the conversation lands on what coding agents get wrong about Phoenix in 2026.

    1h 2m
  4. Zero-Cost Meets Let-It-Crash: The Rust + Elixir Power Combo

    May 8

    Zero-Cost Meets Let-It-Crash: The Rust + Elixir Power Combo

    In this episode of BEAM There, Done That, hosts explore what really happens when the high-level concurrency and fault-tolerance of Elixir meet the low-level performance and control of Rust. The conversation dives into interoperability patterns—NIFs, ports, and emerging tooling—and where each language shines when building real-world systems that need both resilience and raw speed. Joining the discussion are Florian Gilcher, Co-founder and Managing Director of Ferrous Systems and a key figure in Rust’s community, adoption, and safety-critical systems work, and Leandro Pereira, an Elixir developer behind high-performance, developer-focused tools like MDEx, Lumis, and BeaconCMS. Together, they unpack when to stay on the BEAM, when to reach for Rust, and how combining the two can unlock a powerful hybrid architecture without compromising safety or developer productivity.

    59 min
  5. Phoenix’s Next Evolution: Chris McCord Unveils the DurableServer

    May 1

    Phoenix’s Next Evolution: Chris McCord Unveils the DurableServer

    In this episode of BEAM There, Done That, hosts Francesco Cesarini and Allen Wyma sit down with Chris McCord, the creator of the Phoenix Framework, for a deep dive into the evolving world of Elixir, distributed systems, and durable processes on the BEAM. Fresh from ElixirConf EU, Chris shares the story behind his latest work on durable servers—a powerful abstraction that brings persistence, global process identity, and intelligent placement to familiar GenServer patterns. The conversation explores how these ideas emerged from real-world production challenges, including running geo-distributed applications across multiple regions with no single point of failure. Along the way, the trio unpack the current state of Phoenix and Phoenix LiveView, discuss why most new features are driven by production needs rather than theory, and debate hot topics like WebSockets vs. server-sent events, event-driven architectures vs. long-lived processes, and the true scalability limits of the BEAM. This episode is packed with practical insights for Elixir and Erlang developers building real systems: from supervision tree pitfalls and process design trade-offs to tracing, load balancing, and self-healing systems at scale. If you’ve ever wondered how to design applications that can survive crashes, move across nodes, and run globally with minimal complexity, this is a must-listen. Topics covered: Elixir, Erlang, Phoenix, Phoenix LiveView, distributed systems, durable objects, GenServer patterns, supervision trees, multi-region BEAM clusters, fault tolerance, and real-world production architecture.

    1h 4m
  6. Bridging Hardware-as-a-service with Elixir: Inside TV Labs’ Platform With Dave Lucia and Paulo Valente

    Apr 24

    Bridging Hardware-as-a-service with Elixir: Inside TV Labs’ Platform With Dave Lucia and Paulo Valente

    In this episode of BEAM There, Done That, co-hosts Francesco Cesarini and Allen Wyma sit down with Dave Lucia, co-founder and CTO of TV Labs, and Paulo Valente, AI specialist and maintainer of Nx. The conversation explores a novel and compelling use case of Elixir, Luerl, and the BEAM. It’s a deep dive into how TV Labs operates a hardware-as-a-service platform, enabling clients to test and optimize applications for TVs, automotive systems, set-top boxes, and mobile devices—without needing to own or manage physical infrastructure. Dave explains how their platform blends physical hardware with cloud-based orchestration, giving teams remote, programmable access to real devices at scale. Paulo explores the role of AI and numerical computing in improving system performance, enhancing testing workflows, and enabling data-driven optimization. The episode also highlights why Elixir is central to their stack—alongside their use of Luerl for flexible scripting. Together, they unpack the architectural decisions, trade-offs, and real-world lessons behind building a modern, scalable hardware platform powered by the BEAM.

    40 min
  7. The Code is the Instrument: Sam Aaron on the Why of the Sonic Pi

    Apr 17

    The Code is the Instrument: Sam Aaron on the Why of the Sonic Pi

    The Code is the Instrument: Sam Aaron on the Why of the Sonic Pi

    54 min
  8. Redistributing Our Systems. Erlang's Enduring Lessons for Local-First

    Apr 10

    Redistributing Our Systems. Erlang's Enduring Lessons for Local-First

    Erlang was designed for reliability in telephone switches, but its core principles — isolated processes, message passing, “let it crash supervision — anticipated problems we’re only now grappling with at scale. Four decades later, these ideas are finding new expression in local-first software: apps that work offline, sync peer-to-peer, and put users back in control of their data.In this podcast, Robert Virding (Erlang co-creator) and Brooke Zelenka trace the intellectual lineage from telecom switches to CRDTs and capabilities. They’ll explore how Erlang’s fault-tolerance model maps onto modern challenges, distributed security, and systems that continue to work offline. The cloud promised to simplify distributed systems; instead concentrated in a handful of companies; perhaps the answers we need were hiding in a language designed for phone switches all along.

    52 min
See All (13)

Ratings & Reviews

4.3
out of 5
4 Ratings

About

BEAM There, Done That is a podcast about building real systems with Elixir, Erlang, and the BEAM. We’ve built it before — distributed systems, fault‑tolerant services, event pipelines, real‑time apps, production nightmares, and the supervision trees that saved them. Each episode dives into practical lessons from shipping software on the BEAM: architecture decisions, scaling challenges, operational failures, and the patterns that actually work. No hype. No theory without scars. Just hard‑won experience from engineers who’ve been there.

Information

  • Creator
    Plangora
  • Years Active
    2K
  • Episodes
    13
  • Rating
    Clean
  • Copyright
    © Plangora
  • Show Website
    BEAM There, Done That

You Might Also Like