Erlang
Ficha Software
| ||||||||||||
Resumen
Erlang es un lenguaje de programación funcional de alto nivel, que se ubica también dentro del paradigma de Programación Declarativa, diseñado para escribir aplicaciones concurrentes y distribuidas de funcionamiento ininterrumpido. Erlang usa procesos concurrentes para estructurar la aplicación. Estos procesos no comparten memoria y se comunican de forma asincrónica mediante el paso de mensajes. Los procesos Erlang son muy ligeros y pertenecen al propio lenguaje, no al sistema operativo. Erlang posee un mecanismo para cambiar el código fuente de un programa o aplicación al vuelo, sin tener que detener el programa. Este mecanismo facilita la implementación de sistemas indetenibles.
Historia
Los inicios de Erlang toman lugar en los años 80 en los laboratorios de Ciencias de Computación de la Compañía de telefonía sueca Ericsson, como un intento de desarrollar un lenguaje de programación de alto nivel, y con capacidad para afrontar el tipo de proyectos, especialmente de Telecomunicaciones, que la empresa estaba desarrollando y que optimizara el uso de la tecnología emergente en Microelectrónica, especialmente en Microinformática. Para el diseño de Erlang se analizaron al rededor de 300 lenguajes de programación existentes, con el fin de buscar características sobre lo que deseaba la empresa, de estos lenguajes se seleccionaron: Lisp, Haskell, Prolog, y otros, de los cuales se tomaron las características más relevantes.
Características
Entre sus características más relevantes se encuentran:
Lenguaje de alto nivel basado en procesos
Gran parte del código luce así:
% Ejecuta la función loop() como un nuevo proceso y guarda el id del proceso en ‘Pid’.
Pid = spawn(fun()-> loop() end),
% Envía un mensaje al proceso apuntado por ‘Pid’.
Pid ! “Hola Mundo en Erlang!”.
% Cuerpo de la función loop().
loop()->
% Recibe el mensaje enviado al proceso.
receive Msg->
io:format("~p", [Msg]) % Imprime el mensaje en la consola.
end.
Acoplamiento de patrones (Pattern-Matching)
El acoplamiento de patrones es una técnica básica de Erlang con la cual es posible hacer un balance entre las variables y valores a los dos lados del signo de igualdad o fallar si no es posible hacer un balance. Al lado izquierdo se le denomina lado de las variables y valores y al lado derecho lado de los valores.
% Obtiene, en la variable 'Cual', el tercer valor sin importar cuales son los dos primeros.
{_, _, Cual} = {perro, gato, vaca}.
% Obtiene, en la variable 'Cual', el tercer valor garantizando que el primero sea ‘perro’ y sin importar cuál es el segundo.
{perro, _, Cual} = {perro, gato, vaca}.
Organización de memoria automática (Recolector de Basura)
Erlang posee al igual que .Net y Java un mecanismo de limpieza de la memoria que permite al programador olvidarse de manejar la destrucción de las variables una vez creadas y fuera de contexto. Este mecanismo se encarga automáticamente de destruir todos los objetos y procesos que ya no se estén utilizando ya sea porque están fuera de contexto o porque muere su objeto o proceso padre.
Lenguaje funcional
El código de programa se estructura en módulos que contienen funciones:
-module(math). -export([factorial/1]). factorial(0) -> 1; factorial(N) when N > 0 -> N * factorial(N-1).
Función QuickSort, ordena una lista de elementos:
-module(list).
-export([quick_sort/1]).
quick_sort([])-> [];
quick_sort([Pivot|Rest])->
quick_sort[X || X <- Rest, X < Pivot])
++ [Pivot] ++
quick_sort[Y || Y <- Rest, Y >= Pivot].
Evaluación estricta, asignación única y tipado dinámico
Sólo se cumple uno de los casos por ejecución de la función pintar(), (evaluación estricta).
pintar(Color)->
case Color of
“rojo”->
pintar_de_rojo;
4->
pintar_de_rojo;
“amarillo”->
pintar_de_amarillo;
6->
pintar_de_amarillo
end.
La variable Color puede tomar el tipo de datos dinámicamente, puede adquirir un valor numérico o un valor alfanumérico (cadena de caracteres) especificando el color, (tipado dinámico).
La asignación única viene dada por que no se puede asignar un valor a una variable mas de una vez, ejemplo:
Si dentro del mismo contexto hacemos:
A = 5 % Válido. A = 6 % No válido.
Cosas como estas, que son válidas dentro de la Programación Imperativa, no lo son dentro de la programación declarativa funcional.
A = A + 1 % No válido.
Una vez que una variable obtiene un valor, no puede ser modificado, si se desea incrementar el valor de una variable en cierto valor se hace B = A + 1, si y sólo si, la variable B nunca ha sido asignada (unbound) y la variable A ya ha sido previamente asignada (bound). Esta regla permite evitar los efectos colaterales de la concurrencia, donde al acceder varios procesos a un mismo recurso pueda darse el caso de que se corrompa la información.
Listas por comprensión
Las listas por compresión de Erlang es un mecanismo matemático que permite generar valores a partir de una sintaxis muy elegante y simple:
[Constructor || Generador, [Filtros...], Generador, [Filtros...]...].
Ejemplo:
[X * 2 || X <-[1,2,3,4]].
Esto retorna el doble de todos los elementos de la lista [1,2,3,4].
Una lista por comprensión puede definirse como las Xs tales que las Xs que salgan de la lista L cumplan tal condición.
Ejemplo:
[X || X <-L, X > 4].
Cada generador trae sus propios filtros, por lo tanto es válido escribir:
[{X, Y} || X <-[1,2,3,4], X > 2, Y <-[4,5,6,7], Y < 5].
Algo interesante utilizando las listas por comprensión puede ser el cálculo del trío pitagórico:
pythag(N)->
[{A,B,C} ||
A <-lists:seq(1,N),
B <-lists:seq(1,N),
C <-lists:seq(1,N),
A + B + C =< N,
A*A + B*B =:= C*C].
Esto genera todos los tríos de números desde 1 hasta N que cumplen con el teorema de Pitágoras y que la suma de los tres no excede a N, son los llamados números "pitagóricos".
Esto puede leerse como: todos los números {A, B, C} donde A es de 1 a N, B es de 1 a N, C es de 1 a N, cumplan que A + B + C =< N y además que A*A + B*B = C*C.
NOTA: EN EDICION
