Introduction
In 2015, I wanted to experiment with the Erlang VM after hearing about WhatsApp’s scalability successes. At the same time, I wanted to get more serious about functional programming.
Elixir was an approachable bridge: it runs on the Erlang VM, felt familiar after Ruby, and Phoenix offered a convention-driven web framework. After years of using Rails for prototypes, it made a useful comparison.
The Experiment
To exercise the stack, I built a small chat app. The premise was deliberately simple: chat interfaces had few lightweight ways to express an action or intent beyond ordinary text and emoji.
I added slash-command-style actions with aliases. For example:
Aliases made the interaction lighter. :) Fred performed the same action as
/smile Fred.
Takeaways
Using a functional language was a mindset shift, but it became natural quickly. The larger surprise was how approachable Phoenix felt while still sitting on the Erlang VM and its process-oriented runtime model.
I did not benchmark Phoenix or the Erlang VM, so this experiment is not evidence for scalability claims. What it did show me was that the programming model was practical enough to keep exploring for realtime and concurrent systems.
The experiment was later open sourced as
ryjen/emotext.
When I revisited the old project in 2026, upgrading its Elixir, Erlang, and Phoenix dependencies exposed substantial version drift and the UI no longer rendered correctly. That is better treated as a maintenance lesson than as a statement about the current Phoenix ecosystem.
What This Experiment Still Says
The durable lesson was not that one framework was “better.” It was that a runtime model can materially change how concurrency and failure are expressed. A small prototype was enough to make those differences concrete, while leaving performance and production-operability questions explicitly unanswered.