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

En una anterior entrega ya habíamos hablado sobre el tema.

Mencionamos que el lenguaje Erlang había nacido para problemas que aún son vigentes:

• Millones de conexiones simultáneas. 
• Sistemas distribuidos globales. 
• Microservicios que no pueden caerse. 
• Plataformas con latencia estable y operación 24/7 sin downtime.

Quienes vienen de lenguajes como Java o C# deberán cambiar la forma de pensar si es que quieren aprender este lenguaje. La razón es simple: el paradigma de programación de sistemas que usa Erlang es completamente diferente.

Cambios fundamentales en el paradigma

No solo es sintaxis, es un cambio de la forma en la que piensas. El programador incipiente deberá entender que Erlang es diferente, veamos algunos cambios importantes:

• Orientación a objetos vs. Modelo de Actores: En Java/C# piensas en clases, interfaces y objetos que comparten memoria y métodos. En Erlang no hay clases ni objetos; todo son procesos ligeros que no comparten memoria y se comunican únicamente mediante el envío explícito de mensajes asíncronos. 
• Estado mutable vs. Inmutabilidad: Olvídate de modificar variables o campos de una clase. En Erlang todas las variables son inmutables. El estado se gestiona mediante recursión y pasando el nuevo estado como argumento a la siguiente llamada de función. 
• Manejo de errores (Let it crash): En lugar de llenar tu código con bloques try/catch defensivos para cada excepción posible, la filosofía de Erlang es dejar que el proceso falle. Un supervisor detectará la caída y reiniciará el proceso automáticamente a un estado limpio conocido. 
• Tipado dinámico vs. Estático: Erlang utiliza tipado dinámico en tiempo de ejecución. Para compensar la falta de verificación en compilación que tienes en C# o Java, la comunidad depende fuertemente de Dialyzer (análisis estático) y especificaciones de tipos (-spec).

Breve comparativa entre BEAM y JVM

La máquina virtual de Erlang (BEAM) y la máquina virtual de Java (JVM) en comparativa:

En pocas palabras, estas herramientas hacen prácticamente lo mismo. Cada una con sus propias peculiaridades.

Conceptos clave del ecosistema OTP

Los conceptos que deberás entender:

• OTP (Open Telecom Platform): Erlang casi nunca se usa "a secas"; se utiliza junto con OTP, que es la librería estándar de patrones de diseño distribuidos. 
• GenServer: El equivalente a una clase de servicio o Singleton que mantiene un estado y responde a llamadas sincrónicas o asíncronas. 
• Supervisores: Procesos cuyo único trabajo es monitorear a otros procesos y aplicar estrategias de reinicio cuando alguno falla. 
• Hot Code Swapping: La capacidad nativa del runtime para actualizar el código de una aplicación en producción sin detener el sistema ni perder conexiones activas.

Buenas prácticas y herramientas para 2026

Esto es lo que un programador debería tomar en cuenta a la hora de empezar con este lenguaje:

• Pattern Matching: Dominar la coincidencia de patrones es esencial; se utiliza en la asignación de variables, en los argumentos de las funciones y en la extracción de mensajes. 
• Herramientas de construcción: La herramienta estándar moderna para gestionar proyectos, dependencias y compilación en Erlang es rebar3. 
• Ecosistema BEAM y Elixir: La máquina virtual de Erlang se llama BEAM. Elixir corre sobre la misma VM y comparte la misma interoperabilidad. Conocer Erlang te da acceso directo a todo el ecosistema de BEAM.

¿Para qué aprender Erlang?

Aprender Erlang te otorga un entendimiento profundo del motor runtime (BEAM). Lo que permite dominar Elixir y crear arquitecturas capaces de manejar millones de eventos en tiempo real.

Erlang se aplica en problemas donde la caída de un servidor representa pérdidas millonarias o fallos críticos:

• Telecomunicaciones y Mensajería: Gestión de switches de señalización (VoIP), procesamiento de mensajería masiva en tiempo real y componentes de red donde el tiempo de actividad (uptime) debe ser del 99.999%. 
• Plataformas Fintech y Pagos: En el ecosistema fintech mexicano (con cientos de empresas activas procesando transacciones), Erlang/Elixir se usa para motores de procesamiento de pagos, autorizaciones SPEI de alta frecuencia y sistemas transaccionales con tolerancia a fallos. 
• Internet de las Cosas (IoT) y Redes: Manejo de gateways que reciben telemetría constante de miles de sensores o dispositivos conectados simultáneamente sin colapsar el hilo principal. 
•  Infraestructura Backend y Cuchillería de Sistemas: Procesamiento de colas de mensajes distribuidas (como las basadas en RabbitMQ) y motores de base de datos distribuidos (como CouchDB o Riak).

