Hispanopedia Wiki
Articulo de referencia

Erlang (lenguaje de programación)

{{cite web |url=https://vimeo.com/97329186 |title=Joe Armstrong - Functional Programming the Long Road to Enlightenment: a Historical and Personal Narrative |first=N. D. C. |las...

Hispanopedia WikiContenido en espanolLectura gratuita

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 Plataforma Abierta de Telecomunicaciones (OTP), que consta del sistema de ejecución Erlang , varios componentes listos para usar (OTP) escritos principalmente en Erlang, y un conjunto de principios de diseño para programas Erlang. [ 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, coincidencia de patrones y programación funcional . [ 7 ] El subconjunto secuencial del lenguaje Erlang admite evaluación estricta , asignación única y tipado dinámico .

Una aplicación Erlang normal se construye a partir de cientos de pequeños procesos Erlang.

Originalmente era un software propietario dentro de Ericsson , desarrollado por Joe Armstrong , Robert Virding y Mike Williams en 1986, [ 8 ] pero fue lanzado como software libre y de código abierto en 1998. [ 9 ] [ 10 ] Erlang/OTP es respaldado y mantenido por la unidad de producto Open Telecom Platform (OTP) en Ericsson .

Historia

El nombre Erlang , atribuido a Bjarne Däcker, ha sido considerado por quienes trabajaban en las centrales telefónicas (para quienes se diseñó el lenguaje) como 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 estuvo influenciada por el lenguaje de programación PLEX utilizado en centrales Ericsson anteriores. Para 1988, Erlang había demostrado ser adecuado para la creación de prototipos de centrales telefónicas, pero el intérprete de Prolog era demasiado lento. Un grupo dentro de Ericsson estimó que necesitaría ser 40 veces más rápido para ser adecuado para su uso en producción. En 1992, se comenzó a trabajar en la máquina virtual (VM) BEAM , que compila Erlang a C utilizando una mezcla de código compilado de forma nativa y código multihilo para lograr un equilibrio entre rendimiento y espacio en disco. [ 14 ] Según el coinventor Joe Armstrong, el lenguaje pasó de ser un producto de laboratorio a aplicaciones reales tras el colapso de la central telefónica AXE de próxima generación, denominada AXE-N, en 1995. Como resultado, Erlang fue elegido para la siguiente central de modo de transferencia asíncrona (ATM), AXD . [ 8 ]

Robert Virding y Joe Armstrong, 2013

En febrero de 1998, Ericsson Radio Systems prohibió el uso interno de Erlang para nuevos productos, alegando una preferencia por lenguajes no propietarios. [ 15 ] La prohibición provocó que Armstrong y otros planearan abandonar 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 que, según se informó, alcanzaba una alta disponibilidad de nueve "9" . [ 17 ] En diciembre de 1998, la implementación de Erlang se liberó como código abierto y la mayor parte del equipo de Erlang renunció para formar una nueva empresa, Bluetail AB. [ 8 ] Ericsson finalmente flexibilizó la prohibición y volvió a contratar a Armstrong en 2004. [ 16 ]

En 2006, se agregó soporte nativo para multiprocesamiento simétrico al sistema de tiempo de ejecución y a la máquina virtual. [ 8 ]

Procesos

Las aplicaciones Erlang se construyen a partir de procesos Erlang muy ligeros en el sistema de ejecución de Erlang. Este sistema proporciona un estricto aislamiento entre los procesos Erlang (esto incluye la recolección de datos y basura, separadas individualmente por cada proceso Erlang) y una comunicación transparente entre procesos (véase Transparencia de ubicación ) en diferentes nodos Erlang (en diferentes hosts).

Joe Armstrong, coinventor de Erlang, resumió los principios de los procesos en su tesis doctoral: [ 18 ]

  • Todo es un proceso.
  • Los procesos están altamente aislados.
  • La creación y destrucción de procesos es una operación sencilla.
  • El paso de mensajes es la única forma en que los procesos pueden interactuar.
  • Los procesos tienen nombres únicos.
  • Si conoces el nombre de un proceso, puedes enviarle un mensaje.
  • Los procesos no comparten recursos.
  • El manejo de errores no es local.
  • Los procesos hacen lo que se supone que deben hacer o fracasan.

Joe Armstrong comentó en una entrevista con Rackspace en 2013: "Si Java es ' escribe una vez, ejecuta en cualquier lugar ', entonces Erlang es 'escribe una vez, ejecuta para siempre'". [ 19 ]

Uso

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, así como por Nortel y Deutsche Telekom . [ 20 ]

Erlang se utiliza en RabbitMQ . Como expresó Tim Bray , director de Tecnologías Web en Sun Microsystems , en su discurso de apertura en la Convención de Código Abierto de O'Reilly (OSCON) en julio de 2008:

Si alguien viniera a mí y quisiera pagarme mucho dinero para construir un sistema de gestión de mensajes a gran escala que tuviera que estar siempre operativo y que no pudiera permitirse el lujo de estar inactivo durante años, sin dudarlo elegiría Erlang para construirlo.

Erlang es el lenguaje de programación utilizado para codificar WhatsApp . [ 21 ]

También es el lenguaje preferido 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 software de código abierto, Erlang se ha extendido más allá de las telecomunicaciones, consolidándose en otros mercados verticales como FinTech, videojuegos, sanidad, automoción, Internet de las Cosas y blockchain. Además de WhatsApp, otras empresas que han utilizado Erlang con éxito son Vocalink (una empresa de MasterCard), Goldman Sachs , Nintendo , AdRoll, Grindr , BT Mobile , Samsung , OpenX y SITA . [ 23 ] [ 24 ]

Ejemplos de programación funcional

Factorial

Un algoritmo factorial implementado en Erlang:

- módulo ( fact ). % 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 aridad 1 (1 parámetro, sin tipo, sin nombre)fac ( 0 ) -> 1 ; % Si es 0, entonces devuelve 1, de lo contrario (nótese el punto y coma ; que significa 'de lo contrario') fac ( N ) cuando N > 0 , is_integer ( N ​​) -> N * fac ( N - 1 ). % Determina recursivamente, luego devuelve el resultado % (nótese el punto . que significa 'fin si' o 'fin de la función') %% Esta función fallará si se le da algo que no sea un entero no negativo. %% Ilustra la filosofía de "Dejar que falle" de Erlang.

secuencia de Fibonacci

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 ( series ).%% La declaración export contiene una lista de todas las 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 %% la aridad de cada función pública - export ([ fib / 1 ]).%% --------------------------------------------------------------------- %% API pública %% ---------------------------------------------------------------------%% Manejar los casos en los que fib/1 recibe valores específicos %% El orden en que se declaran estas firmas de función es una parte vital %% de la funcionalidad de este módulo%% Si fib/1 recibe un número negativo, entonces devuelve el átomo err_neg_val %% Normalmente, este tipo de codificación defensiva se desaconseja debido a la filosofía de Erlang de 'Dejar %% que se bloquee', pero aquí el resultado sería un bucle infinito. fib ( N ) cuando N < 0 -> err_neg_val ;%% Si a fib/1 se le pasa precisamente el entero 0, entonces devuelve 0 fib ( 0 ) -> 0 ;%% 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 - 1 , 0 , 1 ).%% --------------------------------------------------------------------- %% API privada %% ---------------------------------------------------------------------%% Si fib_int/3 recibe 0 como primer argumento, entonces hemos terminado, así que %% devolvemos el valor del argumento B. El segundo argumento se denota con _ para %% ignorar su valor. fib_int ( 0 , _, B ) -> B ;%% Para todas las demás combinaciones de argumentos, llame recursivamente a fib_int/3 %% donde cada llamada hace lo siguiente: %% - decrementa el contador N %% - pasa el tercer argumento como el nuevo segundo argumento %% - pasa la suma del segundo y tercer argumento como el nuevo %% tercer argumento fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).

Si se omiten los comentarios, el programa resulta mucho más corto.

- módulo ( serie ). - exportar ([ fib / 1 ]).fib ( N ) cuando N < 0 -> err_neg_val ; fib ( 0 ) -> 0 ; fib ( N ) -> fib_int ( N - 1 , 0 , 1 ).fib_int ( 0 , _, B ) -> B ; fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).

