Elixir en un vistazo

 

Elixir es un lenguaje de programación dependiente de la BEAM (la máquina virtual de Erlang). Su síntaxis es similar a Ruby. 

Elixir aprovecha la máquina virtual Erlang, conocida por ejecutar sistemas de baja latencia, distribuidos y tolerantes a fallas. Elixir se utiliza con éxito en desarrollo web, software integrado, ingesta de datos y procesamiento multimedia en una amplia gama de industrias.

En el anterior post sobre Elixir vimos como descargar y ejecutar una imagen con Docker. Está vez veremos como instalar Elixir en Linux(Ubuntu).
Instalar Elixir

$ wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
$ sudo dpkg -i erlang-solutions_2.0_all.deb
$ sudo apt install esl-erlang elixir

Comprobar instalación

$ elixir --version

Entrar al Shell de Elixir

$ iex

Para salir del shell debes presionar los botones Ctrl + C. 

La extensión de un programa en Elixir es *exs.

Ejemplo 1. Crear el famoso "Hola, mundo" en Elixir.

holamundo.exs

# Hola mundo en elixir
IO.puts "Hola, mundo en Elixir"

Para ejecutar el programa abrimos una terminal y tecleamos:

$ elixir holamundo.exs

En próximos post veremos más ejemplos.

Enlaces:
https://elixir-lang.org/

https://codemonkeyjunior.blogspot.com/2020/09/docker-instalando-elixir.html

Elixir: sitios para aprender

En posts pasados hemos estado hablando del lenguaje Elixir y su relación con Erlang, pues ambos lenguajes corren sobre la máquina virtual BEAM. Elixir podría ser una extraña combinación entre Erlang y Ruby, pero con lo mejor de ambas partes. En esta ocasión veremos una lista de sitios sobre Elixir que me parecen importantes.

The Inquisitive Developer

Un sitio creado por Kevin Peter, un desarrollador web que ha tenido el interés por mostrar su paso en este lenguaje. El contenido de su sitio es muy interesante. Imperdible para quienes quieren aprender Elixir.

https://inquisitivedeveloper.com/

Sitio oficial de Elixir

El sitio oficial del lenguaje Elixir. Donde podrás descargar el lenguaje y ver los pasos de instalación, guías, documentación y ejemplos.

https://elixir-lang.org/

Sitio oficial de Joy of Elixir

El sitio oficial del libro Joy of Elixir. Donde podrás acceder al contenido del libro de manera online. Además de la opción de poder adquirir el libro.

https://joyofelixir.com/

Sitio oficial de Phoenix Framework

El sitio oficial de Phoenix Framework. Si quieres usar Elixir para tus desarrollos web este sitio es el ideal para comenzar.

https://www.phoenixframework.org/

Alias Crespo Blogspot

Blog creado por Emmanuel Goette, Alias Crespo. Un blog sobre muchas cosas, muchas. Donde podrás encontrar muchos recursos, ejemplos, etc. sobre Elixir, Erlang, etc. Imperdible para todos los desarrolladores.

https://emanuelpeg.blogspot.com/

Elixir School

Sitio para aprender sobre el lenguaje Elixir. Ideal para principiantes.

https://elixirschool.com/es/

Elixir School

Sitio para aprender sobre el lenguaje Elixir. Ideal para principiantes.

https://elixirschool.com/es/

Docker: instalando Elixir

 

Elixir es un lenguaje dinámico y funcional diseñado para crear aplicaciones escalables y fáciles de mantener. En este post instalaremos una imagen de Elixir con ayuda de Docker. 

Podemos buscar una imagen tecleando:

$ docker search elixir

Descargamos e instalamos imagen de Elixir.

$ docker pull elixir

Creamos un programa Elixir. La extensión es *.exs.
hola_mundo.exs

IO.puts "Hola, mundo en Elixir!!"

El clásico programa de "Hola, mundo".  

Listamos imágenes.

$ docker images -a

Para entrar al REPL del lenguaje:

$ docker run -it --rm elixir

Para ejecutar script:

$ docker run -it --rm --name elixir-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp elixir elixir hola_mundo.exs

