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.
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
Bash es básicamente un lenguaje de programación y scripting. El cual nos permite crear sencillas rutinas como listar directorios, crear archivos y/o directorios, mostrar el calendario, fecha actual y otras cosas más complejas como crear usuarios, eliminarlos, actualiar sus passwords o incluso ejecutar tareas automáticas sin necesidad de ejecución manual.
En este post hablaremos un poco de deste lenguaje y mostraremos algunos ejemplos.
holamundo.sh
#!/bin/bash nombre="Codemonkey Junior" echo Hola, $nombre
El clásico programa de Hola, mundo. Como se puede obserar la extensión es .sh. Para poder ejecutarlo es preciso antes dar permisos de ejecución. Esto se puede de la siguiente manera:
$ sudo chmod +x holamundo.sh
Ejecutar:
$ ./holamundo.sh
Salida:
Hola, Codemonkey Junior
En el siguiente ejemplo veremos:
variables.sh
#!/bin/bash # Comentarios multilínea << 'MULTILINE-COMMENT' FUNDAMENTOS DE PROGRAMACION EN BASH SHELL MULTILINE-COMMENT # Limpiamos terminal clear # Definimos variables tipo Caracter, Entero, Booleano y del sistema nombre="codemonkey Junior" entero=34 booleano=true flotante=9.83 fecha=`date` directorio=`pwd` # Mostramos en pantalla el valor de las variables echo "[Variables en Linux]" echo "Hola, ${nombre}" echo "Entero = ${entero}" echo "Flotante = ${flotante}"
# Comprobamos si una variable es NULLif $booleano; then echo "Es verdadero: ${booleano}"; else echo "Es falso: ${booleano}"; fi echo "Fecha de hoy es: ${fecha}" echo "Estamos en el directorio: ${directorio}" echo "El nombre del archivo es: $0" # Realizamos algunas operaciones aritméticas let num1=21 let num2=1 let suma=${num1}+${num2} echo "num1=${num1}, num2=${num2}" echo "Suma = ${suma}"
Otorgar permisos de ejecución:
$ sudo chmod +x variables.sh
Ejecutar:
$ ./variables.sh
En el siguiente ejemplo veremos como realizar operaciones aritméticas básicas: suma, resta, multiplicación, división y residuo(%).
operaciones.sh
#!/bin/bash # Definimos las variables y su valor let a=20 let b=5 # Operaciones aritméticas let suma=$(expr ${a} + ${b}) let resta=$(expr ${a} - ${b}) let producto=`expr $a \* $b` let division=$(expr ${a} / ${b}) echo "[Operaciones aritmeticas]" echo "a = ${a}, b = ${b}" echo "Suma = ${suma}" echo "Resta = ${resta}" echo "Producto = ${producto}" echo "Division = ${division}" let c=220 let d=200 let residuo=$(expr ${c} % ${d}) echo "c = ${c}, d = ${d}" echo "Residuo = ${residuo}"
Otorgar permisos de ejecución:
$ sudo chmod +x operaciones.sh
Ejecutar:
$ ./operaciones.sh
En este ejemplo veremos como obtener la longitud de las variables declaradas.
longitud.sh
#!/bin/bash nombre='ABC' echo "Cadena = ${nombre}" # La longitud debe ser de 3 echo La longitud de la variable es: ${#nombre} numero=4953 echo "Numero = ${numero}" # La longitud debe ser de 4 echo La longitud de la variable es: ${#numero} booleano=true echo "Booleano = ${booleano}" # En este la longitud será de 4, se cuenta cada una de las letras como si fuera un string echo La longitud de la variable es: ${#booleano}
Otorgar permisos de ejecución:
$ sudo chmod +x longitud.sh
Ejecutar:
$ ./longitud.sh
En este ejemplo mostraremos el uso de comandos como whoami, pwd y variables del sistema.
usuario.sh
#!/bin/bash << 'MULTILINE-COMMENT' FUNDAMENTOS DE PROGRAMACION EN BASH SHELL MULTILINE-COMMENT clear # Algunos comandos y variables de Linux quien=`whoami` donde=`pwd` mishell=$SHELL echo "Quien soy?: ${quien}" echo "Donde estoy?: ${donde}" echo "El home es: ${HOME}" echo "El usuario es: ${USER}" echo "El shell esta en: ${mishell}"
Otorgar permisos de ejecución:
$ sudo chmod +x usuario.sh
Ejecutar:
$ ./usuario.sh
En próximos post veremos más ejemplos.
Enlaces:
https://www.reiser.cl/bash-manejo-de-cadenas-de-texto/ https://linuxhint.com/variables_bash/ https://linuxize.com/post/bash-comments/ https://www.cyberciti.biz/faq/bash-shell-find-out-if-a-variable-has-null-value-or-not/ https://linuxhint.com/use-boolean-value-in-bash/ https://ryanstutorials.net/bash-scripting-tutorial/bash-arithmetic.php
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:
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/
Ejercicio. Crear tres funciones:
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}"
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)Traducción:
Este episodio es un tutorial simple que demuestra lo fácil que es comenzar a usar Phoenix.
En él, crearemos una aplicación de blog simple con publicaciones. Ver más en https://elixircasts.io
Enlaces:
https://elixircasts.io
Katas propuestas
1. Crear un programa que convierta pulgadas a centímetros y viceversa.
2. Crear un programa que convierta grados celsius a fahrenheit y viceversa.
3. Crear un programa que sume únicamente los números pares de una lista cualquiera.
4. Si enumeramos todos los números naturales debajo de 10 que son múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Encuentra la suma de todos los múltiplos de 3 o 5 por debajo de 1000.
Nota: Este último ejemplo viene de la página de Project Euler
Recordando...
Los tipos de programación se pueden dividir en:
1. Programación Imperativa: Donde se describen, paso a paso, las instrucciones necesarias para resolver el problema.
2. Programación Declarativa: Donde se describe el problema que tenemos que solucionar pero no el cómo hacerlo.
conversiones.erl
%% Operaciones con Erlang -module(conversiones). -author("Codemonkey Junior"). -export([cent/1,pulg/1]). -compile(nowarn_export_all). pulg(N)-> N/2.54. cent(N)-> N*2.54.
Salida:
$ erl > conversiones:pulg(4). 1.574803149606299 > conversiones:cent(1.574803149606299). 3.9999999999999996
conversion_grados.erl
%% Operaciones con Erlang -module(conversion_grados). -author("Codemonkey Junior"). -export([fahr/1,cels/1]). -compile(nowarn_export_all). % De Celsius a Fahrenheit fahr(N)-> (1.8*N)+32. % De Fahrenheit a Celsius cels(N)-> (N-32)/1.8.
Salida:
$ erl > c(conversion_grados). > conversion_grados:fahr(34.8). 94.64 > conversion_grados:cels(94.64). 34.8
Tip: Para obtener más información de un módulo podemos teclear:
$ erl > c(programa). > programa:module_info().
Donde la función module_info() nos lista la información del programa o módulo.
$ erl > c(programa). > programa:module_info(). [{module,programa}, {exports,[{start,0}, {suma,2}, {resta,2}, {fahr,1}, {cels,1}, {factorial,1}, {combinatorio,2}, {pulg,1}, {cent,1}, {mcd,2}, {module_info,0}, {module_info,1}]}, {attributes,[{vsn,[276758998827383991874529587796040092315]}, {author,"Codemonkey Junior"}]}, {compile,[{version,"8.1"}, {options,[]}, {source,"/home/codemonkey/Documentos/pruebasErlang/programa.erl"}]}, {md5,<<208,53,216,37,125,14,40,139,135,22,83,244,140,34, 10,155>>}]
suma_multiplos.erl
Este programa se verá en el siguiente post.
Enlaces:
https://projecteuler.net/archives
https://erlangbyexample.org
https://learnyousomeerlang.com
En el anterior post realizamos algunos ejercicios de programación en C. En ésta ocasión continuaremos con los ejercicios.
Ejemplo 1. Obtener el número binario de un número decimal mayor a cero.
binario.c
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<ctype.h> #define MAX 100 int main(int argc, char *argv[]){ char binario[MAX]; int decimal; int residuo; char c; do{ puts("Introduce numero decimal:"); scanf("%d",&decimal); }while(decimal <= 0); printf("Decimal: %d\n",decimal); while(decimal >= 2){ residuo = decimal % 2; decimal = (int) decimal/2; c = (char)residuo+'0'; strcat(binario, &c); } c = (char)decimal+'0'; strcat(binario, &c); char binarioFinal[MAX]; int i, j,k; for(i=0; binario[i] != '\0'; i++ ); j=i-1; for(k=0; k<=i; k++){ binarioFinal[k]=binario[j]; j--; } printf("Binario final:%s\n",binarioFinal); return 0; }
En éste ejemplo podemos ver la descomposición de un número decimal a su forma binaria (0,1). Obtenemos el residuo de la división (%) y lo vamos almacenando en una cadena string, incluimos el último dígito decimal, para al final mostrar la cadena final (en reversa). Ej. Si el número introducido es 3 deberá mostrar su equivalente en binario que sería: 11.
Compilamos y creamos el ejecutable.
$ gcc binario.c -o ejecutable.exe $ ./ejecutable.exe
Ejemplo 2. Crear un programa que tome dos números enteros mayores a cero que realice las seis operaciones básicas de la aritmética: suma, resta, multiplicación(producto) , división, potenciación y radicación.
matematicas.c
#include<stdio.h> #include<stdlib.h> #include<ctype.h> #include<math.h> int suma(int,int); int resta(int,int); int producto(int,int); double division(int,int); double potencia(double, int); int radicacion(int); int suma(int a, int b){ return a+b; } int resta(int a, int b){ return a-b; } int producto(int a, int b){ return a*b; } double division(int a,int b){ return (double) a/b; } double potencia(double b, int p){ int i = 1; double pot = 1.0; while(i <= p){ pot = pot * b; i++; } return pot; } int radicacion(int a){ return sqrt((double) a); } int main(int argc, char *argv[]){ int a = 0, b = 0, mySuma = 0, myResta = 0, myProd = 0; double myDiv = 0.0, myPot = 0.0; do{ system("clear"); puts("Introduce dos numeros enteros mayor a cero:"); printf("a = %d y b = %d\n",a,b); scanf("%d %d",&a,&b); }while(a <= 0 || b <= 0); printf("Numeros introducidos: a=%d y b=%d\n",a,b); mySuma = suma(a,b); myResta = resta(a,b); myProd = producto(a,b); myDiv = division(a,b); myPot = potencia((double) a,b); printf("Suma = %d\n",mySuma); printf("Resta = %d\n",myResta); printf("Producto = %d\n",myProd); printf("Division = %.3lf\n",myDiv); printf("Potencia = %.0lf\n",myPot); printf("Raiz de a = %d es: %d\n",a, radicacion(a)); printf("Raiz de b = %d es: %d\n",b, radicacion(b)); return 0; }
Creamos seis cabeceras y sus implementaciones (funciones) para realizar las operaciones aritméticas básicas. Obligamos a introducir dos número enteros positivos. Si algún número es cero el bucle do-while continuará hasta que los dos números sean mayores a cero.
Para poder compilar y crear el ejecutable (esto si usas GCC):
$ cc matematicas.c -lm -o ejecutable.exe
Ejemplo 3. Crear un programa que tome tres parámetros, dos decimales y un operador (+, -, x, / , %) para realizar las operaciones de: suma, resta, producto, división y resto/residuo.
operador.c
#include<stdio.h> #include<ctype.h> #include<curses.h> #include<string.h> #include<stdlib.h> int operacion(int, int, char); int operacion(int a, int b, char opc){ int resultado = 0; if(opc == '+'){ puts("\tSuma"); resultado = a+b; } if(opc == '-'){ puts("\tResta"); resultado = a-b; } if(opc =='x'){ puts("\tProducto"); resultado = a*b; } if(opc == '/'){ puts("\tDivision"); if(b <= 0){ resultado = a; }else{ resultado = a/b; } } if(opc == '%'){ puts("\tResiduo"); resultado = a%b; } return resultado; } int main(int argc, char *argv[]){ if(argc >= 3){ int a = atoi(argv[1]); int b = atoi(argv[2]); char c = argv[3][0]; // tomar el primer caracter de la fila 3, columna 0 printf("Entrada \t a = %d b = %d , operador: %c\n",a,b,c); printf("Resultado: %d\n",operacion(a,b,c)); }else{ puts("\tDebes introducir tres argumentos: num1 num2 operador\n"); } return 0; }
Compilar y ejecutar:
$ gcc operador.c -o ejecutable.exe $ ./ejecutable.exe 2 3 + Suma Resultado: 5
Enlaces:
http://codemonkeyjunior.blogspot.com/2021/08/vale-la-pena-aprender-c-y-o-c.html