🧠 Descubre por qué tantos desarrolladores se están enamorando de Elixir y Phoenix

Mix.install([
  {:kino, "~> 0.13"},
  {:phoenix, "~> 1.7"},
  {:phoenix_live_view, "~> 0.20"},
  {:plug_cowboy, "~> 2.7"}
])

🎯 Objetivo de esta charla

Entender por qué Elixir y Phoenix están entre las tecnologías más queridas según la diferentes medios importantes para desarrolladores de software, a través de ejemplos reales, filosofía funcional y la potencia de la BEAM.

“Elixir no solo te enseña a programar mejor, te enseña a pensar distinto.”

1️⃣ El amor en los datos

Según la encuesta de Stack Overflow 2025, Elixir y Phoenix aparecen entre los lenguajes y frameworks más admirados y amados.

📊 No solo son potentes: hacen felices a quienes los usan.

💡 Más de 50 libros publicados y miles de recursos en línea:

elixir-lang.org

phoenixframework.org

elixirschool.com

livebook.dev

hex.pm

🎥 Recurso sugerido:
👉 Qué hay que considerar al adoptar un lenguaje de programación o plataforma de desarrollo?

2️⃣ Elixir: el lenguaje que cuida a quien programa

Creado por José Valim (ex core team de Ruby on Rails).
Su meta: unir la claridad de Ruby con la robustez de Erlang.

Elixir es:

Funcional 🧩
Concurrente ⚙️
Escalable 🚀
Bello y legible 💬

📚 Referencia filosófica (SICP):

"A powerful programming language is more than just a means for instructing a computer to perform tasks."
Capítulo 1.1 — The Elements of Programming

🔹 Ejemplo 1: Pipeline elegante (legible y sin mutación)

"@Neodevelop"
|> String.trim()
|> String.downcase()
|> (&"Usuario: #{&1}").()
|> IO.puts()

🗺️ Pipeline (conceptual)

graph LR
A[Dato inicial] --> B[Función 1]
B --> C[Función 2]
C --> D[Función 3]
D --> E[Resultado final]

🎥 Complemento recomendado

📺 Principios de Programación Funcional — José Juan Reyes

🧩 SICP: tres mecanismos de todo lenguaje poderoso

Every powerful language has three mechanisms for accomplishing this:

Primitive expressions: entidades más simples del lenguaje.
Means of combination: construir elementos compuestos a partir de elementos simples.
Means of abstraction: nombrar y manipular elementos compuestos como unidades.

(SICP, 1.1 — The Elements of Programming)

🎬 Demostración práctica: Elegancia · Poder · Simplicidad en Elixir

“Elixir es la prueba de que menos código puede significar más resultados.”

En esta sección mostramos tres ejemplos breves donde se aprecia la belleza pragmática de Elixir: su claridad, su potencia real y su simpleza expresiva.

🎥 1️⃣ La Elegancia: claridad que inspira

Video: https://www.tiktok.com/@neodevelop/video/7455794872390372614

“Un lenguaje elegante es aquel que te permite pensar en el problema, no en la sintaxis.”

⚡ 2️⃣ El Poder: procesos que respiran

Video: https://www.tiktok.com/@neodevelop/video/7460978178987740422

“Elixir hace simple lo que otros lenguajes hacen difícil: la concurrencia.”

💬 Elixir no promete escalabilidad… la entrega.

✨ 3️⃣ La Simplicidad: resultados en pocas líneas

Video: https://www.tiktok.com/@neodevelop/video/7463209723588807942

“Menos código, más significado.”

💡 Simplicidad no es ausencia de poder; es dominio del diseño.

Ejemplo de un Servidor HTTP

defmodule SimpleServer do
  use Plug.Router
  plug :match
  plug :dispatch

  get "/" do
    send_resp(conn, 200, "¡Hola desde Elixir!")
  end
end

{:ok, _} = Plug.Cowboy.http(SimpleServer, [], port: 4001)

🧠 El lado humano: por qué cuesta adoptar Elixir

Elixir, como Lisp, enfrenta barreras culturales (no técnicas):

Curva de aprendizaje: paradigma funcional y concurrencia distribuida exigen pensar distinto.
Percepción de nicho: se asocia a sistemas de alta concurrencia/telecom/tiempo real.
Comunidad más pequeña: ecosistema joven frente a JS, Java o Python.
Fragmentación (estilos/stack): Phoenix, Nerves, LiveView, Nx, Surface, etc.