Ordenación rápida

Quicksort en Erlang, usando comprensión de listas : [ 25 ]

%% qsort:qsort(List) %% Ordena 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 ([ Pivote | Resto ]) -> % Compone recursivamente una lista con 'Frente' para todos los elementos que deben estar antes de 'Pivote' % luego 'Pivote' luego 'Atrás' para todos los elementos que deben estar después de 'Pivote' qsort ([ Frente || Frente <- Resto , Frente < Pivote ]) ++ [ Pivote ] ++ qsort ([ Atrás || Atrás <- Resto , Atrás >= Pivote ]).

El ejemplo anterior invoca recursivamente la función qsorthasta que no quede nada por ordenar. La expresión [Front || Front <- Rest, Front < Pivot]es una comprensión de lista , que significa "Construye una lista de elementos Fronttales que Frontsea miembro de Resty Frontsea menor que Pivot". ++es el operador de concatenación de listas.

Para estructuras más complejas, se puede utilizar una función de comparación 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 'by_length' con 1 parámetro (no importa el tipo ni el nombre) - exportar ([ by_length / 1 ]).por_longitud ( Listas ) -> % Usa 'qsort/2' y proporciona una función anónima como parámetro qsort ( Listas , fun ( A , B ) -> length ( A ) < length ( B ) end ).qsort ([], _) -> []; % Si la lista está vacía, devuelve una lista vacía (ignora el segundo parámetro) qsort ([ Pivote | Resto ], Smaller ) -> % Divide la lista con los elementos 'Smaller' delante de 'Pivote' y los elementos que no son 'Smaller' % después de 'Pivote' y ordena las sublistas. qsort ([ X || X <- Resto , Smaller ( X , Pivote )], Smaller ) ++ [ Pivote ] ++ qsort ([ Y || Y <- Resto , no ( Smaller ( Y , Pivote ))], Smaller ).

