Erlang en ejemplos 2

Para quienes han tenido que documentar su código saben que es un proceso que puede llevar más tiempo que el necesario. En lenguajes como Java contamos con el famoso Javadoc, una herramienta que permite la documentación de nuestro código.

package ejemplos;

/**
* <h1>Main.java</h1>
* @author Codemonkey Junior
* @version 1.0.0
* @see http://codemonkeyjunior.blogspot.com
* 
*/

import static java.lang.System.out;

public class Main{
  /**
  *
  *@param args
  * 
  */
  public static void main(String[] args){
     out.println("Hola, mundo en Java");
  }
}

En este ejemplo podemos ver el uso de etiquetas especiales que nos ayudan describir partes del código que pudieran ser importantes. Como dice una regla no escrita en el mundo de la programación:

Pasamos más tiempo viendo el código de otros, que escribiendo nuevo código

Y que mejor si este código está documentado. En Erlang también existen etiquetas similares al Javadoc de Java. En este ejemplo podemos ver el uso de estás etiquetas.

%%% @doc Programa para conversion de temperaturas
%%% @copyright Inforhomex 2021
-module(conversion).
-author("Codemonkey Junior").
-version("1.0.0").
-export([fahr/1, cels/1]).

%% @doc De Celsius a Fahrenheit
-spec fahr(number()) -> number().
fahr(C) -> (C-32)/1.8.


%% @doc De Fahrenheit a Celsius
-spec cels(number()) -> number().
cels(F) -> (F*1.8)+32.

%% @end

%% erl
%% > c(conversion).
%% > conversion:fahr(-32.8).
%% > conversion:cels(22.9).

Hay un post en Stackoverflow que podría ser muy útil para saber más sobre la documentación de código en Erlang: https://stackoverflow.com/questions/9378765/specifications-for-functions-spec-efficiently-usage En próximos post hablaremos más de este lenguaje.

Enlaces:
http://codemonkeyjunior.blogspot.com/2021/05/erlang-en-ejemplos.html
https://codemonkeyjunior.blogspot.com/2021/05/erlang-modulos.html
https://zxq9.com/projects/zomp/
https://zxq9.com/archives/1650 https://learnyousomeerlang.com/

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/

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.
Enlaces:
https://hexdocs.pm/elixir/String.html

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 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 crear 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

Erlang: módulos

Un módulo es, básicamente, una parte autónoma de un programa. Se puede sonsiderar un miniprograma que puede puede ser llamado por otro programa y/o programas.
Ejemplo 1. Crear un módulo que calcule el triple de un número.
mi_modulo.erl

% Módulo para obtener el triple de un número
-module(mi_modulo).
-export([triple/1]).

triple(X) ->
    3 * X.

% Abrimos la terminal y escribimos:
% erl
% c(mi_modulo).
% mi_modulo:triple(3). % 9
% Triple = mi_modulo:triple(9). % 27

Donde:

-module(mi_modulo).

Nos sirve para definir el módulo(programa) que será cargado.

-export([triple/1]).

Nos sirve para exportar la función. Es importante definir el número de parámetros. En este caso la función solo emplea uno:

> mi_modulo:triple(3). % 9

Ejemplo 2. Crear dos funciones para sumar y restar dos números.

-module(modulos).
-export([suma/2, resta/2]).

suma(X, Y)->
    X + Y.

resta(X, Y)->
    X - Y.

% erl
% > c(modulos).
% > modulos:suma(3,4). % 7
% > modulos:resta(7,4). % 3

Observando el código, podemos exportar más de una función.

-export([suma/2, resta/2]).

Enlaces:
https://blog.guille.dev/2019/08/aprendiendo-un-nuevo-lenguaje-erlang.html
https://www.histel.com/z_histel/biografias.php?id_nombre=46

Erlang: BEAM

En post pasados ya hemos hablado sobre Erlang, pero en esta ocasión trataremos de la máquina virtual de Erlang.

BEAM es la máquina virtual en el núcleo de Erlang Open Telecom Platform (OTP). BEAM es parte del Erlang Run-Time System (ERTS), que compila el código fuente de Erlang y Elixir en código de bytes, que luego se ejecuta en el BEAM. Los archivos de código de bytes BEAM tienen la extensión de archivo .beam. Para los programadores Java, es el equivalente de la JVM.

En Stackoverflow hay una respuesta que nos puede servir para entender qué es BEAM:

La máquina virtual Erlang se ejecuta como un proceso de sistema operativo. De forma predeterminada, ejecuta un subproceso del sistema operativo por núcleo para lograr la máxima utilización de la máquina. La cantidad de subprocesos y en qué núcleos se ejecutan se puede establecer cuando se inicia la máquina virtual. Los procesos de Erlang son implementados en su totalidad por Erlang VM y no tienen conexión ni con los procesos ni con los subprocesos del sistema operativo. Entonces, incluso si está ejecutando un sistema Erlang de más de un millón de procesos, todavía es solo un proceso de SO y un hilo por núcleo. Entonces, en este sentido, Erlang VM es una "máquina virtual de proceso", mientras que el propio sistema Erlang se comporta como un SO y los procesos Erlang tienen propiedades muy similares a los procesos del SO, por ejemplo, el aislamiento. En realidad, hay una máquina virtual Erlang, basada en BEAM, que se ejecuta en bare metal y, de hecho, es un sistema operativo por derecho propio, consulte Erlang en Xen. Por cierto, es perfectamente posible tener sistemas que ejecuten millones de procesos Erlang y de hecho se hace en algunos productos, por ejemplo WhatsApp. Definitivamente estábamos pensando mucho en los sistemas operativos cuando diseñamos el entorno básico de Erlang.

El concepto de Máquina Virtual nos puede aclarar más las cosas:

...una máquina virtual es un software que simula un sistema de computación y puede ejecutar programas como si fuese una computadora real. Este software en un principio fue definido como "un duplicado eficiente y aislado de una máquina física". La acepción del término actualmente incluye a máquinas virtuales que no tienen ninguna equivalencia directa con ningún hardware real. Una característica esencial de las máquinas virtuales es que los procesos que ejecutan están limitados por los recursos y abstracciones proporcionados por ellas. Estos procesos no pueden escaparse de esta "computadora virtual".

En próximos posts hablaremos más de esto.

Enlaces:
https://blog.erlang.org/a-brief-BEAM-primer/
https://stackoverflow.com/questions/16779162/what-kind-of-virtual-machine-is-beam-the-erlang-vm
https://github.com/AlexanderKaraberov/Erlang-BEAM-Links

Erlang: conociendo el shell

Erlang es un lenguaje de programación funcional que posee ciertas características especiales (como cualquier otro lenguaje se digne de serlo). Fue desarrollado pensando en la concurrencia y ser tolerante a fallos. Permitir ser actualizado "en caliente", lo cual  muchos otros lenguajes no pueden presumir. Además esta pensado en trabajar a la par con otros programas, no importando si están en otras máquinas o servidores. 

Para entrar al shell (o repl) de Erlang debes abrir una terminal y teclear la palabra erl.

$ erl

Con esto abrirás el shell de Erlang. Y comenzamos a probar...

> "Esto es una cadena". 
> true.
> false.
> 34 + 65.
> 22 > 11.
> X = 10.
> Str = "Hola, mundo".

Como se puede ver

• Al final de una sentencia debes poner un punto.
• Las variables deben comenzar con una mayúscula.
  

Hay dos maneras de ejecutar un programa en Erlang:

1era forma
holamundo.erl

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

start() ->
    io:fwrite("Hola, mundo en Erlang\n").


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

Desde la terminal ejecutamos estos comandos:

$ erlc holamundo.erl
$ erl -noshell -s holamundo start -s init stop

2da forma
Desde el shell (repl) de Erlang:

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

Para salir del shell debes escribir el comando q().

Conociendo el esqueleto de un programa en Erlang.

%% Esto es un comentario

% Se específica el programa
-module(programa).

% Se exporta la función del programa y el no. de parámetros
-export([start/0]).

% Esto sirve para dar crédito al autor del programa
-author("Codemonkey Junior").

% La versión del programa
-version("1.0.0").

% Nos sirve para exporta más funciones, sin tener que usar -export por c/u de estas
-compile(export_all).

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

% Importar una función y el no. de parámetros que necesita
-import(io, [fwrite/1]). 

% Para la documentación del programa
-spec start() -> any().
start()->
   fwrite("\t [ ***** Fundamentos en Erlang *** ]").

 

Enlaces:
https://es.wikipedia.org/wiki/Erlang
http://jungerl.sourceforge.net/
https://www.erlang-solutions.com/
https://emanuelpeg.blogspot.com/search?q=erlang

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/