ERLANG – Concurrencia en toda su expresión

Saludos, en esta ocasión quiero hablarles de ERLANG.

¿ Pero que es ERLANG ? 

Es un lenguaje de programación utilizado para construir sistemas en tiempo real masivamente escalables y con requisitos de alta disponibilidad. Algunos de sus usos son las telecomunicaciones, bancos, comercio electrónico, telefonía, informática y la mensajería instantánea. Dicho de otra manera es un lenguaje de programación concurrente u orientado a la concurrencia  cuenta con un sistema de ejecución que incluye una máquina virtual (BEAM) y bibliotecas (OTP).

¿ Que es OTP ?

OTP es un conjunto de librerías Erlang y principios de diseño que ofrecen middleware para desarrollar estos sistemas. Incluye su base de datos distribuida propia, aplicaciones para la interfaz hacia otros idiomas, depuración y herramientas de manejo de liberación.

Erlang es Open Source

Erlang es un lenguaje de programación diseñado en el Laboratorio de Ciencias Computacionales Ericsson. Es de Código abierto Erlang se publica para ayudar a fomentar la propagación de Erlang al exterior de Ericsson. Se ha lanzando de forma gratuita: El código fuente de todo el sistema actual de Erlang. Amplias bibliotecas de código para la construcción de aplicaciones distribuidas con tolerancia a errores robustos. Todos con la documentación. Todo el software anterior ha sido probado en combate en un número de productos de Ericsson, por ejemplo AXD301 (conmutador ATM).

Licencia

Erlang Public License (EPL). EPL es una obra derivada de la Licencia Pública de Mozilla (MPL). Contiene términos que difieren de MPL, principalmente en términos de jurisdicción. La licencia está construida de acuerdo con las leyes de Suecia. EPL texto traducción Un objeto ayudar a entender el texto legal. El texto legal es la licencia, por lo que si usted tiene alguna duda, consulte el texto legal.

Comercial

Hay una serie de productos disponibles que pueden ser de interés para los programadores profesionales y aficionados de Erlang (documentación impresa, cursos, etc).

La creación, gestión y comunicación de procesos es sencilla en Erlang, mientras que en muchos lenguajes, los hilos se consideran un apartado complicado y propenso a errores. En Erlang toda concurrencia es explícita.

Erlang recibe el nombre de A. K. Erlang. A veces se piensa que el nombre es una abreviación de ERicsson LANGuage, debido a su uso intensivo en Ericsson. Según Bjarne Däcker -quien fue el jefe del Computer Science Lab en su día-, esta dualidad es intencional.

A continuación un pequeño ejemplo :

Un cliente telnet simple

%%
%% getty.erl
%%
%% Author: Sebastian Strollo [[email protected]]
%%
-module(getty).

-export([start/0, start/1, start/2]).

-export([init/2, l/2]).

%%
%% Interface: start( Port , {Mod, Fun} )
%%
%% Starts a "getty" process that listens on TCP port Port, and spawns
%% {Mod, Fun, [self()]} after accepting a connection on that port.
%%
start(PortNo, MF) ->
    spawn(?MODULE, init, [PortNo, MF]).

%%
%% Defaults - start {user, server} on port 7788
%%
start() ->
    start(7788).

start(PortNo) when integer(PortNo) ->
    start(PortNo, {user, server}).


%% ----------------------------------------------------------------------

init(PortNo, MF) ->
    process_flag(trap_exit, true),
    {ok, LS} = gen_tcp:listen(PortNo, [{reuseaddr, true}, {packet, 0},
				       {active, false}]),
    g_loop(LS, MF).

%%
%% Main loop
%%
g_loop(S, MF) ->
    {ok, NS} = gen_tcp:accept(S),		% accept new connection
    Pid = spawn(?MODULE, l, [NS, MF]),		% start a child
    gen_tcp:controlling_process(NS, Pid),	% give child the socket
    Pid ! go_ahead,				% synchronize with child
    g_loop(S, MF).

%% ----------------------------------------------------------------------

l(S, {UMod, UFun}) ->
    process_flag(trap_exit, true),
    receive
	go_ahead ->				% wait for synchronization,
	    inet:setopts(S, [{active, true}])	% before we activate socket
    end,

    gen_tcp:send(S, "\nWelcome to Erlang!\n\n"), % could implement login here
    
    U = spawn_link(UMod, UFun, [self()]),	% start user process
    ll(S, U).

%%
%% Child loop, passes the data between the user process and the socket.
%%
ll(S, U) ->
    receive
	{tcp, S, Bytes} ->
	    U ! {self(), {data, Bytes}},
	    ll(S, U);
	
	{tcp_closed, S} ->
	    io:format("getty:ll(~p, ~p) socket closed~n", [S, U]),
	    exit(closed);
	
	{tcp_error, S, Reason} ->
	    io:format("getty:ll(~p, ~p) socket error ~p~n", [S, U, Reason]),
	    exit(Reason);
	
	{U, {command, Bytes}} ->
	    gen_tcp:send(S, Bytes),
	    ll(S, U);
	
	{'EXIT', U, Why} ->
	    io:format("getty:ll(~p, ~p) user died ~p~n", [S, U, Why]),
	    gen_tcp:close(S),
	    exit(Why);
	
	Other ->
	    io:format("getty:ll(~p, ~p) got msg ~p~n", [S, U, Other]),
	    ll(S, U)
    end.

Mas información en: http://www.erlang.org/