En el mundo laboral actual, Erlang (y su hijo Elixir) es uno de esos lenguajes "raros" que muy pocas personas dominan o emplean de manera profesional. La mayoría de las empresas prefieren lenguajes conocidos como Java, C# y Python para sus desarrollos. Incluso lenguajes como COBOL siguen vigentes y con una importante demanda.

En países de Europa y USA existen vacantes. En países como México es poca la demanda, la mayoría ofertas de trabajo remoto.

¿Por qué Erlang sigue vivo en 2026? Porque resuelve problemas que aún existen... y existirán en un futuro.

Enlaces:

https://codemonkeyjunior.blogspot.com/2021/06/erlang-sitios-para-aprender.html

¿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

Gleam en ejemplos

Continuamos con el tema de Gleam, un lenguaje que corre sobre la máquina virtual de Erlang (BEAM). Similar a Elixir en algunos aspectos.

Si quieres programar usando este lenguaje y además usas VsCode como editor, existe un plugin que podrás instalar:

https://marketplace.visualstudio.com/items?itemName=Gleam.gleam

Te ayudará en el resaltado de estilo, formato, definición y autocompletado.

Recordemos cómo crear un proyecto en Gleam:

gleam new proyecto

Nos ubicamos en el directorio creado:

cd proyecto

Podemos usar VsCode. Abrimos una terminal y tecleamos:

code .

Esto abrirá el editor de código.

Ejemplo 1. Crear una función que mande un saludo.

La sintaxis para crear una función es la siguiente:

pub fn nombre_funcion() {
  // Cuerpo del procedimiento o función
}

Nuestra función será esta:

pub fn saludo() {
  io.println("\t Hola, mundo desde Gleam")
}

La invocamos desde el método main del programa principal.

proyecto.gleam

import gleam/io

pub fn main() {
  saludo()
}

pub fn saludo() {
  io.println("\t Hola, mundo desde Gleam")
}

Construimos y ejecutamos:

gleam build
gleam run

Salida:

        Hola, mundo desde Gleam

Ejemplo 2. Crear una función que calcula el factorial de un número.

Teniendo el siguiente pseudo código:

numero = 5
IF numero = 0 THEN
   result = 1
IF ELSE numero = 1 THEN
   result = 1
ELSE 
   result = numero * FACTORIAL(numero - 1)

La función en Gleam quedaría de tal modo:

pub fn factorial(x: Int) -> Int {
  case x {
    0 -> 1
    1 -> 1
    _ -> x * factorial(x - 1)
  }
}

La invocamos de esta manera:

import gleam/io
import gleam/int

pub fn main() {
  io.println("\t===== Factorial en Gleam =====")
  io.println("El factorial de 5: ")
  io.debug(factorial(5))
  io.println("El factorial de 7: ")
  io.debug(factorial(7))
}

Ejemplo 3. Crear una función anónima que sume dos número enteros.

fn suma(a: Int, b: Int) -> Int {
  a + b
}

Y la invocamos de la siguiente forma:

import gleam/io
import gleam/int


pub fn main() {
  io.println("\t===== Sumando en Gleam =====")
  let add = suma(3, 4)
  io.println("Suma (3,4) es: ")
  io.debug(add)
}

Este post se irá actualizando para agregar más ejemplos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/03/conociendo-gleam-un-lenguaje-que-corre.html
https://emanuelpeg.blogspot.com/search?q=gleam

Creando un proyecto con Gleam

En un post anterior vimos qué es el lenguaje Gleam, además de como instalarlo. Esta ocasión vamos a crear un proyecto con este lenguaje de programación funcional.

Creando un proyecto con Gleam

Abrimos una terminal y tecleamos:

gleam new proyecto

Esto nos creará un proyecto.

$ tree
Listado de rutas de carpetas
El número de serie del volumen es F4A1-89BE
C:.
├───.github
│   └───workflows
├───build
│   ├───dev
│   │   ├───erlang
│   │   │   ├───gleam_stdlib
│   │   │   │   ├───ebin
│   │   │   │   ├───include
│   │   │   │   └───_gleam_artefacts
│   │   │   ├───gleeunit
│   │   │   │   ├───ebin
│   │   │   │   └───_gleam_artefacts
│   │   │   └───proyecto
│   │   │       ├───ebin
│   │   │       └───_gleam_artefacts
│   │   └───javascript
│   ├───lsp
│   │   ├───erlang
│   │   └───javascript
│   ├───packages
│   │   ├───gleam_stdlib
│   │   │   ├───include
│   │   │   └───src
│   │   │       └───gleam
│   │   └───gleeunit
│   │       └───src
│   │           └───gleeunit
│   └───prod
│       ├───erlang
│       └───javascript
├───src
└───test

