¿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

Wisp: un nuevo framework para Gleam

El lenguaje de programación Gleam ahora cuenta con un nuevo framework: Wisp.

Wisp fue creado por Louis Pilfol.

Este nuevo framework ofrece:

• Middleware componible, con muchos recursos útiles integrados. 
• Enrutamiento seguro de tipos con coincidencia de patrones tradicional. 
• Análisis de JSON, URL y cuerpos multiparte. 
• Cookies firmadas a prueba de manipulaciones, ideales para autenticación. 
• Limitación del tamaño del cuerpo y transmisión de archivos al disco para evitar ataques de agotamiento de memoria. 
• Entrega de CSS, JavaScript o cualquier otro recurso estático que desee. 
• Registro, tanto ad hoc como de solicitudes, mediante middleware. 
• Programación estándar con Gleam, para que pueda usar cualquier paquete de Gleam sin problemas.

Este ejemplo sacado de la página oficial es una muestra de lo que se puede hacer:

import my_app/people
import my_app/web.{Context}
import gleam/result.{try}
import wisp.{Request, Response}

pub fn handle_request(req: Request, ctx: Context) -> Response {
  use json <- wisp.require_json(req)

  let result = {
    use params <- try(people.parse_params(json))
    use person <- try(people.save(params, ctx.db))
    Ok(people.to_json(person))
  }

  case result {
    Ok(body) -> wisp.json_response(body, 201)
    Error(_) -> wisp.bad_request()
  }
}

Aquí vemos una solicitud a un JSON API y guarda un elemento en una base de datos.

Como hemos mencionado en esta serie de entregas sobre Gleam, se trata de un nuevo lenguaje de programación (que corre sobre la máqina de BEAM) que toma lo mejor de lenguajes Elixir y Erlang para proveer un camino más sencillo al programador.

Continuaremos con esta serie más adelante.

Enlaces:

https://elixirforum.com/t/gleam-has-a-new-web-framework/59874
https://gleam-wisp.github.io/wisp/
https://x.com/louispilfold
https://github.com/gleam-wisp/wisp

Un vistazo a la programación funcional

La Programación Funcional (Functional Programming)es un paradigma de programación declarativa (decir qué queremos, pero no cómo hacerlo) basado en el uso de funciones matemáticas donde:

• Estaremos trabajando principalmente con funciones (el elemento principal para construir programas), evitaremos los datos mutables, así como el hecho de compartir estados entre funciones.
• Y donde el valor generado por una función depende exclusivamente de los argumentos alimentados a la función.
• Las funciones serán tratadas como ciudadanos de primera clase y podrán ser asignadas a variables además podrán ser utilizadas como entrada y salida de otras funciones.
• Además, evitamos a toda costa los efectos secundarios que alteren el estado del programa u otros programas.
• Ejemplos de lenguajes que soportan este paradigma son Haskell, Elixir, Erlang , Scala, y Clojure.

Características principales:

1. Funciones puras: Las funciones siempre producen el mismo resultado para los mismos argumentos y no tienen efectos colaterales (no modifican variables globales ni realizan I/O directamente). 
2.  Inmutabilidad: Los datos no se pueden modificar una vez creados. En lugar de cambiar valores, se crean nuevos valores. 
3.  Funciones de orden superior: Las funciones pueden aceptar otras funciones como argumentos o devolver funciones. 
4.  Composición de funciones: Las funciones se pueden combinar para crear otras más complejas, facilitando la reutilización de código. 
5.  Evaluación perezosa: Las expresiones no se evalúan hasta que su resultado es necesario, optimizando el rendimiento en muchos casos.

Ventajas:

1. Código más predecible y fácil de razonar gracias a la ausencia de efectos colaterales. 
2. Facilidad para la concurrencia y el paralelismo, ya que no hay variables mutables que puedan causar conflictos.

Algunos conceptos clave de la Programación Funcional