Links: 

https://elixir-lang.org/

Elixir: cadenas

 

En cualquier lenguaje de programación existen funciones para el tratamiento de cadenas (String).

$ iex
> String.upcase("abc")
"ABC"
> String.downcase("ABC")
"abc"

Estas funciones convertirán una cadena en minúsculas a mayúsculas. La otra String.downcase("STR") de mayúscula a minúscula.

> String.length("abc")
3
> String.capitalize("elixir")
"Elixir"

Estás dos funciones obtendrán la longitud de la cadena y la otra mostrará el primer carácter en mayúscula. 

> "abc" == "abc"
true
> "abc == "ab1"
false
> String.trim(" Elixir y Erlang ")
"Elixir y Erlang"

No existe una función como equals, pero se puede usar el operador == para comparar dos cadenas. La función String.trim(" cadena con espacios "), quitará los espacios de una cadena.

> String.to_integer("233")
233
> String.to_float("23.9")
23.9
> String.to_atom("hello")
:hello

Existen funciones para convertir cadenas a tipos entero (Int) o tipo (Float). Además de convertir la cadena a atoms, las cuales son constantes cuyos valores tienen su propio nombre. Próximamente más ejemplos en Elixir.

UPDATE: Más ejemplos de Elixir.

Ejemplo. Uso de funciones de cadena en Elixir.

cadenas.exs

cadena = "ABC"

if String.length(cadena) != 0 do
  IO.puts "Cadena: #{cadena}"
  IO.puts "Longitud [length]: #{String.length(cadena)}"
  IO.puts "Es binario [is_binary]: #{is_binary(cadena)}"
  IO.puts "Longitud[byte_size]: #{byte_size(cadena)}"
  IO.puts "Mayusculas[upcase]: #{String.upcase(cadena)}"
  IO.puts "Minusculas[lowcase]: #{String.downcase(cadena)}"  
  
  if cadena == "ABC" do
    IO.puts "Las cadenas son iguales."
  else
    IO.puts "Las cadenas no son iguales."
  end
  
else
  IO.puts "Cadena vacia."
end

Ejecutamos:

$ elixir cadena.exs

Enlaces:
https://hexdocs.pm/elixir/String.html

Por qué deberías aprender Elixir y también usarlo en producción

En este vídeo del canal de Youtube "Rafa Páez - Más allá del código" nos hablan de las ventajas de usar Elixir sobre otros lenguajes de programación. Muy recomendable para conocer las bondades del lenguaje.

Quienes han usado Ruby les llama la atención Elixir, pero la diferencia es que... Elixir esta diseñado para programación distribuida y concurrente.

Checa los enlaces de abajo para conocer más.

Enlaces:
http://alquimistadecodigo.blogspot.com/2021/06/por-que-deberias-aprender-elixir-y.html
https://www.youtube.com/channel/UCGSxspQQauJQP0TaTFKx7aw
https://www.amazon.com.mx/Elixir-Action-Juri-cacute-Sasa/dp/1617295027/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=elixir+in+action&qid=1623380351&sr=8-1
https://twitter.com/RafaPaez_ https://codemonkeyjunior.blogspot.com/search?q=elixir
https://codemonkeyjunior.blogspot.com/search?q=erlang
https://emanuelpeg.blogspot.com/search?q=elixir
https://emanuelpeg.blogspot.com/search?q=erlang

Elixir: variables

 Elixir al igual que muchos otros lenguajes funcionales como Erlang y/o Haskell permiten ejecutar un shell para interactuar. Abrimos una terminal y tecleamos:

$ iex
Erlang/OTP 23 [erts-11.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1]