💬 “No es falta de mérito técnico, sino de narrativa cultural. Los lenguajes que te cambian la mente tardan en adoptarse.”

📘 Inspirado en “Land of Lisp” — Conrad Barski.

❤️ Por qué, a pesar de todo, Lisp (y Elixir) siguen siendo elegidos

“Las razones por las que la gente ama Lisp siguen vivas en Elixir.”

Razón	En Lisp	En Elixir
Expresividad y macros	Homoiconicidad y macros poderosas para DSLs.	Macros para DSLs y metaprogramación (`Ecto.Schema`, `Phoenix.Router`).
Desarrollo interactivo (REPL)	REPL permite iteración rápida.	`iex` con evaluación incremental e introspección.
Diseño perdurable	Introdujo GC, dynamic typing, etc.	Hereda resiliencia y concurrencia de la BEAM.
Productividad en problemas complejos	Equipos pequeños → sistemas grandes.	Startups reducen complejidad y costes.
Te hace mejor programador	Cambia tu forma de pensar.	Piensas en procesos y mensajería, no en hilos.

🎥 Recurso: Hablemos de Elixir — Manuel Rubio

3️⃣ BEAM: la máquina virtual que nunca duerme

“El corazón que late millones de veces por segundo.”

La BEAM VM (Erlang VM) da a Elixir:

Procesos ultraligeros ⚡
Aislamiento total 🔒
Supervisión automática 💪
Distribución nativa 🌎

🔹 Ejemplo 2: Un millón de procesos (concurrency demo)

1..1_000_000
|> Enum.map(fn _ -> spawn(fn -> :timer.sleep(1000) end) end)
|> length()

🌐 Ejemplo 3: Elixir distribuido (dos nodos)

# Terminal 1
# iex --sname nodo_a
# Terminal 2
# iex --sname nodo_b

# Desde nodo_b:
Node.connect(:'nodo_a@localhost')        # => true
Node.spawn(:'nodo_a@localhost', fn ->
  IO.puts("¡Hola desde nodo remoto!")
end)

🗺️ Diagrama de distribución (conceptual)

graph LR
A[Node A] <-- BEAM / Distribution --> B[Node B]
A <-- Messages --> B
A -->|spawn/monitor| B

🔧 Supervisión (auto-recuperación)

graph TD
S[Supervisor] --> W1[Worker 1]
S --> W2[Worker 2]
W1 --> F1[Falla]
F1 -->|reinicio| W1

“Si algo falla, no muere el sistema; renace.”

🌍 Casos de éxito (resúmenes)

🟢 WhatsApp — Erlang/BEAM

>2M conexiones simultáneas en una máquina (2012).
Mensajería global con un equipo pequeño.
Lección: BEAM escala conexiones con uso eficiente de CPU y memoria.
🔗 https://blog.whatsapp.com/1-million-is-so-2011

🟣 Discord — Elixir + Rust

Elixir coordina tiempo real y audio en 1000+ nodos.
Millones de usuarios concurrentes.
Lección: Elixir es excelente como plano de control distribuido.
🔗 https://elixir-lang.org/blog/2020/10/08/real-time-communication-at-scale-with-elixir-at-discord

🟠 Pinterest — Ahorro con Elixir

Migración parcial a Elixir ⇒ >2M USD menos al año y reducción de servidores (~150 → ~5).
Lección: Menos máquinas, menos complejidad, más fiabilidad.
🔗 https://paraxial.io/blog/elixir-savings

🔵 Phoenix — 2M WebSockets

Benchmark: 2 millones de conexiones WebSocket con Phoenix.
Lección: Phoenix + BEAM son ideales para real‑time masivo.
🔗 https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections

4️⃣ Phoenix: productividad sin sacrificar rendimiento

Phoenix es el framework web que corre sobre la BEAM: ligero, explícito y muy rápido.

🔹 Ejemplo 4: Controlador simple

defmodule HelloWeb.PageController do
  use HelloWeb, :controller
  def index(conn, _params), do: render(conn, :index)
end

🔹 Ejemplo 5: Chat en tiempo real (minimal)

defmodule ChatWeb.RoomChannel do
  use Phoenix.Channel

  def join("room:lobby", _msg, socket), do: {:ok, socket}

  def handle_in("new_msg", %{"body" => body}, socket) do
    broadcast!(socket, "new_msg", %{body: body})
    {:noreply, socket}
  end
