¿Por qué Erlang sigue vivo en 2025 ... ?

¿Por qué Erlang sigue vivo en 2025? Una pregunta que muy pocos hacen, es la verdad, admitámoslo. 

En un mundo donde cada año aparecen nuevos lenguajes, frameworks y paradigmas, sorprende que Erlang, creado en los años 80 por Ericsson, siga siendo una pieza clave en sistemas modernos de telecomunicaciones, mensajería, fintech e infraestructura crítica. En 2025, Erlang no solo sigue vivo… es insustituible.

---

1. Erlang nació para problemas que siguen vigentes

Erlang/OTP se diseñó para tolerancia a fallos, concurrencia masiva y actualizaciones en caliente. Hoy esos retos son más comunes: millones de conexiones simultáneas, sistemas distribuidos globales, microservicios que no pueden caerse, plataformas con latencia estable y operación 24/7 sin downtime.

---

2. Industrias donde Erlang domina en 2025

Telecomunicaciones

• Origen: conmutadores telefónicos que no pueden fallar.
• Usos actuales: VoIP, gateways de señalización, softswitches, sistemas de mensajería en tiempo real.

Mensajería y tiempo real

• Escala: millones de conexiones concurrentes con latencia mínima.
• Proyectos: Ejabberd (XMPP), RabbitMQ, CouchDB.

Fintech y trading

• Requisitos: baja latencia, alta disponibilidad, resiliencia ante fallos.
• Encaje: procesamiento distribuido y tolerante a fallos.

IoT y sistemas distribuidos

• Modelo: procesos ligeros + supervisión automática.
• Casos: sensores distribuidos, gateways IoT, sistemas de monitoreo.

---

3. ¿Por qué no ha sido reemplazado?

Ningún otro lenguaje combina al mismo nivel: procesos ultraligeros, aislamiento entre procesos, paso de mensajes seguro, supervisores que reinician fallos automáticamente, hot code swapping y escalabilidad horizontal nativa. Muchos lenguajes modernos intentan imitarlo; pocos lo logran.

---

4. Comparativa: Erlang vs Elixir vs Haskell (2025)

Característica	Erlang	Elixir	Haskell
Paradigma	Funcional, concurrente	Funcional, concurrente	Funcional puro
VM	BEAM	BEAM	GHC
Concurrencia	★★★★★	★★★★★	★★★
Tolerancia a fallos	★★★★★	★★★★★	★★
Hot code reload	Sí	Sí	No
Ecosistema web	Limitado	Phoenix (muy fuerte)	Limitado
Curva de aprendizaje	Media	Baja	Alta
Uso típico	Telecom, mensajería, sistemas críticos	Web, APIs, tiempo real	Compiladores, investigación, sistemas puros
Comunidad	Pequeña pero estable	Creciente	Académica

Conclusión comparativa: Erlang sigue siendo el rey de la resiliencia; Elixir es la puerta de entrada moderna al ecosistema BEAM; Haskell brilla en lógica pura, no en sistemas distribuidos de alta disponibilidad.

---

5. Ejemplos sencillos para entender su poder

Ejemplo 1: Un proceso que puede fallar (y un supervisor lo traería de vuelta)

ejemplo.erl

-module(ejemplo).
-export([start/0, loop/0]).

start() ->
    spawn(fun loop/0).

loop() ->
    receive
        crash ->
            exit(crashed);
        _ ->
            io:format("Mensaje recibido~n")
    end,
    loop().

Idea clave: en Erlang los procesos están aislados y los supervisores de OTP reinician los que fallan para mantener el sistema saludable.

Ejemplo 2: Concurrencia masiva en una línea

spawn(fun() -> io:format("Hola desde un proceso~n") end).

Punto fuerte: puedes crear millones de procesos ligeros gracias a la VM BEAM y su planificación cooperativa.

Ejemplo 3: Comunicación entre procesos

Shell de Erlang:

Pid = spawn(fun() ->
    receive
        {hola, From} ->
            From ! "Hola desde Erlang!"
    end
end),

Pid ! {hola, self()},
receive
    Respuesta -> io:format("~p~n", [Respuesta])
end.

