BEAM There, Done That

What if the BEAM had a language that felt like talking to a friend instead of fighting a compiler?That's the problem Louis Pilfold set out to solve. He loved the BEAM. He missed static types. Every other option was a tradeoff he couldn't live with. So he built Gleam - and after years of quietly saying no to everything he wasn't sure about, it's gathered a community, found production users, and now runs on servers, browsers, and $2 microcontrollers.Topics include:why every successful language is born from a problem - and what specific frustration made Louis start building rather than just complainingthe discipline of saying no: no if, no currying, no pretending two targets are one worldthe design decision Louis regrets most - the conditional compilation syntax he's now stuck with and desperately doesn't want more people to usewhy Gleam's concurrency model lives in a library rather than the language - and what that buys in terms of flexibility when smarter people eventually improve ithow Gleam solved the problem everyone said was unsolvable: "you can't type message passing on the BEAM"what the JavaScript and BEAM targets share and where they genuinely can't be unified - and why pretending they can leads to terrible architecturewhy Gleam chose Erlang records as its data structure and what that costs at runtimeLustre, Gleam's web framework - beating mainstream JavaScript frameworks in benchmarks while written entirely in Gleamhow Louis funds his work on Gleam: GitHub Sponsors, the Gleam community, and what sustainable open source actually looks like from the insidewhat Gleam will look like in 3–5 years - native records, better JavaScript interop, and why the language's approach to stability makes those changes possibleRecorded August 20, 2026.Resources mentioned:gleam.run - docs, tour, communitytour.gleam.run - interactive language tour running the Gleam compiler compiled to Wasm, takes an afternoonExercism Gleam trackCode Crafters - build Redis/SQLite/Git in GleamGitHub Sponsors: lpil (Louis Pilfold)Lustre - Gleam's web framework

Part one established that Erlang scales. Part two is about what comes after - keeping a codebase that large healthy for years, when most engineers arrive having never written Erlang before.WhatsApp's answer was to invest in the language itself. The formatter, the language server, the type checker. And then to open source almost all of it back to the community - not as charity, but because diverse use cases and external bug reports make the tools better.Roberto Aloi and Michał Muskała are back for the half that doesn't appear on conference posters.Topics include:why the investment in tooling came from a developer survey rather than an engineering instinct - the data showed Erlang developer experience was the weak pointwhat ELP (the Erlang Language Platform) actually is and how it superseded the Erlang LS that Roberto built before joining WhatsApphow eqWAlizer, WhatsApp's type checker, was rolled out without breaking other teams - the team owning the type checker also owned the task of fixing things up when new checks introduced errorswhy types and let it crash aren't in tension: you can never statically verify everything in a dynamic language, so the gap is where supervision and recovery fitthe two biggest misconceptions about static analysis tools: that they're slow (modern tooling is fast) and that you have to commit to them all at once (you can do it incrementally)why WhatsApp open sources tools that took significant engineering investment - keeping them internal would make them worse, not betterwhat's still unsolved: exhaustiveness checks at this scale remain an open problemhow AI is changing the Erlang learning experience - build first, ask AI to review your patterns afterwardthe word that ties both episodes together: trust. Supervision earns it at runtime. Types earn it at compile time.Companion episode: Part 1 on scale and operations.Recorded June 25, 2026.

Everyone quotes WhatsApp when the topic of Erlang and scale comes up. Fewer people know what it actually looks like from the inside - what was hard, what was never hard, and what the team spent their time on once the concurrency stopped being the problem.Roberto Aloi and Michał Muskała work on the team keeping it running. This is the first of two episodes with them.Topics include:what Roberto's first Erlang moment was - implementing a GenServer for a robot at university and learning binary pattern matching felt like cheatingwhy Michał came to Erlang backwards, from Elixir, and what the tooling gap actually felt likethe column numbers OTP bug that caused cascading failures and taught Roberto what no documentation couldthe optimization that made the JSON Unicode parser slower - binary pattern matching was the wrong tool, and a custom state machine was fasterwhat "let it crash" actually means at WhatsApp scale: letting it crash is the easy part, recovery is where the engineering liveswhy the 30th employee was the first person at WhatsApp with Erlang experience - and what that means for hiringthe most misunderstood thing about Erlang at WhatsApp: scaling isn't the exotic part, keeping the codebase healthy ishow WhatsApp does deployments: 1% of servers first, one region next, monitoring throughout, ready to roll backwhat types of failures become normal at this scale - and why disaster recovery drills are a regular practiceoverly dynamic code as the anti-pattern that creates the most sustained painPart two covers ELP, Equalizer, and the tooling that keeps a codebase this large navigable. You want both.Recorded June 25, 2026.