end

5️⃣ LiveView: magia sin JavaScript

“Interactividad sin JavaScript.”

🔹 Ejemplo 6: Contador reactivo

defmodule CounterLive do
  use Phoenix.LiveView

  def render(assigns) do
    ~H"""
      <div>
        <div>{@count}</div>
        <button phx-click="inc">Increment</button>
      </div>
    """
  end

  def mount(_params, _session, socket), do: {:ok, assign(socket, :count, 0)}
  def handle_event("inc", _, socket), do: {:noreply, update(socket, :count, &(&1 + 1))}
end

🗺️ Diagrama LiveView (conceptual)

graph LR
C[Cliente] <---> S[Socket LiveView]
S --> E[Estado en BEAM]
E --> R[Render HTML]

🧩 Proyecto práctico con LiveView: Amazing Domino

“Aprendimos Elixir, Phoenix y LiveView construyendo un juego en tiempo real.”

🎮 Contexto

En MakingDevs, creamos el proyecto Amazing Domino como un ejercicio educativo para un grupo de desarrolladores. A través de este proyecto, los participantes aprendieron los fundamentos de:

Elixir → Procesos, concurrencia, mensajes.
Phoenix → Canales y comunicación en tiempo real.
LiveView → Interactividad reactiva sin JavaScript.

🧠 El objetivo fue mostrar que con Elixir se pueden construir sistemas vivos, no solo servicios REST.

⚙️ Lo que se construyó

Un juego de dominó multijugador en tiempo real.
Cada partida es gestionada por un proceso supervisado en la BEAM.
La interfaz se actualiza automáticamente vía LiveView.
Los jugadores pueden unirse, tirar fichas y ver el tablero sincronizado al instante.

🗺️ Diagrama de flujo del juego

graph TD
A[Jugador 1] -->|Evento: jugar ficha| B[Phoenix Channel]
B --> C[Broadcast a todos]
C --> D[LiveView Render en Jugador 1]
C --> E[LiveView Render en Jugador 2]

💬 Cada acción de un jugador actualiza todos los clientes conectados instantáneamente.

🔍 Lo que aprendieron los desarrolladores

Concepto	Cómo se aplicó en el proyecto
Concurrencia ligera	Cada partida es un proceso supervisado independiente.
Mensajería entre procesos	Phoenix Channels y PubSub manejan los eventos.
Estado vivo y reactivo	LiveView mantiene el tablero sincronizado sin JS.
Supervisión	Cada partida se reinicia si falla un proceso.
Escalabilidad	Múltiples juegos en paralelo sin interferencias.

🚀 Resultados y aprendizajes

Entendieron la filosofía viva de la BEAM: procesos aislados, resiliencia y comunicación eficiente.
Aprendieron que LiveView reemplaza frameworks frontend completos, pero con menos complejidad.
Vivieron el poder de ver sus cambios en tiempo real, sin recargar ni escribir JS.
Y sobre todo, descubrieron la alegría de crear software elegante, reactivo y robusto.

💜 “Con Amazing Domino, los participantes dejaron de leer sobre LiveView… y empezaron a sentirlo.”

🔗 Proyecto: https://gitlab.com/makingdevs/amazing_domino 🎮 Demo en vivo (si está disponible): https://domino.makingdevs.com

6️⃣ Ecosistema, comunidad y aprendizaje

Herramienta	Propósito
Ecto	ORM funcional
Oban	Jobs supervisados
Nx	Machine Learning
LiveBook	Cuadernos interactivos
Surface	UI components

📚 Libros recomendados

Programming Elixir – Dave Thomas
Elixir in Action – Saša Jurić
Programming Phoenix – Chris McCord, Bruce Tate
Designing Elixir Systems with OTP – James Edward Gray II
LiveView & Beyond – PragProg

💡 Recursos en línea

❤️ Conclusión

Confiabilidad: gracias a la BEAM
Productividad: gracias a Phoenix y LiveView
Distribución natural: sistemas que cooperan sin fricción
Casos reales: empresas globales lo usan a escala
Alegría: simplicidad funcional → código claro y mantenible

IO.puts("Elixir no solo te enseña a programar mejor, te enseña a pensar distinto.")

neodevelop/descubre_elixir_y_phoenix.livemd