Modelo mental: todo se coordina por paso de mensajes; no hay memoria compartida, lo que evita condiciones de carrera y simplifica la concurrencia.

---

6. ¿Deberías aprender Erlang en 2025?

Si te atraen sistemas distribuidos, alta disponibilidad, telecomunicaciones, mensajería, backend resiliente y microservicios, la respuesta es sí. Si prefieres una entrada más suave, comienza con Elixir: sintaxis moderna, misma potencia de BEAM.

---

7. Conclusión

Erlang no compite por ser trendy; compite por ser confiable. Sigue vivo porque fue diseñado para problemas que persisten, su modelo de concurrencia es superior, su tolerancia a fallos es incomparable y el ecosistema OTP/BEAM continúa sólido. Industrias enteras dependen de él, y por eso, en 2025, Erlang sigue ganando.

Enlaces:

https://codemonkeyjunior.blogspot.com/2021/06/erlang-sitios-para-aprender.html
https://codemonkeyjunior.blogspot.com/2021/05/erlang-beam.html
https://codemonkeyjunior.blogspot.com/2021/07/elixir-sitios-para-aprender.html

Intro to Elixir, APIs, and data architecture

Jacob Luetzow en este vídeo de Youtube nos da introducción de Elixir.

"My name is Jacob Luetzow, and I architect and build production-ready API's that scale with your company's growth. I will take you through step-by-step tutorials and teach you everything you need to know about building a robust backend for your apps". 

"You will get tips, tricks, and how-to's with building a REST API in Elixir, writing scripts to automate your build process, spinning up docker containers, and the DevOps skills required to maintain and load balance your servers". 

"Before starting your next API project, check out my hands-on tutorials and architect and build it the right way the first time".

Erlang: funciones y otras cosas más

Como vimos en un post anterior de Erlang vimos cómo emplear algunas funciones. En este post vamos a ver como emplear funciones propias de Erlang y a crear las nuestras.

Pero antes vamos a repasar algunas cosas sobre módulos en Erlang:

fundamentos.erl

%% @doc Fundamentos en Erlang.
%% @copyright Codemonkey Junior 2023.

%% Nombre de nuestro módulo.
-module(fundamentos).

%% autor del módulo
-author("Codemonkey Junior").

%% versión del módulo
-version("1.0.0").

%% Exportamos las funciones que vamos a usar.
-export([start/0]).

%% Para importar funciones.
-import(io, [fwrite/1]).

%% Para exportar todas las funciones.
-compile(export_all). 

%% Para exportar todas las funciones sin warnings.
-compile(nowarn_export_all).

Como buena práctica podemos documentar el código usando las etiquetas @doc. También escribir comentarios de lo que hace cada función. En este caso exponemos como importar y exportar funciones en nuesto módulo. Para obtener información de nuestro módulo podemos hacer algo como esto:

$ erl
> c(fundamentos).
> fundamentos:module_info().

La función module_info() mostrará la información del módulo. 

Como vimos en un post anterior. Podemos crear funciones para realizar alguna acción. En el caso de abajo, se trata de una función para convertir números binario, octal y hexadecimal a decimal.

-module(fundamentos).
-author("Codemonkey Junior").
-version("1.0").
-export([start/0,convierte/0]).


println(Cosa) -> io:format("~p~n", [Cosa]).


start()->
    println(" ==== Erlang ===="),
    Funcion = fun(X)-> X*2 end,
    println(Funcion(45)),
    println(self()),
    convierte().

convierte()->
    X = 2#101,
    Y = 8#0677,
    Z = 16#AE,
    io:format("De binario a decimal: ~p~n",[X]),
    io:format("De octal a decimal: ~p~n",[Y]),
    io:format("De hexadecimal a decimal: ~p~n",[Z]).

% erl
% c(fundamentos).
% fundamentos:start().

Entramos al REPL o Shell de Erlang, cargamos el programa e invocamos la función.

Erlang al igual que otros lenguajes de programación funcionales plantean una nueva forma de pensar para los programadores que usan Java, C#, C, C++ o Python. Mientras que los programadores Java requieren crear clases y clases, módulos y módulos para resolver un problema planteado con Erlang (Haskell, etc.) bastarán algunos bloques de código para hacer lo mismo. Aunque el código, en un principio, parezca incomprensible.