A Pivotse toma del primer parámetro dado a qsort()y el resto de Listsse denomina Rest. Tenga en cuenta que la expresión

[ X || X <- Rest , Smaller ( X , Pivot )]

no es diferente en forma de

[ Frente || Frente <- Resto , Frente < Pivote ]

(en el ejemplo anterior) excepto por el uso de una función de comparación en la última parte, que dice "Construye una lista de elementos Xtales que Xsea miembro de Rest, y Smallersea verdadero", siendo Smallerdefinido anteriormente como

fun ( A , B ) -> length ( A ) < length ( B ) end

La función anónima se nombra Smalleren la lista de parámetros de la segunda definición qsortpara que pueda referenciarse con ese nombre dentro de dicha función. No se nombra en la primera definición qsort, que trata el caso base de una lista vacía y, por lo tanto, no necesita esta función, y mucho menos un nombre para ella.

Tipos de datos

Erlang tiene ocho tipos de datos primitivos :

Números enteros
Los números enteros se escriben como secuencias de dígitos decimales; por ejemplo, 12, 12375 y -23427 son enteros. La aritmética de enteros es exacta y solo está limitada por la memoria disponible en la máquina. (Esto se denomina aritmética de precisión arbitraria ).
Átomos
Los átomos se utilizan en un programa para representar valores específicos. Se escriben como cadenas de caracteres alfanuméricos consecutivos, siendo el primero minúsculo. Un átomo puede contener cualquier carácter si está entre comillas simples, y existe una convención de escape que permite el uso de cualquier carácter dentro de un átomo. Los átomos nunca se eliminan mediante el recolector de basura, por lo que deben usarse con precaución, especialmente al generarlos dinámicamente.
Flotadores
Los números de punto flotante utilizan la representación IEEE 754 de 64 bits .
Referencias
Las referencias son símbolos globalmente únicos cuya única propiedad es que se pueden comparar para comprobar su igualdad. Se crean evaluando la primitiva de Erlang make_ref().
Binarios
Un binario es una secuencia de bytes. Los binarios ofrecen una forma eficiente de almacenar datos binarios en cuanto al uso del espacio. Existen primitivas de Erlang para componer y descomponer binarios, así como para la entrada y salida eficiente de los mismos.
Pids
Pid es la abreviatura de identificador de proceso ; un Pid es creado por la primitiva Erlang. Los Pids son referencias a procesos Erlang. spawn(...)
Puertos
Los puertos se utilizan para comunicarse con el mundo exterior. Se crean con la función integrada open_port. Se pueden enviar y recibir mensajes desde los puertos, pero estos mensajes deben cumplir con el llamado "protocolo de puerto".
Diversión
Los funs son cierres de funciones . Los funs se crean mediante expresiones de la forma: fun(...) -> ... end.

