TL;DR
This is a report on what I learned during the second day of the Code BEAM 2025 conference. After the conference, I attended the Elixir Berlin meetup, which was a great opportunity to meet Elixir developers from the Berlin area.
Opening Keynote — CyanView by Daniil Popov and David Bourgeois
I first read about the CyanView tool on the official Elixir Language blog, where it was featured as an example of successful adoption of Elixir in production. The project is very impressive to me because it combines an Elixir application with custom hardware and professional cameras.
The main problem they solve is ensuring that the color of the grass looks the same across video feeds from all cameras broadcasting an event. Since they needed highly reliable broadcasting and were already familiar with Elixir, choosing Elixir and the BEAM VM was a natural fit.
The system supports a number of protocols, the application is structured as an umbrella project, and “let it crash” helped them resolve bugs detected in production. For communication with a Linux daemon application, they chose to use Erlang ports. And among all the custom hardware, there is even a joystick!
There was also a funny anecdote in the talk. Right before the presentation, they discovered a bug causing a broken stream. But they knew exactly how long the stream could survive before the inevitable crash. So just before the crash happened, they quickly switched from the live feed demo to the slides—buying enough time for the stream to restart. Supervisors to the rescue.
During the presentation, I also learned about the Unix tree command, which prints a visual folder tree view.
Beyond GenServers: Declarative AI Flows with gen_statem — Coby Benveniste
This talk explained how to implement an agentic workflow state machine using the proven gen_statem behaviour. All features were covered: internal events, postponed events, and timers. The core pattern is reason → act → observe.
One issue that can arise when using gen_statem is that cancelling a timer does not always fully cancel it.
For agentic workflow orchestration, I would personally recommend using Oban Workflows (https://oban.pro/articles/unlocking-agentic-workflows-with-oban-pro), which is a proven solution—but it does require Oban Pro.
Rust Sandwich
In this talk, Julian Köpke demonstrated how to run Rust functions in the browser via WASM, and on the backend via NIFs, with Phoenix LiveView acting as the glue. It was a very cool demo.
I also learned that WASM is formally verified and sandboxed.
Beyond your first NIF by Riccardo Binetti
Here we got all tips and ticks how to implement your first NIF used in beam. Presentation was late because Riccardo’s Mac refused to talk with the project. Solution was to press one of the buttons from the machine on the picture.
Coffee Break
During the coffee break, I approached Thomas, who asked during the Supervisors to the Rescue talk why the init callback becomes a bottleneck when many significant children are started dynamically.
Teaching the BEAM to See — Alvise Susmel
The core of this talk was a demo of live object tracking and classification using a camera. The hardware used was a Raspberry Pi 5. The demo also showed a limitation: it was unable to detect two objects simultaneously.
Structured Generation and Logits Processing with Elixir — Chris Beck
Chris asked ChatGPT to write a poem about functional programming that does not contain the letter e. As expected, ChatGPT failed, and he explained precisely why.
You can read more about the talk here: https://bitcrowd.dev/logits-processing-and-constrained-sampling-in-bumblebee
I understood most of the talk because I am currently reading the excellent blog series Writing LLMs From Scratch:
https://www.gilesthomas.com/2024/12/llm-from-scratch-1
Optimizing the BEAM Scheduler for Many-Core Machines — Robin Morisset
I learned a lot from this talk. The problem discussed was low BEAM performance on servers with 100+ CPU cores. Why? When the scheduler has access to so many cores, some cores end up idle. Then the fun begins: idle schedulers start “stealing” work from schedulers that do have work, causing unexpected behaviour.
The talk provided a step-by-step guide to identifying what is really happening inside the BEAM scheduler.
Yes, I really must read The BEAM Book (https://blog.stenmans.org/theBeamBook/).
Microservice the OTP Way — Diede Claessens
We learned the pros and cons of introducing microservices, based on real-world experience transforming a modular monolith into a microservices architecture.
Pros: scalability, independence, simplicity.
Cons: local development and testing become a nightmare.
Setting boundaries early is crucial. Then you extract functionality from your monolith module by module into microservices.
Keynote: Empathy in Engineering — Sundi Myint
I am a regular listener of the Elixir Wizards podcast, where Sundi is one of the hosts. I learned about server-driven UI, an architecture where UI changes do not require redeploying the mobile app or waiting for App Store review.
Elixir Berlin Meetup at Bitcrowd
After the social closing of Code BEAM, I went to the meetup hosted at Bitcrowd that also provided drinks and pizzas. Dominic Letz drove Ramiro and me there, so we got to experience Berlin rush hour first-hand.
At the meetup, Ramiro and I repeated our Code BEAM talks. Ramiro’s talk focused on evaluating LLM-powered applications, based on his work on his pet project. There was also a lot of opportunity to mingle with other attendees.
The third talk, High-Level Abstractions, was given by Peter. He is a Gleam adopter, and Gleam is a type-safe language. He showed examples of systems that are not type-safe: operating systems and Bash, for example. Then he connected this with the BEAM, where supervision trees effectively replace try/catch patterns and even Kubernetes concepts.
Gleam is a tool for organising thoughts. Browsers are universal distribution platforms. Glistix is a fork of the Gleam compiler that compiles Gleam into Nix. These were some of the intriguing ideas Peter shared with us.
Elixir Unconference
On Friday we gathered again at Bitcrowd for the unconference event. Food was provided by the Erlang Ecosystem Foundation. We first proposed topics in a shared Google spreadsheet, then voted on them, and started discussing beginning with the topics that received the most votes. We had only one track.
The first topic was how to improve the Code BEAM experience. Many suggestions were inspired by the recent Goatmire conference organized by Lars Wikman, as many of us had attended this excellent event.
The second topic was how to improve Elixir adoption. The conclusion was that we need to solve hard problems with the BEAM to attract more developers and companies.
In the third topic, Josh from Ash presented a new Ash feature: Clarity. Ash will automatically generate a number of diagrams—from schema dependency graphs to flow diagrams.
Then we learned about the erlang-red project: a visual programming tool for Erlang processes, influenced by Node-RED. A very interesting project.
The last topic was a demo of LLMs and voice. Using ElevenLabs, we saw a demonstration of text-to-speech prompting. I also learned about the Excalidraw tool for creating presentations.