Elixir: funciones

 

Continuando con la serie sobre Elixir en ésta ocasión veremos algo de funciones. Funciones propias del lenguaje y cómo crear las nuestras.

Pero, antes que nada, ¿qué es una función? Una función es un bloque de código que realizar una operación específica. Este bloque tiene un nombre y contiene las instrucciones necesarias para realizar esa tarea. Se puede invocar y devolverá un valor: el resultado de dicha operación.

# Función para sumar 2 números
suma = fn (a,b) -> a+b end

# Función para restar dos números
resta = fn (a,b) -> a-b end

En este código definimos dos funciones anónimas (suma y resta) que nos devolverán el resultado. Invocamos las funciones.

IO.puts suma.(3,5) # 8
IO.puts resta.(6,2) # 4

Abajo hacemos uso de una función propia de Elixir para medir la longitud de una cadena.

String.length("CODE-MONKEY-JUNIOR")
18

Existen más funciones para manipulaciones de cadena de caracteres que son muy útiles y nos ahorrarán tiempo de desarrollo.

String.contains?("code for life", "for")
true

String.capitalize("elixir")
"Elixir"

String.downcase("CODEMONKEY")
"codemonkey"

¿Y qué con los procedimientos? Un procedimiento es similar a una función. Es un bloque que tendrá un nombre y podrá ser invocado, pero no devolverá ningún valor.

Esto (los procedimientos) se puede ver en un clásico Hola mundo o cualquier operación que no devuelva algo con lo que podamos hacer alguna operación.

holamundo.exs

defmodule Hello do
  def print(lang \\ :en)
  def print(:de), do: "Hallo Welt"
  def print(:en), do: "Hello World"
  def print(:es), do: "Hola Mundo"
  def print(:ru), do: "Привет мир"
end

IO.puts Hello.print()
IO.puts Hello.print(:es)
Io.puts Hello.print(:ru)

Ejecutamos:

$ elixir holamundo.exs
Hello World
Hola Mundo
Привет мир

Ahora procedemos a crear dos funciones de suma y resta (funciones con nombre):

defmodule Operaciones do 
  def sumar(x,y) do 
    x+y
  end

  def restar(x,y) do 
    x-y
  end  
end

Invocamos las funciones:

x=2
y=4

IO.puts "Suma de #{x} + #{y} da: #{Operaciones.sumar(x,y)}"
IO.puts "Resta de #{x} - #{y} da: #{Operaciones.restar(x,y)}"

Más post sobre elixir en futuras entregas.

Enlaces:

https://elixir-lang.org/
https://joyofelixir.com/

Erlang en ejemplos 3

Recapitulando lo visto en publicaciones anteriores:

Erlang es un lenguaje de programación funcional, compilado, tipado dinámicamente, tolerante a fallas y concurrente. Erlang es un lenguaje exótico ya que aborda la concurrencia diferente a los lenguajes de programación convencionales.

Erlang se utiliza para construir sistemas de software en tiempo real masivamente escalables con requisitos de alta disponibilidad. Algunos de sus usos son en telecomunicaciones, banca, comercio electrónico, telefonía informática y mensajería instantánea. El sistema de tiempo de ejecución de Erlang tiene soporte incorporado para concurrencia, distribución y tolerancia a fallas.

OTP es un conjunto de bibliotecas de Erlang y principios de diseño que proporcionan middleware para desarrollar estos sistemas. Incluye su propia base de datos distribuida, aplicaciones para interactuar con otros lenguajes, herramientas de depuración y manejo de versiones.

En el siguiente programa veremos:

• Crear variables (en mayúscula)
• Asignar valores a variables
• Crear una función local
• Crear funciones "globales"
• Operación de conversión de binario, octal y hexadecimal a decimal

fundamentos.erl

-module(fundamentos).
-author("Codemonkey Junior").
-version("1.0").
-export([start/0,convierte/0]).


println(Cosa) -> io:format("~p~n", [Cosa]).


start()->
    println(" ==== Erlang ===="),
    Funcion = fun(X)-> X*2 end,
    println(Funcion(45)),
    println(self()),
    convierte().