Y tres tipos de datos compuestos:

Tuplas
Las tuplas son contenedores para un número fijo de tipos de datos de Erlang. La sintaxis {D1,D2,...,Dn}denota una tupla cuyos argumentos son D1, D2, ... Dn.Los argumentos pueden ser tipos de datos primitivos o compuestos. Se puede acceder a cualquier elemento de una tupla en tiempo constante.
Liza
Las listas son contenedores para un número variable de tipos de datos de Erlang. La sintaxis [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 una 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 cabeza de la lista. El resto de una lista cuando se ha eliminado su cabeza se llama cola de la lista.
Mapas
Los mapas contienen un número variable de asociaciones clave-valor. La sintaxis es #{Key1=>Value1,...,KeyN=>ValueN}.

Se proporcionan dos formas de azúcar sintáctico :

Instrumentos de cuerda
Las cadenas se escriben como listas de caracteres entre comillas dobles. Esto es azúcar sintáctico para una lista de los puntos de código Unicode enteros para los caracteres de la cadena. Así, por ejemplo, la cadena "cat" es una abreviatura de [99,97,116]. [ 26 ]
Archivos
Los registros proporcionan una forma práctica de asociar una etiqueta a cada uno de los elementos de una tupla. Esto permite referirse a un elemento de una tupla por su nombre y no por su posición. Un precompilador toma la definición del registro y la reemplaza con la referencia de tupla correspondiente.

Estilo de codificación "Deja que se estrelle"

Erlang está diseñado con un mecanismo que facilita a los procesos externos la monitorización de fallos (o errores de hardware), en lugar de un mecanismo interno como el manejo de excepciones utilizado en muchos otros lenguajes de programación. Los fallos se notifican como cualquier otro mensaje, que es la única forma en que los procesos pueden comunicarse entre sí, [ 27 ] y se pueden crear subprocesos de forma económica (véase más abajo ). La filosofía de "dejar que falle" prefiere que un proceso se reinicie por completo en lugar de intentar recuperarse de un fallo grave. [ 28 ] Aunque todavía requiere el 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. [ 27 ]

Árboles supervisores

Una aplicación típica de Erlang se escribe en forma de árbol de supervisores. Esta arquitectura se basa en una jerarquía de procesos donde el proceso de nivel superior se conoce como "supervisor". El supervisor genera múltiples procesos hijos que actúan como trabajadores o como supervisores de nivel inferior. Estas jerarquías pueden tener 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 de supervisión, todos los procesos supervisores son responsables de gestionar el ciclo de vida de sus procesos hijos, lo que incluye el manejo de situaciones en las que dichos procesos hijos fallan. Cualquier proceso puede convertirse en supervisor creando primero un proceso hijo y luego invocándolo erlang:monitor/2. Si el proceso supervisado 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 de tomar las medidas adecuadas para corregir la condición de error.

Orientación a la concurrencia y la distribución

La principal fortaleza de Erlang es su soporte para la concurrencia . Cuenta con un conjunto pequeño pero potente 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 paso de mensajes asíncrono. [ 29 ] Los procesos son el medio principal para estructurar una aplicación Erlang. No son ni procesos del sistema operativo ni hilos , sino procesos ligeros que son planificados por BEAM. Al igual que los procesos del sistema operativo (pero a diferencia de los hilos del sistema operativo), no comparten estado entre sí. La sobrecarga mínima estimada para cada uno es de 300 palabras . [ 30 ] Por lo tanto, se pueden crear muchos procesos sin degradar el rendimiento. En 2005, se realizó con éxito una prueba de rendimiento 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). [ 31 ] Erlang ha admitido el multiprocesamiento simétrico desde la versión R11B de mayo de 2006.

Si bien en la mayoría de los lenguajes los hilos requieren soporte de bibliotecas externas, Erlang proporciona características a nivel de lenguaje para crear y gestionar 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 máquina virtual sigue utilizando un esquema de bloqueo internamente). [ 32 ]