In 1952, Marvin Minsky and Claude Shannon built a box with a single switch. When you flip it, the only thing it does is reach out and switch itself back off. Seventy years later, 5,000 of those boxes are sitting on desks worldwide — and the thing making them tick is Erlang, running on a chip smaller than a fingernail.Davide Bettio built AtomVM, the virtual machine that makes this possible. Paul Guyot wrote the Erlang firmware, added SMP support as a weekend project, and shipped 5,000 units.Topics include:what AtomVM is — a from-scratch BEAM-compatible VM for microcontrollers with a few hundred kilobytes of RAM and no OSdebugging a virtual machine with no stack traces: printf everywhere, blindfoldedthe first production batch with a 5–10% return rate that turned out to be a mechanical problem — after Paul rewrote half the software looking for a bug that wasn't therewhy the actor model, let it crash, and binary pattern matching are unusually well-suited to embedded deviceswhat AtomVM actually supports: GenServer, maps, JSON, Erlang distribution, and via the Popcorn project — Phoenix LiveView on a microcontrollerPaul's SMP implementation as a "mixed blessing" — added for purely selfish engineering reasons, then forced the whole team to rewrite their driverswhere AtomVM differs from the BEAM: no dirty schedulers, no hot code unloading, a simpler scheduler model that mostly doesn't surface at the API levelRecorded June 24, 2026.Resources mentioned:atomvm.netGitHub: atomvm/AtomVMPopcorn project — Phoenix LiveView on AtomVMDiscord: AtomVM community

Bandit quietly became the default web server in Phoenix. Mat Trudel wrote it by hand, in pure Elixir, as a side project - and kept it that way even as AI changed how everyone else writes code.This episode goes two places at once: the engineering of a foundational piece of infrastructure most developers never think about, and an honest conversation about what it means to keep building something by hand when you don't have to.Topics include:how a six-month debugging session - Wireshark, a 30-page RFC, and a single misread line in the HPACK spec - explains why HTTP is genuinely hard to get rightwhat "one process per connection" actually buys you at 3am when something's on fire: a stack trace that's entirely Elixir frames, all the way upwhy HTTP parsers have a million attack vectors that have nothing to do with which language you write them inthe WebSock and WebSock Adapter split - and why a web server depending on another web server is ridiculoushow José Valim looked at Mat's first WebSocket implementation and told him he was doing too muchan AI-generated PR sitting open on the Bandit repo that implements the entire HTTP/3 stack - and why Mat hasn't merged itwhy Mat still writes Bandit entirely by hand while using agents for everything in his day jobthe cabinet maker's son analogy that explains the whole thing: if you want cabinets, go to IKEA; if you want to build them, the journey is the pointwhat it means when "finding bugs got cheap but judging and fixing them didn't"Companion episode: Peter Ulrich and Jonathan Machin on CVEs and security - the same story from the reporting side.Recorded June 22, 2026.Bandit quietly became the default web server in Phoenix. Mat Trudel wrote it by hand, in pure Elixir, as a side project - and kept it that way even as AI changed how everyone else writes code.This episode goes two places at once: the engineering of a foundational piece of infrastructure most developers never think about, and an honest conversation about what it means to keep building something by hand when you don't have to.Topics include:how a six-month debugging session - Wireshark, a 30-page RFC, and a single misread line in the HPACK spec - explains why HTTP is genuinely hard to get rightwhat "one process per connection" actually buys you at 3am when something's on fire: a stack trace that's entirely Elixir frames, all the way upwhy HTTP parsers have a million attack vectors that have nothing to do with which language you write them inthe WebSock and WebSock Adapter split - and why a web server depending on another web server is ridiculoushow José Valim looked at Mat's first WebSocket implementation and told him he was doing too muchan AI-generated PR sitting open on the Bandit repo that implements the entire HTTP/3 stack - and why Mat hasn't merged itwhy Mat still writes Bandit entirely by hand while using agents for everything in his day jobthe cabinet maker's son analogy that explains the whole thing: if you want cabinets, go to IKEA; if you want to build them, the journey is the pointwhat it means when "finding bugs got cheap but judging and fixing them didn't"Companion episode: Peter Ulrich and Jonathan Machin on CVEs and security - the same story from the reporting side.Recorded June 22, 2026.