convierte()->
    X = 2#101,
    Y = 8#0677,
    Z = 16#AE,
    io:format("De binario a decimal: ~p~n",[X]),
    io:format("De octal a decimal: ~p~n",[Y]),
    io:format("De hexadecimal a decimal: ~p~n",[Z]).

% erl
% c(fundamentos).
% fundamentos:start().

En Erlang podemos crear funciones de la siguiente forma:

Funcion = fun(X)-> X*2 end

O también así:

mi_funcion(Arg)->
     Arg + 3.

Ejecutando el programa:

$ erl
> c(fundamentos).
> fundamentos:start().

En el próximo post continuaremos con más ejemplos.

Sitios:

https://erlangbyexample.org/
https://adoptingerlang.org/
https://emanuelpeg.blogspot.com/search?q=erlang

Erlang: construir aplicaciones Erlang con Rebar3

Rebar3 es una herramienta que permite crear aplicaciones Erlang. Para instalarlo puedes seguir este link: http://rebar3.org/docs/getting-started/

Abrimos una terminal y tecleamos:

$ rebar3 new app auditor
===> Writing auditor/src/auditor_app.erl
===> Writing auditor/src/auditor_sup.erl
===> Writing auditor/src/auditor.app.src
===> Writing auditor/rebar.config
===> Writing auditor/.gitignore
===> Writing auditor/LICENSE
===> Writing auditor/README.md

Nos ubicamos en el directorio:

$ cd auditor
$ tree
.
├── LICENSE
├── README.md
├── rebar.config
└── src
    ├── auditor.app.src
    ├── auditor_app.erl
    └── auditor_sup.erl

Con esto tendremos nuestra primera aplicación creada con Rebar3.

exit()->
   io:fwrite("Hasta la próxima!!!\n").

Enlaces:
https://medium.com/erlang-central/building-your-first-erlang-app-using-rebar3-25f40b109aad
https://rebar3.readme.io/
https://adoptingerlang.org/docs/development/otp_applications/

Erlang: registros (record)

Un registro es un conjunto de campos que contienen los datos que pertenecen a una misma entidad. En base de datos representa una fila, una tupla. En Erlang podemos crear un registro de la siguiente manera:

%% Define un registro 'persona'
-define(persona,{nombre, edad, edo_civil = soltero}).

%% Define un registro 'producto'
-define(producto,{nombre, precio, marca, disponibilidad=true}).

En este ejemplo hemos creado dos registros:

1. persona
2. producto

Un registro en Erlang es similar a una estructura en C. Suele utilizarse para almacenar un número fijo de elementos. 

typedef struct{
  char nombre[30];
  char marca[30];
  double precio;
}Producto;

Las expresiones de registro se traducen a expresiones de tupla durante la compilación.

Ejemplo. Crear un registro 'producto' con cuatro atributos: nombre, marca, precio, disponibilidad

modelo.erl

%% @doc Registros en Erlang
-module(modelo).
-author("Code Monkey Jr").
-compile(export_all).
-compile(nowarn_export_all).
-record(producto, {nombre, marca, precio, disponibilidad=true}).