La comunicación entre procesos funciona mediante un sistema de paso de mensajes asíncrono sin recursos compartidos : cada proceso tiene un "buzón", una cola de mensajes enviados por otros procesos que aún no se han procesado. Un proceso utiliza una primitiva para recuperar los mensajes que coinciden con los patrones deseados. Una rutina de procesamiento de mensajes los compara sucesivamente con cada patrón hasta que uno coincide. Cuando el mensaje se procesa y se elimina del buzón, el proceso reanuda su ejecución. Un mensaje puede contener cualquier estructura de Erlang, incluyendo primitivas (enteros, números de coma flotante, caracteres, átomos), tuplas, listas y funciones.receive

El siguiente ejemplo de código muestra la compatibilidad integrada con procesos distribuidos:

% Crea un proceso e invoca la función web:start_server(Port, MaxConnections) ServerProcess = spawn ( web , start_server , [ Port , MaxConnections ]),% Crea un proceso remoto e invoca la función % web:start_server(Port, MaxConnections) en la máquina RemoteNode RemoteProcess = spawn ( RemoteNode , web , start_server , [ Port , MaxConnections ]),% Envía un mensaje a ServerProcess (asíncronamente). El mensaje consiste en una tupla % con el átomo "pause" y el número "10". ServerProcess ! { pause , 10 },% Recibir mensajes enviados a este proceso receive a_message -> do_something ; { data , DataContent } -> handle ( DataContent ); { hello , Text } -> io : format ( "Mensaje de saludo recibido: ~s " , [ Text ]); { goodbye , Text } -> io : format ( "Mensaje de despedida recibido: ~s " , [ Text ]) end .

Como muestra el ejemplo, los procesos pueden crearse en nodos remotos, y la comunicación con ellos es transparente en el sentido de que la comunicación con los procesos remotos funciona exactamente igual que la comunicación con los procesos locales.

La concurrencia es el método principal de manejo de errores en Erlang. Cuando un proceso falla, finaliza correctamente y envía un mensaje al proceso controlador, que puede tomar medidas, como iniciar un nuevo proceso que se haga cargo de la tarea del proceso anterior. [ 33 ] [ 34 ]

Implementación

La implementación de referencia oficial de Erlang utiliza BEAM . [ 35 ] BEAM está incluido en la distribución oficial de Erlang, llamada Erlang/OTP. BEAM ejecuta bytecode que se convierte en código multihilo 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) en la Universidad de Uppsala . Desde octubre de 2001, el sistema HiPE está completamente integrado en el sistema Erlang/OTP de código abierto de Ericsson. [ 36 ] También admite la interpretación, directamente desde el código fuente a través del árbol de sintaxis abstracta , a través de scripts desde la versión R11B-5 de Erlang.

Carga de código en caliente y módulos

Erlang admite la actualización dinámica de software a nivel de lenguaje . Para implementarla, el código se carga y gestiona como unidades de "módulo"; cada módulo es una unidad de compilación . El sistema puede mantener dos versiones de un módulo en memoria simultáneamente, y los procesos pueden ejecutar código de cada una de ellas de forma concurrente. Estas versiones se denominan "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 en caliente:

%% Un proceso cuya única función es mantener un contador. %% Primera versión - módulo ( contador ). - exportar ([ inicio / 0 , cambio de código / 1 ]).inicio () -> bucle ( 0 ).loop ( Sum ) -> receive { increment , Count } -> loop ( Sum + Count ); { counter , Pid } -> Pid ! { counter , Sum }, loop ( Sum ); code_switch -> ? MODULE : codeswitch ( Sum ) % Fuerza el uso de 'codeswitch/1' de la última versión de MODULE end .codewitch ( Sum ) -> loop ( Sum ).

Para la segunda versión, añadimos la posibilidad de reiniciar el contador a cero.

%% Segunda versión - módulo ( contador ). - exportar ([ inicio / 0 , cambio de código / 1 ]).inicio () -> bucle ( 0 ).bucle ( suma ) -> recibir { incremento , Contador } -> bucle ( suma + Contador ); reiniciar -> bucle ( 0 ); { contador , Pid } -> Pid ! { contador , Suma }, bucle ( suma ); code_switch -> ? MÓDULO : codeswitch ( suma ) fin .codewitch ( Sum ) -> loop ( Sum ).