Interactive Elixir (1.11.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> entero = 23
23
iex(2)> str = "ABC"
"ABC"
iex(3)> real = 3.45
3.45
iex(4)> true
true
iex(5)> not false
true
iex(6)> true or false
true
iex(7)> false or true
true
iex(8)> true and true
true
iex(9)> true and false
false
iex(10)> rem(220,200)
20
iex(11)> div(23,10)
2
iex(12)> 23 + 65
88
iex(13)> 12 / 6
2.0
iex(14)> 

Para salir del shell(repl) debemos teclear  Ctrl + C. 

Los tipos de datos en Elixir son: Int, String, Double, Booleans...

Contrario a Erlang, no es necesario que las variables comiencen en mayúscula. Tampoco que las sentencias acaben con un punto.

variables.exs

# Variables en Elixir
entero = 45
IO.puts "Entero: #{entero}"
str = "Elixir es parecido a Ruby"
IO.puts "Str: #{str}"
mayuscula = String.upcase(str)
IO.puts "Str en mayuscula: #{mayuscula}"
verdadero = 12>5 # true
if verdadero do
  IO.puts "Esto es verdadero"   
end

Ejecutamos:

$ elixir variables.exs

Enlaces:
https://elixirschool.com/en/
https://emanuelpeg.blogspot.com/search?q=elixir

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/

Elixir: Creando un proyecto con Mix

En este post veremos cómo crear un proyecto Elixir usando Mix. Pero, ¿qué es Mix? Mix es una herramienta similar a Maven o Gradle (para quienes usan Java) que nos permite crear, cmpilar, ejecutar y administrar las aplicaciones Elixir.

Tan simple como abrir una terminal y teclear:

$ mix new proyecto
$ cd proyecto
$ mix help 

Esto nos creará un proyecto con el nombre 'proyecto'. Nos ubicamos en la carpeta principal y obtenemos la ayuda.

Alejecutar el comando nos mostrará una lista de los archivos creados:

* creating README.md
* creating .gitignore
* creating .formatter.exs
* creating mix.exs
* creating lib
* creating lib/proyecto.ex
* creating test
* creating test/test_helper.exs
* creating test/example_test.exs

El archivo principal es 'proyecto.ex':

$ ls
$ cat lib/proyecto.ex

Modificamos el archivo principal y creamos un método llamado 'hola' con el clásico programa "Hola, mundo"

proyecto.ex

defmodule Proyecto do
  def hola do 
    "Hola, mundo desde proyecto Elixir"
  end
end

Nota:Es importante saber que los archivos Elixir con la extensión *.exs son interpretados y los archivos con la extensión *.ex son compilados.

Para ejecutar debemos teclear (debemos estar en la misma carpeta del proyecto):

$ iex -S mix
> Proyecto
> Proyecto.hola()
"Hola, mundo desde proyecto Elixir"

Si se edita el archivo se deberá recompilar, para eso usamos 'recompile' y volverá a acompilar el archivo:

$ iex -S mix
> Proyecto
> Proyecto.nuevo_metodo()
"AQUI SALDRIA UN ERROR"
> recompile
> Proyecto.nuevo_metodo()
"Soy un nuevo método"

En próximos post veremos más ejemplos.
Links:
https://elixirschool.com

¿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

Elixir: listas y mapas

Las listas son una secuencia ordenada de elementos del mismo tipo. Estos tipos pueden ser numéricos, strings, objetos, etc.

# Lista vacía
lista = []

# Lista llena de números
lista = [1,2,3,4,5]

Las listas son colecciones de datos enlazados. Una lista puede estar vacía, o contener una cabeza head y una cola tail. Es decir que una lista no vacía, estará compuesta por el primer elemento de la lista (head) y el resto de elementos de la lista (tail). 

[head|tail] = [1,2,3,4,5,6]
IO.puts "Head: #{head}"
IO.puts "Tail: #{tail}"

Tuplas

Las tuplas son colecciones valores que pueden ser de distinto tipo. Normalmente tienen entre dos y cuatro valores, ya que hay otros tipos de colecciones mejor preparadas para trabajar con más datos. Las tuplas se definen entre llaves {} .

tupla = {1,:ok,:hello,true, 65,[1,2,3],false,"ABC"}

Listas clave-valor

Básicamente una variante de la lista, solo que con llave-valor.

# listas clave-valor
lista_llave_valor = [nombre: "John Erlang", blog: "alquimista", url: "alquimistadecodigo.com"]

¿Qué pasa con los Mapas?

Los mapas son también colecciones de elementos clave-valor, pero se definen de forma diferente.

# Mapa en Elixir
mapa = %{:ok => 1, :hello => 2, :a => 3}
IO.puts mapa.ok # 1
IO.puts mapa.a # 3

Links:
http://agrega.juntadeandalucia.es/repositorio/02122016/a5/es-an_2016120212_9131705/33_listas.html
https://charlascylon.com/2016-03-21-tipos-colecciones-Elixir

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

Katas en programación (un solo programa en distintos lenguajes)

 

En este post crearemos un mismo programa usando lenguajes como Java, Elixir, Erlang, Javscript, Perl, Python y otros más.

Ejercicio. Crear tres funciones:

• Función 1 para calcular  1.8 * numero, donde numero es la variable con el valor que introduce el usuario.
• Función 2 para calcular 1000 + (x + y), donde x & y son las variables que contendrán los valores que introducirá el usuario.
• Función 3 para calcular la suma de x+y+z

Código en Perl

 funciones.pl

#!/usr/bin/perl

use strict;
use warnings;
use constant MAX => 1000;
use constant VALOR => 1.8;

my($x,$y,$z);

$x=3;
$y=2;
$z=4;

print "Datos:\nx=",$x,", y=",$y,", z=",$z,"\n";


sub func1{
  return VALOR * $_[0];
}

sub func2{
  return MAX +($_[0]+$_[1]);
}

sub func3{
  return $_[0]+$_[1]+$_[2];
}

print "Resultado 1: ",func1($x),"\n";
print "Resultado 2: ",func2($y,$z),"\n";
print "Resultado 3: ",func3($x,$y,$z),"\n";

 

Código en Erlang

funciones.erl

-module(funciones).
-author("Codemonkey Junior").
-version("1.0.0").
-export([func1/1,func2/2,func3/3]).
-define(MAX,1000).
-define(VALOR,1.8).

func1(X)-> X*?VALOR.

func2(X,Y)-> ?MAX +(X+Y).

func3(X,Y,Z)-> X+Y+Z. 

Funcionando:

1> c(funciones).
{ok,funciones}
2> funciones:func1(3).
5.4
3> funciones:func2(3,9).
1012
4> funciones:func3(3,9,9).
21
5> 

Código en Elixir

funciones.exs

defmodule Constante do
  def mMAX, do: 1000
  def mVALOR, do: 1.8
end


x=2
y=4
z=5

IO.puts "Datos:\n x= #{x}, y= #{y}, z= #{z}"

func1 = fn (num) -> Constante.mVALOR*num end
func2 = fn (a,b) -> Constante.mMAX+(a+b) end
func3 = fn (a,b,c) -> a+b+c end

result1 = func1.(x)
result2 = func2.(z,y)
result3 = func3.(x,y,z)

IO.puts "Resultado 1: #{result1}"
IO.puts "Resultado 2: #{result2}"
IO.puts "Resultado 3: #{result3}"

 

Código en C#

Funciones.cs

using System;
        
public class Funciones
{

  public static readonly int MAX = 1000;
  public static readonly double VALOR = 1.8;


  public static double Func1(int num)
  {
    return VALOR * num;
  }

  public static int Func2(int x, int y)
  {
    return MAX +(x+y);
  }

  public static int Func3(int x, int y, int z)
  {
    return x+y+z;
  }

  public static void Main()
  {
    Console.WriteLine("Resultado 1: {0}",Func1(3));
    Console.WriteLine("Resultado 2: {0}",Func2(4,7));
  }

}

 

Código en C

funciones.c

#include<stdio.h>
#define VALOR 1.8
#define MAX 1000

int func1(int);
int func2(int,int);
int func3(int,int,int);


int func1(int num){
  return VALOR*num;
}

int func2(int x,int y){
  return MAX +(x+y);
}

int func3(int a,int b,int c){
  return a+b+c;
}

int main(int argc, char *argv[]){
  printf("Resultado 1:%d\n",func2(4,3));
  printf("Resultado 2:%d\n",func1(2));
  printf("Resultado 3:%d\n",func3(2,5,6));
  return 0;
}

Enlaces:

https://es.wikipedia.org/wiki/Kata_(programaci%C3%B3n)