inicio()->
    MyProd = #producto{nombre="Jamon de Viena", marca="El chuletón", precio=86.99},
    io:format("Producto disponible? : ~p~n",[MyProd#producto.disponibilidad]),
    io:format("Nombre: ~p~n",[MyProd#producto.nombre]),
    io:format("Marca: ~p~n",[MyProd#producto.marca]),
    io:format("Precio: ~p~n",[MyProd#producto.precio]).

%% erl
%% c(modelo).
%% modelo:inicio().

En lenguajes más "modernos" como Groovy tendríamos el siguiente resultado:

class Producto{
   String nombre
   String marca
   double precio
   boolean disponibilidad
}

Links:
https://erlangbyexample.org/records

Erlang en ejemplos

En pasados post vimos como instalar una imagen de Erlang usando Docker. También vimos como instalar Erlang en nuestra máquina. Una diferencia entre la ejecución de un programa Erlang usando la imagen instalada con docker es que debe haber un metódo main con un argumento:
holamundo.erl

% Hola mundo en Erlang
-module(holamundo).
-import(io, [format/1]).
-export([main/1]).

main(_Args) ->
    format("Hola, mundo con Erlang!!~n").

Ejecutando con Docker:

$ docker run -it --rm --name erlang-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp erlang escript holamundo.erl

Teniendo instalado Erlang en nuestras máquinas el código cambia un poco. No es necesario contar con un método main con un argumento.
holamundo2.erl

% Hola mundo en Erlang
-module(holamundo).
-import(io, [format/1]).
-export([start/0]).

start() ->
    format("Hola, mundo con Erlang!!~n").

Ejecutando sin Docker:

$ erl
> c(holamundo2).
> holamundo2:start().

Es importante recordar que toda variable en Erlang debe comenzar con una mayúscula y toda instrucción termina con un punto. Tampoco puedes reasignar un valor a una variable con valor asignado previamente.

$ erl

Erlang/OTP 24 [erts-12.0] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]

Eshell V12.0  (abort with ^G)
1> E=0.
0
2> 0=E.
0
3> E=8.
** exception error: no match of right hand side value 8
4> E=4.
** exception error: no match of right hand side value 4
5> 
BREAK: (a)bort (A)bort with dump (c)ontinue (p)roc info (i)nfo
       (l)oaded (v)ersion (k)ill (D)b-tables (d)istribution

Ejemplo. Crear una función que sume dos número enteros.
suma.erl

-module(suma).
-author("Codemonkey Junior").
-version("1.0.0").
-export([suma/2, main/1]).
-import(io, [format/1]).
-import(io, [format/2]).

main(_Args)->
     format("Sumar dos numeros en Erlang~n"),
     A = 2,
     B = 3,
     suma(A,B).

suma(A, B)->
    format("A=~p~n",[A]),
    format("B=~p~n",[B]),
    RESULT = A+B,
    format("Suma=~p~n",[RESULT]).


% erl
% c(suma).
% suma:main(1).
% q().

Ejecutamos...

$ erl
> c(suma).
> suma:main(1).
> q().

En próximos post veremos más ejemplos.
Enlaces:
https://codemonkeyjunior.blogspot.com/2020/09/docker-instalando-erlang.html
https://erlang-otp.es/
https://learnyousomeerlang.com/

Erlang: compilar y ejecutar programa

En el anterior post sobre Erlang y la instalación de una imagen con Docker. Esta vez veremos cómo instalar Erlang en Ubuntu.

Pero, ¿qué es Erlang?

Erlang es un lenguaje de programación que se utiliza para construir sistemas de software en tiempo real escalables de forma masiva con requisitos de alta disponibilidad.

Algunos de sus usos se encuentran en telecomunicaciones, banca, comercio electrónico, telefonía informática y mensajería instantánea. El sistema de tiempo de ejecución de Erlang tiene soporte integrado para concurrencia, distribución y tolerancia a fallas.

¿Qué es la OTP?

OTP es un conjunto de bibliotecas de Erlang y principios de diseño que proporcionan middleware para desarrollar estos sistemas. Incluye su propia base de datos distribuida, aplicaciones para interactuar con otros lenguajes, herramientas de depuración y manejo de versiones.

Instalando Erlang.

$ echo "deb https://packages.erlang-solutions.com/ubuntu focal contrib" | sudo tee /etc/apt/sources.list.d/rabbitmq.list
$ sudo apt update
$ sudo apt install erlang
$ erl

Notas sobre Erlang:

• Erlang esta diseñado para programas distribuidos y de alto rendimiento
• Un programa en Erlang tiene la extensión *.erl
• Las variables deben estar en mayúscula
• No puedes reasignar valor a una variale declarada
• Etc.

saludar.erl

-module(saludar).
-author("CodeMonkey Junior").
-version("1.0.0").
-export([start/0]).

start() ->
    io:fwrite("Saludos desde México!!\n").


% erlc saludar.erl
% erl -noshell -s saludar start -s init stop

Si queremos ejecutar desde el REPL de Erlang

$ erl
> c(saludar).
> saludar:start().

Enlaces:
http://www.methodsandtools.com/archive/erlang.html
https://issuu.com/angelfelipegonzalez/docs/erlang-i
https://www.thegeekstuff.com/2010/05/erlang-hello-world-example/