Solo al recibir un mensaje que contenga el átomo, code_switchel bucle ejecutará una llamada externa a codeswitch/1 ( ?MODULEuna macro del preprocesador para el módulo actual). Si hay una nueva versión del módulo contador en memoria, se llamará a su función codeswitch/1. La práctica de tener un punto de entrada específico a una nueva versión permite al programador transformar el estado a lo que se necesita en la versión más reciente. En el ejemplo, el estado se mantiene como un entero.

En la práctica, los sistemas se construyen utilizando principios de diseño de la Open Telecom Platform, lo que da como resultado diseños con mayor capacidad de actualización de código. La carga en caliente de código es exigente. El código debe escribirse con cuidado para aprovechar las funcionalidades de Erlang.

Distribución

En 1998, Ericsson lanzó Erlang como software libre y de código abierto para garantizar su independencia de un único proveedor y para dar a conocer el lenguaje. Erlang, junto con bibliotecas y la base de datos distribuida en tiempo real Mnesia , conforma la colección de bibliotecas OTP. Ericsson y algunas otras empresas ofrecen soporte comercial para Erlang.

Desde su lanzamiento como código abierto, Erlang ha sido utilizado por varias empresas en todo el mundo, incluidas Nortel y Deutsche Telekom . [ 37 ] Aunque Erlang fue diseñado para cubrir un nicho y ha permanecido como un lenguaje poco conocido durante la mayor parte de su existencia, su popularidad está creciendo debido a la demanda de servicios concurrentes. [ 38 ] [ 39 ] Erlang ha encontrado cierto uso en el despliegue de servidores de juegos de rol multijugador masivos en línea (MMORPG). [ 40 ]

Véase también