El programa principal será src/proyecto.gleam . Lo editaremos:

// Pruebas con Gleam

import gleam/io

pub fn main() {
  io.println("\t===== Programando en Gleam =====")
}

Para compilar y ejecutar tecleamos:

$ gleam build
$ gleam run

Nota: Podemos solo teclear el segundo comando, iniciará la compilación y después ejecutará el código:

Si la compilación es correcta, se ejecutará:

$ gleam run
  Compiling proyecto
   Compiled in 1.32s
    Running proyecto.main
        ===== Programando en Gleam =====

Variables en Gleam

La declaración de variables es algo con lo que comenzaremos a ver.

// Int
let entero = 33

// String
let cadena = "ABC"

// Int con formato
let num_binario = 0b00001111
let num_octal = 0o17
let num_hexa = 0xF

// Float
let num_flotante = 7.0e7

// Boolean
let booleano = 43 < 33 // Esto es False
	

Se pude apreciar que la declaración de variables es similar a Rust. Existen tipos Int, Float, String y Boolean.

Si queremos declarar una variable sin usar podemos hacer esto:

// Int
let _no_se_usa = 33


	

Notar que usamos el guión bajo para declarar variables que no usamos.

Código completo:

src/proyecto.gleam

// Pruebas con Gleam

import gleam/io

pub fn main() {
  io.println("\t===== Programando en Gleam =====")
  test_a()
}


pub fn test_a(){
	let entero = 33
	let cadena = "ABC"
	let num_binario = 0b00001111
	let num_octal = 0o17
	let num_hexa = 0xF
	let num_flotante = 7.0e7
	let booleano = 43 < 33 // Esto es False
	io.println("\t ====== Variables en Gleam ======")
	io.println("Entero: ")
	io.debug(entero)
	io.println("Cadena: ")
	io.debug(cadena)
	io.println("Booleano: ")
	io.debug(booleano)
	io.println("Numero binario: ")
	io.debug(num_binario)
	io.println("Numero hexadecimal: ")
	io.debug(num_hexa)
	io.println("Numero octal: ")
	io.debug(num_octal)
	io.println("Numero flotante: ")
	io.debug(num_flotante)
}

Ejecutamos el proyecto:

 gleam run
  Compiling proyecto
   Compiled in 1.32s
    Running proyecto.main
        ===== Programando en Gleam =====
         ====== Variables en Gleam ======
Entero:
33
Cadena:
"ABC"
Booleano:
False
Numero binario:
15
Numero hexadecimal:
15
Numero octal:
15
Numero flotante:
7.0e7

Hemos creado nuestro primer proyecto con este lenguaje de programación. Más en próximos posts.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/03/conociendo-gleam-un-lenguaje-que-corre.html

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.

Try Erlang (online)

 En ésta ocasión veremos un sitio web donde podemos poner en práctica el lenguaje Erlang. Se trata del sitio https://www.tryerlang.org/.

Básicamente, se trata de un REPL online.

> 34 + 31.
65
> 20 - 3.
17
> "Alpha".
Alpha
> [1,2,3,4,5].
[1,2,3,4,5]

>
  X = 33.
33
> X = Y.
"variable 'Y' is unbound"
> Y = X.
33

Seguiremos con los post de Erlang más adelante.

Comparación de la concurrencia de Erlang y Go (en Inglés)

Go tiene un sistema de concurrencia inspirado en el artículo Comunicando Procesos Secuenciales de CAR Hoare. El sistema de concurrencia de Erlang tiene más en común con el modelo Actor de Carl Hewitt. Vamos a explorar brevemente los artículos académicos que forman la base de estos dos lenguajes, y luego compararemos y contrastaremos las primitivas de concurrencia entre Erlang y Go usando demostraciones en vivo y código de muestra.

Erlang en ejemplos (4)

 En esta serie de post sobre Erlang se ha visto los tipos de datos, listas, tuplas, funciones y demás ejemplos del lenguaje.

Seguimos con esta serie.

Para obtener información del compilador/emulador de Erlang tecleamos:

man erl

Abrimos una terminal y comenzamos a realizar algunas pruebas:

erl
Erlang/OTP 25 [erts-13.0.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns]

Eshell V13.0.4  (abort with ^G)
1> A="abc".
"abc"
2> string:to_upper(A).
"ABC"
3> B="ABC".
"ABC"
4> string:to_lower(B).
"abc"
5> erlang:is_number(B).
false
6> erlang:is_number(A).
false
7> erlang:is_number(66).
true
8> erlang:is_binary(A). 
false
9> erlang:is_binary(54).
false
10> erlang:is_port(54).  
false
11> erlang:is_port(8080).
false
12> erlang:is_list(B).   
true
13> erlang:is_tuple(B).
false
14> Suma = fun(X,Y)-> X+Y end.
#Fun<erl_eval.41.3316493>
15> Suma(43,32).
75
16> MiSuma= Suma(8,5).
13
17> elang:is_function(Suma).
** exception error: undefined function elang:is_function/1
18> erlang:is_function(Suma).
true
19> 45 + "32".
** exception error: an error occurred when evaluating an arithmetic expression
     in operator  +/2
        called as 45 + "32"
20> 23*43/(21+32+43+44)-45.
-37.93571428571428
21> 89+(32*4/32).
93.0
22> 33=33.
33
23> 12=9.
** exception error: no match of right hand side value 9
24> N=43.
43
25> N+43.
86
26> (N+43)/2.
43.0
27> erlang:is_list(N).
false
28> erlang:is_number(N).
true
29> erlang:is_integer(N).
true
30> erlang:is_float(N).  
false
31> Lista=[1,2,3,4,5].
[1,2,3,4,5]
32> erlang:is_list(Lista). 
true
33> erlang:is_tuple(Lista).
false
34> Division= fun(X,Y)-> X div Y end.
#Fun<erl_eval.41.3316493>
35> Division(23,32).
0
36> erlang:is_integer(Division(8,3)).
true
37> Residuo=fun(X,Y)-> X rem Y end. 
#Fun<erl_eval.41.3316493>
38> Resisuo(220,200).
* 1:1: variable 'Resisuo' is unbound
39> Residuo(220,200).
20
40> erlang:is_number(Residuo(220,200)).
true
41> Perfil={1,"Fernando"}.
{1,"Fernando"}
42> erlang:is_tuple(Perfil).
true
43> Message = {"MX",true,345,Perfil}.
{"MX",true,345,{1,"Fernando"}}
44> {Id,Name}=Perfil.
{1,"Fernando"}
45> Id.
1
46> Name.
"Fernando"
47> {Code,Available,Numer,User}=Message.
{"MX",true,345,{1,"Fernando"}}
48> Code.
"MX"
49> Available.
true
50> Numer.
345
51> User.
{1,"Fernando"}
52> {_,MyName}=Perfil.
{1,"Fernando"}
53> MyName.
"Fernando"
54>q(). 

Como se puede observar Erlang tiene ciertas particularidades y funciones propias para realizar cosas como tratamiento de cadenas, verificar si una variable es de determinado tipo (integer, float, etc.), si alguna declaración es una lista, una tupla, una función. Así como declarar funciones, crear tuplas, etc.

Algunas funciones de Erlang

Función	Uso
is_atom/2	Verificar si es atom
is_binary/2	Verificar si es binary
is_bitstring/1	Verificar si es bitstring
is_boolean/1	Verificar si es boolean
is_float/1	Verificar si es float
is_function/1	Verificar si es function
is_port/1	Verificar si es port
is_integer/1	Verificar si es integer
is_number/1	Verificar si es number
is_record/1	Verificar si es record
is_tuple/1	Verificar si es tuple

Cosas importantes para no olvidar

Obtener informacíon del módulo.

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

Con esto se mostrará la información del módulo

Documentación, exportación e importación de módulos/funciones. Definición de constantes y macros.

%% @doc Fundamentos en Erlang
%% @copyright Codemonkey Junior 2022
-module(fundamentos).
-author("Codemonkey Junior").
-version("1.0.0").
-export([start/0]).
-import(io, [fwrite/1]).
-compile(export_all). % Para exportar todas las funciones
-compile(nowarn_export_all). % Para exportar todas las funciones sin warnings
-define(MAX, 1000). %% constante
-define(CUADRADO (X), X*X). %% macro, similar a C

Continuaremos en próximos post.

https://codemonkeyjunior.blogspot.com/2021/12/erlang-constuir-aplicaciones-erlang-con.html

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

Elixir iex, understanding the REPL (vídeo en Inglés)