1. Funciones puras: Funciones que siempre producen el mismo resultado para los mismos argumentos. 
2. Inmutabilidad: Los valores no pueden ser modificados una vez creados.
3. Currificación: Funciones que pueden ser llamadas con menos argumentos de los que requieren originalmente.
4. Composición de funciones: Encadenar funciones mediante el operador (.).
5. Pattern matching: Hacer coincidir patrones en listas, tuplas, y otros datos estructurados.
6. Guards y condicionales: Usar guards para control de flujo condicional.
7. Recursión: La forma principal de control de iteraciones.

Ejemplo 1. Crear una función pura que nos sume dos números enteros. Este ejemplo lo haremos en Haskell.

suma.hs

suma :: Int -> Int -> Int
suma x y = x + y

main :: IO()
main = print (suma 8 3)

Como se puede ver, iniciamos con la delaración de tipos (Int). Definimos la función (suma) y en la d¿función principal (main) asignamos dos valores por default (8 y 3), lo cual nos dará como resultado 11.

Si solo queremos ejecutar el programa, abrimos una terminal y tecleamos lo siguiente:

runghc suma.hs

Si queremos compilar y crear un ejecutable, entonces:

ghc -o suma.exe suma.hs

Como la definición de una Función Pura indica, el resultado será el mismo cuando los argumentos son los mismos. Si invertimos el lugar del los valores (8, 3 por 3,8) el resultado seguirá siendo el mismo.

Aprender programación funcional se ha vuelto una "moda" que ya no solo implica el ámbito académico. Puesto que ya son muchos proyectos como la I.A. o Aprendizaje Automático que cada vez más requieren desarrolladores que dominen los principios de la matemática y, por ende, la programación funcional.

Enlaces:

https://codemonkeyjunior.blogspot.com/search?q=erlang
https://codemonkeyjunior.blogspot.com/search?q=elixir
https://emanuelpeg.blogspot.com/search?q=haskell

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

Conociendo Gleam, un lenguaje que corre sobre la máquina de Erlang

 

Gleam es: un lenguaje de programación funcional que corre sobre la máquina virtual de Erlang (BEAM) o como lo dice el sitio oficial:

"Es un lenguaje amigable para construir sistemas con seguridad de tipos que escalan".

El clásico "Hello world" en Gleam:

// Import a Gleam module from the standard library
import gleam/io

pub fn main() {
  io.println("Hola, mundo en Gleam!")
}

Si quieres probarlo sin tener que instalarlo, checha este sitio: https://tour.gleam.run/

A primera vista Gleam nos recuerda a lenguajes como Rust o quizás Golang y hasta Ballerina language.

Instalando Gleam

En Linux:

sudo xbps-install gleam

En Windows necesitamos instalar Scoop antes de Gleam. Debemos abrir una terminal de Powershell como administrador y teclear estos comandos:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

En caso de que no permita instalar, teclear este comando:

iex "& {$(irm get.scoop.sh)} -RunAsAdmin"

Verificar instalación de Scoop:

scoop help

Procedemos a instalar Gleam:

scoop install gleam

Verificar instalación de Gleam:

$ gleam --version
gleam 0.34.1

Más sobre este lenguaje en próximos posts.

Enlaces:

https://gleam.run/
https://emanuelpeg.blogspot.com/2023/03/gleam-un-lenguaje-funcional-que-corre.html
https://scoop.sh/
https://github.com/ScoopInstaller/Install#for-admin

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".

Un programa en varios lenguajes

 

Esta ocasión veremos un ejemplo de programa escrito en varios lenguajes de programación como: Java, Erlang, Python, Powershell, Clojure y otros más.

Ejercicio: Un programa que determine si una cadena ("ABC") tiene una longitud distinta de cero. Si la longitud de cadena es distinta de cero, que imprima la cadena en pantalla. Si no cumple la condición deberá mandar el mensaje: "Cadena vacía".

En pseudo código sería algo como esto:

// Pseudo code language
prog longitud:{
     var cadena:String = "ABC";
     var longitud:Int = cadena.size;
     if longitud != 0 then
        disp "${cadena}"
     else
        disp "Cadena vacía"
}

Por temas de espacio algunos bloques de código son omitidos para no hacer más grande el código, usted disculpe.

En Powershell:

longitud.ps1

$cadena="ABC"

if($cadena.Length -ne 0){
   Write-Host $cadena  
}
else{
   Write-Host "Cadena vacia"
}

En Clojure:

longitud.clj

(ns longitud)

(def cadena "ABC")
(def longitud (count cadena))
(if (not= longitud 0)
   (println cadena)
   (println "Cadena vacia")
)

En Erlang:

longitud.erl

-module(longitud).
-author("Codemonkey Junior Blogspot").
-version("1.0.0").
-export([start/0]).

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

start()->
    Cadena="ABC",
    Longitud=string:length(Cadena),
    if 
     Longitud /= 0 ->
       println(Cadena);
    true ->
       println("Cadena vacia")
    end.

En OpenEdge ABL:

longitud.p

define var as char no-undo initial "ABC".

if length(cadena)<>0 then
   disp cadena.
else
   disp "Cadena vacia".

En Rust:

longitud.rs

let cadena:String = String::from("ABC");

if cadena.chars().count()!=0 {
   println!("{}",cadena)
}
else{
   println!("Cadena vacia")
}

En PL/SQL:

longitud.sql

SET SERVEROUTPUT ON
DECLARE
  cadena varchar2(3):='ABC';
  BEGIN
       IF LENGTH(cadena) != 0 THEN
          dbms_output.put_line(cadena);
       ELSE
          dbms_output.put_line('Cadena vacia');
       END IF;
  END;
/

En Elixir:

longitud.exs

cadena = "ABC"

if String.length(cadena) != 0 do
  IO.puts "#{cadena}"
else
  IO.puts "Cadena vacia"
end

En R:

longitud.r

cadena <- "ABC"

if(nchar(cadena) != 0) {
  sprintf("%s",cadena)
}else{
  print("Cadena vacia")
}

En DataStage BASIC:

longitud.dsx

Option Explicit

' Declaración de variables
Dim cadena As String

' Asignación de valor a la variable
cadena = "ABC"

' Verificación de la longitud de la cadena
If Len(cadena) <> 0 Then
    ' Imprimir la cadena si no está vacía
    Print cadena
Else
    ' Imprimir un mensaje si la cadena está vacía
    Print "Cadena vacia"
End If

En Ballerina:

longitud.bal

import ballerina/io;

public function main() {
    string cadena = "ABC";

    if (lengthof cadena != 0) {
        io:println(cadena);
    } else {
        io:println("Cadena vacia");
    }
}

En C:

longitud.c

#include <stdio.h>
#include <string.h>

int main() {
    char cadena[] = "ABC";

    if (strlen(cadena) != 0) {
        printf("%s\n", cadena);
    } else {
        printf("Cadena vacia\n");
    }

    return 0;
}

En C++:

longitud.cpp

#include <iostream>
#include <string>

int main() {
    std::string cadena = "ABC";

    if (!cadena.empty()) {
        std::cout << cadena << std::endl;
    } else {
        std::cout << "Cadena vacia" << std::endl;
    }

    return 0;
}

En Haskell:

longitud.hs

main :: IO ()
main = do
    let cadena = "ABC"
    if length cadena /= 0
        then putStrLn cadena
        else putStrLn "Cadena vacia"

En Prolog:

longitud.pl

cadena_valida('ABC') :- write('ABC').
cadena_valida('') :- write('Cadena vacia').

main :- cadena_valida('ABC').

En Python:

longitud.py

cadena="ABC"
if len(cadena) !=0:
   print(cadena) 
else:
   print("Cadena vacia")

Este post se irá actualizando... see you later !!