Referencias

  1. ↑ "Versión 29.0.5" . 4 de agosto de 2026. Consultado el 4 de agosto de 2026 .
  2. ↑ Conferencias, NDC (4 de junio de 2014). "Joe Armstrong - Programación funcional: el largo camino hacia la iluminación: una narrativa histórica y personal" . Vimeo.
  3. ↑ "Clojure: Lisp se encuentra con Java, con un toque de Erlang - O'Reilly Radar" . radar.oreilly.com .
  4. ↑ "Influencias - The Rust Reference" . The Rust Reference . Consultado el 18 de abril de 2023 .
  5. ↑ "Erlang – Introducción" . erlang.org . Archivado del original el 8 de septiembre de 2019. Consultado el 6 de febrero de 2017 .
  6. ↑ Armstrong, Joe; Däcker, Bjarne; Lindgren, Thomas; Millroth, Håkan. "Erlang de código abierto: Libro Blanco" . Archivado del original el 25 de octubre de 2011. Recuperado el 31 de julio de 2011 .
  7. ↑ El recorrido del autoestopista por el BEAM – Robert Virding http://www.erlang-factory.com/upload/presentations/708/HitchhikersTouroftheBEAM.pdf
  8. 1 2 3 4 5 6 Armstrong, Joe (2007). Historia de Erlang . HOPL III: Actas de la tercera conferencia ACM SIGPLAN sobre la historia de los lenguajes de programación . ISBN 978-1-59593-766-7.
  9. ↑ "Cómo los gigantes tecnológicos difunden el amor por la programación de código abierto - CIO.com" . 8 de enero de 2016. Archivado del original el 22 de febrero de 2019. Consultado el 5 de septiembre de 2016 .
  10. ↑ "Erlang/OTP se publica como código abierto, 8 de diciembre de 1998" . Archivado del original el 9 de octubre de 1999.
  11. ↑ "¿Erlang, el matemático?" . Febrero de 1999.
  12. ↑ "Diccionario gratuito en línea de informática: Erlang" .
  13. ↑ "Historia de Erlang" . Erlang.org .
  14. ↑ Armstrong, Joe (agosto de 1997). «El desarrollo de Erlang». Actas de la segunda conferencia internacional ACM SIGPLAN sobre programación funcional . Vol. 32. págs. 196–203 . doi : 10.1145/258948.258967 . ISBN   0897919181. S2CID 6821037 . {{cite book}}: |journal=ignorado ( ayuda )
  15. ↑ Däcker, Bjarne (octubre de 2000). Programación funcional concurrente para telecomunicaciones: un estudio de caso de introducción tecnológica (PDF) (Tesis). Instituto Real de Tecnología. pág. 37. 
  16. 1 2 "Pregunta sobre el futuro de Erlang" . 6 de julio de 2010.
  17. ↑ "Programación orientada a la concurrencia en Erlang" (PDF) . 9 de noviembre de 2002.
  18. ↑ Armstrong, Joe (20 de noviembre de 2003). Creación de sistemas distribuidos fiables en presencia de errores de software (tesis doctoral). Estocolmo, Suecia: Real Instituto de Tecnología.
  19. ↑ McGreggor, Duncan (26 de marzo de 2013). Rackspace analiza el lenguaje de programación Erlang para computación distribuida (Vídeo). Rackspace Studios, San Francisco. Archivado del original el 11 de diciembre de 2021. Consultado el 24 de abril de 2019 .
  20. ↑ "Ericsson" . Ericsson.com . 4 de diciembre de 2014. Consultado el 7 de abril de 2018 .
  21. ↑ "Dentro de Erlang, el singular lenguaje de programación detrás del éxito de WhatsApp" . fastcompany.com . 21 de febrero de 2014. Consultado el 12 de noviembre de 2019 .
  22. ↑ "Sintaxis de Erlang/Elixir: Un curso intensivo" . elixir-lang.github.com . Consultado el 10 de octubre de 2022 .
  23. ↑ "¿Qué empresas utilizan Erlang y por qué? #MyTopdogStatus" . erlang-solutions.com . 11 de septiembre de 2019. Consultado el 15 de marzo de 2020 .
  24. ↑ "¿Qué nuevas empresas están usando Erlang y Elixir? #MyTopdogStatus" . erlang-solutions.com . 2 de marzo de 2020. Consultado el 24 de junio de 2020 .
  25. ↑ "Erlang – Comprensión de listas" . erlang.org .
  26. ↑ "Literales de cadena y carácter" . Consultado el 2 de mayo de 2015 .
  27. 1 2 Verraes, Mathias (9 de diciembre de 2014). "Let It Crash" . Blog de Mathias Verraes . Recuperado el 10 de febrero de 2021 .
  28. ↑ "Patrones de diseño reactivos —" . www.reactivedesignpatterns.com . Consultado el 10 de febrero de 2021 .
  29. ↑ Armstrong, Joe (septiembre de 2010). "Erlang" . Communications of the ACM . 53 (9): 68–75 . doi : 10.1145/1810891.1810910 . 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.
  30. ↑ "Guía de eficiencia de Erlang – Procesos" . Archivado del original el 27 de febrero de 2015.
  31. ↑ Wiger, Ulf (14 de noviembre de 2005). "Pruebas de estrés en Erlang" . comp.lang.functional.misc . Consultado el 25 de agosto de 2006 .
  32. ↑ "Cola de mensajes sin bloqueo" . Archivado del original el 24 de diciembre de 2013. Consultado el 23 de diciembre de 2013 .
  33. ↑ Armstrong, Joe. "Robustez de Erlang" . Archivado del original el 23 de abril de 2015. Recuperado el 15 de julio de 2010 .
  34. ↑ "Principios de supervisión de Erlang" . Archivado del original el 6 de febrero de 2015. Consultado el 15 de julio de 2010 .
  35. ↑ "Erlang – Compilación y carga de código" . erlang.org . Consultado el 21 de diciembre de 2017 .
  36. ↑ "Erlang de alto rendimiento" . Consultado el 26 de marzo de 2011 .
  37. ↑ "¿Quién usa Erlang para el desarrollo de productos?" . Preguntas frecuentes sobre Erlang . Consultado el 16 de julio de 2007 . El mayor usuario de Erlang es (¡sorpresa!) Ericsson. Ericsson lo usa para escribir software para sistemas de telecomunicaciones. Decenas de proyectos lo han usado, uno particularmente grande es el conmutador ATM AXD301, extremadamente escalable. Otros usuarios comerciales que aparecen en las preguntas frecuentes incluyen: Nortel, Deutsche Flugsicherung (la organización nacional alemana de control de tráfico aéreo ) y T-Mobile.
  38. ↑ "Programación en Erlang" . Consultado el 13 de diciembre de 2008. Prácticamente todos los lenguajes utilizan concurrencia de estado compartido . Esto es muy difícil y genera graves problemas al gestionar fallos y escalar el sistema... Algunas startups de rápido crecimiento en el mundo financiero se han decantado por Erlang; por ejemplo, la sueca www.kreditor.se.
  39. ↑ "Erlang, el próximo Java" . Archivado del original el 11 de octubre de 2007. Recuperado el 8 de octubre de 2008. No creo que otros lenguajes puedan alcanzar a Erlang en un futuro próximo . Les resultará fácil añadir características similares a las de Erlang. Les llevará mucho tiempo desarrollar una máquina virtual de tan alta calidad y bibliotecas maduras para la concurrencia y la fiabilidad. Por lo tanto, Erlang está destinado al éxito. Si desea desarrollar una aplicación multinúcleo en los próximos años, debería considerar Erlang.
  40. ↑ Clarke, Gavin (5 de febrero de 2011). "Se necesitan veteranos de Battlestar Galactica para juegos de rol en línea" . Música y medios . The Reg . Recuperado el 8 de febrero de 2011 .

