Bet on Elixir

Bet on Elixir

☕️ 4 min read

I recently had the opportunity to present at the Mumbai Global Elixir Meetup in October 2025—the first-ever Elixir meetup in Mumbai. That’s why I chose the topic “Bet on Elixir” - to introduce the language and showcase why it deserves attention from the local developer community. Rather than just creating slides, I built something more interesting: a complete interactive experience using Phoenix LiveView to demonstrate Elixir’s capabilities.

Why Choose Elixir in 2025? Three Core Advantages

The talk addresses a simple question: why should developers consider Elixir in 2025? The answer lies in three pillars that make Elixir unique: concurrency, fault tolerance, and distributed systems - all built on 30+ years of battle-tested Erlang/OTP foundations.

Four Interactive Demos You Can Try Now

Here’s what makes this talk different: instead of static slides explaining processes and supervision trees, I built live, interactive demonstrations using Phoenix LiveView. The meta-irony isn’t lost on me - using Elixir to demonstrate why Elixir is powerful.

1. Process Spawning Visualization

Try it: https://bom-gem.rakshanshetty.in/demo/processes

Visualization showing thousands of Elixir processes being spawned in real-time

Watch Elixir spawn thousands of lightweight processes in real-time. Each process is only ~2KB and takes microseconds to create. This isn’t a simulation - these are real BEAM virtual machine processes running on the server, visualized through LiveView. The BEAM VM (Erlang’s runtime) is designed from the ground up for massive concurrency - unlike VMs built for single-threaded execution.

2. Message Passing Networks

Try it: https://bom-gem.rakshanshetty.in/demo/ping-pong

Animated visualization of Elixir processes exchanging messages in different network topologies

See the actor model (Elixir’s approach to concurrency where isolated processes communicate via messages) in action with animated messages traveling between processes. Switch between different network topologies (Chain, Ring, Hub & Spoke) and watch color-coded messages (Ping, Pong, Data, Task) flow through the system. No shared state, no race conditions - just pure message passing.

3. Mailbox & Queuing Mechanics

Try it: https://bom-gem.rakshanshetty.in/demo/ping-pong-mailbox

Animated demo showing process mailboxes queuing and processing messages at different rates

This demo makes the invisible visible: process mailboxes. Watch messages queue up, see independent processing rates, and understand how Elixir handles backpressure naturally. Each process has its own mailbox, processing messages at its own pace.

4. Fault Tolerance & Supervision Trees

Try it: https://bom-gem.rakshanshetty.in/demo/fault-tolerance

Supervision tree visualization showing workers being crashed and automatically restarted

This is my favorite. Crash workers with different exit reasons (runtime errors, timeouts, brutal kills) and watch the supervision tree automatically restart them based on their restart policies. Toggle between restart strategies (:one_for_one, :one_for_all, :rest_for_one) and see the “let it crash” philosophy in action. Real-time metrics show uptime, crashes, restarts, and overall system health.

Building Real-Time Apps with Phoenix LiveView (No JavaScript Required)

All four demos are built with Phoenix LiveView - a library that lets you build real-time, interactive web applications without writing JavaScript. Here’s a complete working example:

defmodule CounterLive do
  use Phoenix.LiveView
 
  def mount(_params, _session, socket) do
    {:ok, assign(socket, count: 0)}
  end
 
  def handle_event("increment", _params, socket) do
    {:noreply, assign(socket, count: socket.assigns.count + 1)}
  end
 
  def render(assigns) do
    ~H"""
    <div>
      <h1>Live Counter: <%= @count %></h1>
      <button phx-click="increment">+</button>
    </div>
    """
  end
end

That’s it. Real-time updates, WebSocket management, DOM diffing (tracking what changed on the page) - all handled for you.

Explore the Full Experience

The complete talk experience is available online:

Why Bet on Elixir?

  • Concurrency without complexity: Lightweight processes and the actor model eliminate entire classes of bugs
  • Fault tolerance that actually works: Supervision trees and the “let it crash” philosophy create self-healing systems
  • Distribution built-in: Clustering, process communication across nodes - it just works

If you’re building real-time applications, handling high concurrency, or need fault-tolerant systems, Elixir deserves your attention. And now you have an interactive playground to explore it.

Get Started with Elixir: Try These Interactive Demos

Try the demos. Crash some workers in the fault tolerance demo and watch them resurrect. Explore the slides with speaker notes. Clone the repo and run it locally. Join the growing Elixir community at your local meetup or online.

The best way to understand why developers are betting on Elixir is to experience it yourself.

Start here: https://bom-gem.rakshanshetty.in/demo/fault-tolerance

Presented at Mumbai Global Elixir Meetup (GEM), October 2025. Part of the worldwide GEM week with 46+ meetups across 6 continents. If you’re interested in setting up Elixir with Nix for your own projects, check out my guide on setting up Elixir with Nix.

Recent blogs