Erlang ( / ˈ ɜːr l æ ŋ / UR -lang ) es un lenguaje de programación de alto nivel funcional , concurrente y de propósito general , y un sistema de ejecución con recolección de basura . El término Erlang se usa indistintamente con Erlang/OTP, o Open Telecom Platform (OTP), que consta del sistema de ejecución de Erlang , varios componentes listos para usar (OTP) escritos principalmente en Erlang y un conjunto de principios de diseño para Erlang. programas. [5]
El sistema de ejecución de Erlang está diseñado para sistemas con estas características:
El lenguaje de programación Erlang tiene datos inmutables , coincidencia de patrones y programación funcional . [7] El subconjunto secuencial del lenguaje Erlang admite evaluación entusiasta , asignación única y escritura dinámica .
Una aplicación Erlang normal se construye a partir de cientos de pequeños procesos Erlang.
Originalmente era software propietario de Ericsson , desarrollado por Joe Armstrong , Robert Virding y Mike Williams en 1986, [8] pero se lanzó como software gratuito y de código abierto en 1998. [9] [10] Erlang/OTP es compatible y mantenido por la unidad de productos Open Telecom Platform (OTP) de Ericsson .
Quienes trabajan en los conmutadores telefónicos (para quienes se diseñó el idioma) han supuesto que el nombre Erlang , atribuido a Bjarne Däcker, es una referencia al matemático e ingeniero danés Agner Krarup Erlang y una abreviatura silábica de "Ericsson Language". [8] [11] [12] Erlang fue diseñado con el objetivo de mejorar el desarrollo de aplicaciones de telefonía. [13] La versión inicial de Erlang se implementó en Prolog y fue influenciada por el lenguaje de programación PLEX utilizado en intercambios anteriores de Ericsson. En 1988, Erlang había demostrado que era adecuado para la creación de prototipos de centrales telefónicas, pero el intérprete Prolog era demasiado lento. Un grupo de Ericsson estimó que tendría que ser 40 veces más rápido para que fuera adecuado para uso en producción. En 1992, se comenzó a trabajar en la máquina virtual (VM) BEAM que compila Erlang en C utilizando una combinación de código compilado de forma nativa y código subproceso para lograr un equilibrio entre rendimiento y espacio en disco. [14] Según el co-inventor Joe Armstrong, el lenguaje pasó de ser un producto de laboratorio a aplicaciones reales luego del colapso de la central telefónica AX de próxima generación llamada AXE-N en 1995. Como resultado, Erlang fue elegido para la próxima transferencia asincrónica. Modo (ATM) de intercambio AXD . [8]
En febrero de 1998, Ericsson Radio Systems prohibió el uso interno de Erlang para nuevos productos, citando una preferencia por lenguajes no propietarios. [15] La prohibición hizo que Armstrong y otros hicieran planes para dejar Ericsson. [16] En marzo de 1998, Ericsson anunció el conmutador AXD301, [8] que contenía más de un millón de líneas de Erlang y reportó que lograba una alta disponibilidad de nueve "9" . [17] En diciembre de 1998, la implementación de Erlang fue de código abierto y la mayor parte del equipo de Erlang renunció para formar una nueva empresa, Bluetail AB. [8] Ericsson finalmente relajó la prohibición y volvió a contratar a Armstrong en 2004. [16]
En 2006, se agregó soporte nativo de multiprocesamiento simétrico al sistema de ejecución y a la VM. [8]
Las aplicaciones Erlang se crean a partir de procesos Erlang muy livianos en el sistema de ejecución de Erlang. Los procesos de Erlang pueden verse como objetos "vivos" ( programación orientada a objetos ), con encapsulación de datos y paso de mensajes , pero capaces de cambiar el comportamiento durante el tiempo de ejecución. El sistema de tiempo de ejecución de Erlang proporciona un estricto aislamiento de procesos entre los procesos de Erlang (esto incluye la recolección de datos y basura, separados individualmente por cada proceso de Erlang) y una comunicación transparente entre procesos (consulte Transparencia de ubicación ) en diferentes nodos de Erlang (en diferentes hosts).
Joe Armstrong, co-inventor de Erlang, resumió los principios de los procesos en su tesis doctoral : [18]
Joe Armstrong comentó en una entrevista con Rackspace en 2013: "Si Java es ' escribir una vez, ejecutar en cualquier lugar ', entonces Erlang es 'escribir una vez, ejecutar para siempre'". [19]
En 2014, Ericsson informó que Erlang se estaba utilizando en sus nodos de soporte y en redes móviles GPRS , 3G y LTE en todo el mundo y también por Nortel y T-Mobile . [20]
Erlang se utiliza en RabbitMQ . Como expresó Tim Bray , director de Tecnologías Web de Sun Microsystems , en su discurso de apertura en la Convención de Código Abierto O'Reilly (OSCON) en julio de 2008:
Si alguien viniera a mí y quisiera pagarme un montón de dinero para construir un sistema de manejo de mensajes a gran escala que realmente tuviera que estar activo todo el tiempo y que nunca pudiera darse el lujo de dejar de funcionar durante años seguidos, elegiría sin dudar a Erlang. constrúyalo.
Erlang es el lenguaje de programación utilizado para codificar WhatsApp . [21]
También es el idioma elegido por Ejabberd , un servidor de mensajería XMPP .
Elixir es un lenguaje de programación que se compila en código de bytes BEAM (a través del formato abstracto de Erlang). [22]
Desde su lanzamiento como código abierto, Erlang se ha extendido más allá de las telecomunicaciones, estableciéndose en otros mercados verticales como FinTech, juegos, atención médica, automoción, Internet de las cosas y blockchain. Además de WhatsApp, hay otras empresas que figuran como casos de éxito de Erlang: Vocalink (una empresa de MasterCard), Goldman Sachs , Nintendo , AdRoll, Grindr , BT Mobile , Samsung , OpenX y SITA . [23] [24]
Un algoritmo factorial implementado en Erlang:
- módulo ( hecho ). % Este es el archivo 'fact.erl', el módulo y el nombre del archivo deben coincidir - exportar ([ fac / 1 ]). % Esto exporta la función 'fac' de arity 1 (1 parámetro, sin tipo, sin nombre) fac ( 0 ) -> 1 ; % Si es 0, devuelve 1; de lo contrario (tenga en cuenta el punto y coma; que significa 'otro') fac ( N ) cuando N > 0 , is_integer ( N ) -> N * fac ( N - 1 ). % Determina recursivamente y luego devuelve el resultado % (tenga en cuenta el punto . que significa 'endif' o 'fin de función') %% Esta función fallará si se proporciona algo que no sea un número entero no negativo. %% Ilustra la filosofía "Let it crash" de Erlang.
Un algoritmo recursivo de cola que produce la secuencia de Fibonacci :
%% La declaración del módulo debe coincidir con el nombre del archivo "series.erl" - módulo ( serie ).%% La declaración de exportación contiene una lista de todas aquellas funciones que forman %% la API pública del módulo. En este caso, este módulo expone una única función %% llamada fib que toma 1 argumento (IE tiene una aridad de 1) %% La sintaxis general para -export es una lista que contiene el nombre y %% aridad de cada función pública - export ([ fib / 1 ]).%% ------------------------------------------------ --------------------- %% API pública %% ----------------------- ----------------------------------------------%% Manejar casos en los que fib/1 recibe valores específicos %% El orden en el que se declaran estas firmas de funciones es una %% parte vital de la funcionalidad de este módulo%% Si fib/1 se pasa precisamente el número entero 0, entonces devuelve 0 fib ( 0 ) -> 0 ; %% Si fib/1 recibe un número negativo, entonces devuelve el átomo err_neg_val %% Normalmente, se desaconseja este tipo de codificación defensiva debido a la filosofía de Erlang 'Let %% crash'; sin embargo, en este caso debemos %% prevenir explícitamente una situación que bloqueará el motor de ejecución de Erlang fib ( N ) cuando N < 0 -> err_neg_val ; %% Si a fib/1 se le pasa un número entero menor que 3, entonces se devuelve 1 %% Las dos firmas de función anteriores manejan todos los casos en los que N < 1, %%, por lo que esta firma de función maneja los casos en los que N = 1 o N = 2 fib ( N ) cuando N < 3 -> 1 ; %% Para todos los demás valores, llame a la función privada fib_int/3 para realizar %% el cálculo fib ( N ) -> fib_int ( N , 0 , 1 ). %% ------------------------------------------------ --------------------- %% API privada %% ----------------------- ----------------------------------------------%% Si fib_int/3 recibe un 1 como primer argumento, entonces hemos terminado, por lo que %% devuelve el valor en el argumento B. Como no estamos interesados en el valor %% del segundo argumento, lo denotamos usando _ para indicar un valor %% "no me importa" fib_int ( 1 , _, B ) -> B ; %% Para todas las demás combinaciones de argumentos, llame recursivamente a fib_int/3 %% donde cada llamada hace lo siguiente: %% - contador de decremento N %% - Tome el valor de Fibonacci anterior en el argumento B y páselo como %% argumento A %% - Calcule el valor del número de Fibonacci actual y páselo %% como argumento B fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).
Aquí está el mismo programa sin los comentarios explicativos:
- módulo ( serie ). - exportar ([ fib / 1 ]).fib ( 0 ) -> 0 ; fib ( N ) cuando N < 0 -> err_neg_val ; fib ( N ) cuando N < 3 -> 1 ; fib ( N ) -> fib_int ( N , 0 , 1 ). fib_int ( 1 , _, B ) -> B ; fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).
Clasificación rápida en Erlang, mediante comprensión de listas : [25]
%% qsort:qsort(List) %% Ordenar una lista de elementos - módulo ( qsort ). % Este es el archivo 'qsort.erl' - exportar ([ qsort / 1 ]). % Se exporta una función 'qsort' con 1 parámetro (sin tipo, sin nombre) qsort ([]) -> []; % Si la lista [] está vacía, devuelve una lista vacía (nada que ordenar) qsort ([ Pivot | Rest ]) -> % Componga recursivamente una lista con 'Front' para todos los elementos que deberían estar antes de 'Pivot' % luego ' Pivote' y luego 'Atrás' para todos los elementos que deberían estar después de 'Pivote' qsort ([ Front || Front <- Rest , Front < Pivot ]) ++ [ Pivot ] ++ qsort ([ Back || Back <- Rest , Atrás >= Pivote ]).
El ejemplo anterior invoca recursivamente la función qsort
hasta que no queda nada por ordenar. La expresión [Front || Front <- Rest, Front < Pivot]
es una lista por comprensión , que significa "Construir una lista de elementos Front
tal que Front
sea miembro de Rest
y Front
sea menor que Pivot
". ++
es el operador de concatenación de listas.
Se puede utilizar una función de comparación para estructuras más complicadas en aras de la legibilidad.
El siguiente código ordenaría las listas según su longitud:
% Este es el archivo 'listsort.erl' (el compilador está hecho de esta manera) - módulo ( listsort ). % Exportar 'por_longitud' con 1 parámetro (no importa el tipo y el nombre) - exportar ([ por_longitud / 1 ]).by_length ( Lists ) -> % Utilice 'qsort/2' y proporciona una función anónima como parámetro qsort ( Lists , fun ( A , B ) -> length ( A ) < length ( B ) end ). qsort ([], _) -> []; % Si la lista está vacía, devuelve una lista vacía (ignore el segundo parámetro) qsort ([ Pivote | Resto ], Más pequeño ) -> % Lista de particiones con elementos 'más pequeños' delante de elementos 'Pivote' y no 'más pequeños' % después de 'Pivotar' y ordenar las sublistas. qsort ([ X || X <- Resto , Más pequeño ( X , Pivote )], Más pequeño ) ++ [ Pivote ] ++ qsort ([ Y || Y <- Resto , no ( Más pequeño ( Y , Pivote ))], Más pequeño ).
A Pivot
se toma del primer parámetro dado qsort()
y el resto Lists
se denomina Rest
. Tenga en cuenta que la expresión
[ X || X <- Resto , Más pequeño ( X , Pivote )]
no es diferente en forma de
[ Frente || Delantero <- Reposo , Delantero < Pivote ]
(en el ejemplo anterior) excepto por el uso de una función de comparación en la última parte, que dice "Construir una lista de elementos X
que X
sean miembros de Rest
y Smaller
sean verdaderos", que Smaller
se definió anteriormente como
diversión ( A , B ) -> longitud ( A ) < longitud ( B ) final
La función anónima recibe un nombre Smaller
en la lista de parámetros de la segunda definición de qsort
para que se pueda hacer referencia a ella con ese nombre dentro de esa función. No se nombra en la primera definición de qsort
, que trata con el caso base de una lista vacía y, por lo tanto, no necesita esta función, y mucho menos un nombre para ella.
Erlang tiene ocho tipos de datos primitivos :
make_ref()
.spawn(...)
Los Pids son referencias a procesos de Erlang.open_port
. Los mensajes se pueden enviar y recibir desde los puertos, pero estos mensajes deben obedecer el llamado "protocolo de puerto".fun(...) -> ... end
.Y tres tipos de datos compuestos:
{D1,D2,...,Dn}
denota una tupla cuyos argumentos son. D1, D2, ... Dn.
Los argumentos pueden ser tipos de datos primitivos o tipos de datos compuestos. Se puede acceder a cualquier elemento de una tupla en tiempo constante.[Dh|Dt]
denota una lista cuyo primer elemento es Dh
y cuyos elementos restantes son la lista Dt
. La sintaxis []
denota una lista vacía. La sintaxis [D1,D2,..,Dn]
es la abreviatura de [D1|[D2|..|[Dn|[]]]]
. Se puede acceder al primer elemento de una lista en tiempo constante. El primer elemento de una lista se llama encabezado de lista. El resto de una lista cuando se ha eliminado el encabezado se denomina cola de la lista.#{Key1=>Value1,...,KeyN=>ValueN}
.Se proporcionan dos formas de azúcar sintáctico :
[99,97,116]
. [26]Erlang no tiene ningún método para definir clases, aunque hay bibliotecas externas disponibles. [27]
Erlang está diseñado con un mecanismo que facilita a los procesos externos monitorear fallas (o fallas de hardware), en lugar de un mecanismo dentro del proceso como el manejo de excepciones utilizado en muchos otros lenguajes de programación. Los fallos se informan como otros mensajes, que es la única forma en que los procesos pueden comunicarse entre sí, [28] y los subprocesos se pueden generar de forma económica (ver más abajo). La filosofía "let it crash" prefiere que un proceso se reinicie por completo en lugar de intentar recuperarse de un fallo grave. [29] Aunque todavía requiere manejo de errores, esta filosofía da como resultado menos código dedicado a la programación defensiva donde el código de manejo de errores es altamente contextual y específico. [28]
Una aplicación típica de Erlang está escrita en forma de árbol supervisor. Esta arquitectura se basa en una jerarquía de procesos en la que el proceso de nivel superior se conoce como "supervisor". Luego, el supervisor genera múltiples procesos secundarios que actúan como trabajadores o como supervisores de nivel inferior. Estas jerarquías pueden existir en profundidades arbitrarias y han demostrado proporcionar un entorno altamente escalable y tolerante a fallos dentro del cual se puede implementar la funcionalidad de la aplicación.
Dentro de un árbol supervisor, todos los procesos supervisores son responsables de gestionar el ciclo de vida de sus procesos secundarios, y esto incluye manejar situaciones en las que esos procesos secundarios fallan. Cualquier proceso puede convertirse en supervisor generando primero un proceso hijo y luego invocando erlang:monitor/2
ese proceso. Si el proceso monitoreado falla, el supervisor recibirá un mensaje que contiene una tupla cuyo primer miembro es el átomo 'DOWN'
. El supervisor es responsable, en primer lugar, de escuchar dichos mensajes y, en segundo lugar, de tomar las medidas adecuadas para corregir la condición de error.
La principal fortaleza de Erlang es el soporte para la concurrencia . Tiene un pequeño pero poderoso conjunto de primitivas para crear procesos y comunicarse entre ellos. Erlang es conceptualmente similar al lenguaje occam , aunque reformula las ideas de comunicación de procesos secuenciales (CSP) en un marco funcional y utiliza el paso de mensajes asíncrono. [30] Los procesos son el medio principal para estructurar una aplicación Erlang. No son procesos ni subprocesos del sistema operativo , sino procesos livianos que son programados por BEAM. Al igual que los procesos del sistema operativo (pero a diferencia de los subprocesos del sistema operativo), no comparten ningún estado entre sí. La sobrecarga mínima estimada para cada uno es de 300 palabras . [31] Por lo tanto, se pueden crear muchos procesos sin degradar el rendimiento. En 2005, se realizó con éxito una prueba comparativa con 20 millones de procesos con Erlang de 64 bits en una máquina con 16 GB de memoria de acceso aleatorio (RAM; total 800 bytes/proceso). [32] Erlang ha soportado el multiprocesamiento simétrico desde la versión R11B de mayo de 2006.
Si bien los subprocesos necesitan soporte de biblioteca externa en la mayoría de los idiomas, Erlang proporciona funciones a nivel de idioma para crear y administrar procesos con el objetivo de simplificar la programación concurrente. Aunque toda la concurrencia es explícita en Erlang, los procesos se comunican mediante el paso de mensajes en lugar de variables compartidas, lo que elimina la necesidad de bloqueos explícitos (la VM todavía utiliza un esquema de bloqueo internamente). [33]
La comunicación entre procesos funciona a través de un sistema de paso de mensajes asíncrono sin compartir : cada proceso tiene un "buzón", una cola de mensajes que han sido enviados por otros procesos y aún no consumidos. Un proceso utiliza la primitiva para recuperar mensajes que coinciden con los patrones deseados. Una rutina de manejo de mensajes prueba los mensajes uno por uno con cada patrón, hasta que uno de ellos coincide. Cuando el mensaje se consume y se elimina del buzón, el proceso reanuda la ejecución. Un mensaje puede comprender cualquier estructura de Erlang, incluidas primitivas (enteros, flotantes, caracteres, átomos), tuplas, listas y funciones. receive
El siguiente ejemplo de código muestra el soporte integrado para procesos distribuidos:
% Crea un proceso e invoca la función web:start_server(Port, MaxConnections) ServerProcess = spawn ( web , start_server , [ Port , MaxConnections ]), % Cree un proceso remoto e invoque la función % web:start_server(Port, MaxConnections) en la máquina RemoteNode RemoteProcess = spawn ( RemoteNode , web , start_server , [ Port , MaxConnections ]), % Enviar un mensaje a ServerProcess (de forma asíncrona). El mensaje consta de una tupla % con el átomo "pausa" y el número "10". Proceso del servidor ! { pausa , 10 }, % Recibir mensajes enviados a este proceso recibir un_mensaje -> hacer_algo ; { datos , Contenido de datos } -> identificador ( Contenido de datos ); { hola , Texto } -> io : formato ( "Recibí el mensaje de saludo: ~s " , [ Texto ]); { adiós , Texto } -> io : formato ( "Recibí un mensaje de despedida: ~s " , [ Texto ]) fin .
Como muestra el ejemplo, los procesos se pueden crear en nodos remotos y la comunicación con ellos es transparente en el sentido de que la comunicación con procesos remotos funciona exactamente como la comunicación con procesos locales.
La concurrencia admite el método principal de manejo de errores en Erlang. Cuando un proceso falla, sale claramente y envía un mensaje al proceso de control, que luego puede tomar medidas, como iniciar un nuevo proceso que se haga cargo de la tarea del proceso anterior. [34] [35]
La implementación de referencia oficial de Erlang utiliza BEAM . [36] BEAM está incluido en la distribución oficial de Erlang, llamada Erlang/OTP. BEAM ejecuta código de bytes que se convierte en código de subprocesos en el momento de la carga. También incluye un compilador de código nativo en la mayoría de las plataformas, desarrollado por el Proyecto Erlang de Alto Rendimiento (HiPE) de la Universidad de Uppsala . Desde octubre de 2001, el sistema HiPE está totalmente integrado en el sistema Open Source Erlang/OTP de Ericsson. [37] También admite la interpretación, directamente desde el código fuente a través de un árbol de sintaxis abstracta , a través de un script a partir de la versión R11B-5 de Erlang.
Erlang admite la actualización dinámica de software a nivel de idioma . Para implementar esto, el código se carga y administra como unidades de "módulo"; El módulo es una unidad de compilación . El sistema puede mantener dos versiones de un módulo en la memoria al mismo tiempo y los procesos pueden ejecutar código de cada uno al mismo tiempo. Las versiones se denominan versión "nueva" y "antigua". Un proceso no pasará a la nueva versión hasta que realice una llamada externa a su módulo.
Un ejemplo del mecanismo de carga de código activo:
%% Un proceso cuyo único trabajo es mantener un contador. %% Primera versión - módulo ( contador ). - exportar ([ inicio / 0 , cambio de código / 1 ]). inicio () -> bucle ( 0 ). bucle ( Suma ) -> recibir { incremento , Contar } -> bucle ( Suma + Contar ); { contador , Pid } -> Pid ! { contador , Suma }, bucle ( Suma ); code_switch- > ? MÓDULO : codeswitch ( Sum ) % Fuerza el uso de 'codeswitch/1' desde el final de la última versión del MÓDULO . interruptor de código ( Suma ) -> bucle ( Suma ).
Para la segunda versión, agregamos la posibilidad de restablecer el conteo a cero.
%% Segunda versión - módulo ( contador ). - exportar ([ inicio / 0 , cambio de código / 1 ]). inicio () -> bucle ( 0 ). bucle ( Suma ) -> recibir { incremento , Contar } -> bucle ( Suma + Contar ); restablecer -> bucle ( 0 ); { contador , Pid } -> Pid ! { contador , Suma }, bucle ( Suma ); code_switch- > ? MÓDULO : final del interruptor de código ( Suma ) . interruptor de código ( Suma ) -> bucle ( Suma ).
Solo cuando se recibe un mensaje que consta del átomo, code_switch
el bucle ejecutará una llamada externa a codeswitch/1 ( ?MODULE
es una macro de preprocesador para el módulo actual). Si hay una nueva versión del módulo contador en la memoria, se llamará a su función codeswitch/1. La práctica de tener un punto de entrada específico en una nueva versión permite al programador transformar el estado a lo que se necesita en la versión más nueva. En el ejemplo, el estado se mantiene como un número entero.
En la práctica, los sistemas se construyen utilizando principios de diseño de Open Telecom Platform, lo que conduce a más diseños actualizables de código. La carga exitosa del código activo es exigente. El código debe escribirse con cuidado para hacer uso de las instalaciones de Erlang.
En 1998, Ericsson lanzó Erlang como software gratuito y de código abierto para garantizar su independencia de un único proveedor y aumentar el conocimiento del idioma. Erlang, junto con las bibliotecas y la base de datos distribuida en tiempo real Mnesia , forma la colección de bibliotecas OTP. Ericsson y algunas otras empresas apoyan comercialmente a Erlang.
Desde el lanzamiento del código abierto, Erlang ha sido utilizado por varias empresas en todo el mundo, incluidas Nortel y T-Mobile . [38] Aunque Erlang fue diseñado para llenar un nicho y ha seguido siendo un lenguaje oscuro durante la mayor parte de su existencia, su popularidad está creciendo debido a la demanda de servicios concurrentes. [39] [40] Erlang ha encontrado cierta utilidad en el campo de servidores de juegos de rol multijugador masivo en línea (MMORPG). [41]
{{cite book}}
: |journal=
ignorado ( ayuda )Erlang es conceptualmente similar al lenguaje de programación occam, aunque reformula las ideas de CSP en un marco funcional y utiliza el paso de mensajes asíncrono.
El mayor usuario de Erlang es (¡sorpresa!) Ericsson.
Ericsson lo utiliza para escribir software utilizado en sistemas de telecomunicaciones.
Muchas docenas de proyectos lo han utilizado, uno particularmente grande es el conmutador ATM AXD301 extremadamente escalable.
Otros usuarios comerciales enumerados como parte de las preguntas frecuentes incluyen: Nortel, Deutsche Flugsicherung (la organización nacional alemana
de control del tráfico aéreo
) y T-Mobile.
Prácticamente todos los idiomas utilizan concurrencia de estado compartido.
Esto es muy difícil y conduce a problemas terribles cuando se manejan fallas y se amplía el sistema... Algunas empresas emergentes de rápido movimiento en el mundo financiero se han aferrado a Erlang;
por ejemplo, el sueco www.kreditor.se.
No creo que otros idiomas puedan alcanzar a Erlang en el corto plazo.
Les resultará fácil agregar funciones de idioma para que sean como Erlang.
Les llevará mucho tiempo construir una máquina virtual de tan alta calidad y bibliotecas maduras para lograr simultaneidad y confiabilidad.
Por tanto, Erlang está preparado para el éxito.
Si desea crear una aplicación multinúcleo en los próximos años, debería consultar Erlang.