Lecturas adicionales

  • Armstrong, Joe (2003). Creación de sistemas distribuidos fiables en presencia de errores de software (PDF) (Tesis doctoral). Instituto Real de Tecnología, Estocolmo, Suecia. Archivado del original (PDF) el 23 de marzo de 2015. Consultado el 13 de febrero de 2016 .
  • Armstrong, Joe (2007). «Una historia de Erlang». Actas de la tercera conferencia ACM SIGPLAN sobre Historia de los lenguajes de programación – HOPL III . pp. 6–1 . doi : 10.1145/1238844.1238850 . ISBN  978-1-59593-766-7. S2CID 555765 . 
  • Historia temprana de Erlang. Archivado el 29 de agosto de 2019 en Wayback Machine por Bjarne Däcker.
  • Mattsson, H.; Nilsson, H.; Wikstrom, C. (1999). "Mnesia: un sistema de gestión de bases de datos distribuido y robusto para aplicaciones de telecomunicaciones". Primer Taller Internacional sobre Aspectos Prácticos de los Lenguajes Declarativos (PADL '99) : 152–163 .
  • Armstrong, Joe; Virding, Robert; Williams, Mike; Wikstrom, Claes (16 de enero de 1996). Programación concurrente en Erlang (2.ª  ed.). Prentice Hall . pág.  358. ISBN 978-0-13-508301-7Archivado del original el 6 de marzo de 2012.
  • Armstrong, Joe (11 de julio de 2007). Programación en Erlang: Software para un mundo concurrente (1.ª  ed.). Pragmatic Bookshelf . pág . 536. ISBN  978-1-934356-00-5.
  • Thompson, Simon J.; Cesarini, Francesco (19 de junio de 2009). Programación en Erlang: Un enfoque concurrente para el desarrollo de software (1.ª  ed.). Sebastopol, California: O'Reilly Media , Inc. pág.  496. ISBN 978-0-596-51818-9.
  • Logan, Martin; Merritt, Eric; Carlsson, Richard (28 de mayo de 2010). Erlang y OTP en acción (1.ª  ed.). Greenwich, CT: Manning Publications . pág.  500. ISBN 978-1-933988-78-8.
  • Martin, Brown (10 de mayo de 2011). "Introducción a la programación en Erlang, Parte 1: Lo básico" . developerWorks . IBM . Recuperado el 10 de mayo de 2011 .
  • Martin, Brown (17 de mayo de 2011). "Introducción a la programación en Erlang, Parte 2: Uso de características y funcionalidades avanzadas" . developerWorks . IBM . Recuperado el 17 de mayo de 2011 .
  • Wiger, Ulf (30 de marzo de 2001). "Cuádruple aumento de productividad y calidad: programación funcional de nivel industrial en productos de telecomunicaciones" (PDF) . Implementación de FEmSYS 2001 en arquitecturas distribuidas . Ericsson Telecom AB. Archivado del original (PDF) el 19 de agosto de 2019. Recuperado el 16 de septiembre de 2014 .