Erlang

Erlang es un lenguaje de programación funcional, concurrente y de propósito general, y un sistema de tiempo de ejecución de recolección de elementos no utilizados. El término Erlang se usa indistintamente con Erlang/OTP, o Open Telecom Platform (OTP), que consta del sistema de tiempo 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

El sistema de tiempo de ejecución de Erlang está diseñado para sistemas con estas características:

• Repartido
• Tolerante a fallos
• Suave en tiempo real
• Aplicaciones ininterrumpidas de alta disponibilidad
• Intercambio en caliente, donde el código se puede cambiar sin detener un sistema.

El lenguaje de programación Erlang tiene datos inmutables, coincidencia de patrones y programación funcional. El subconjunto secuencial del lenguaje Erlang admite evaluación entusiasta, asignación única y escritura dinámica.

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

Originalmente era un software propietario dentro de Ericsson, desarrollado por Joe Armstrong, Robert Virding y Mike Williams en 1986, pero se lanzó como software gratuito y de código abierto en 1998. Erlang/OTP cuenta con el respaldo y mantenimiento de Open Telecom Platform (OTP) unidad de producto en Ericsson.

Historia

El nombre Erlang, atribuido a Bjarne Däcker, ha sido asumido por aquellos que trabajan en los conmutadores de telefonía (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". Erlang fue diseñado con el objetivo de mejorar el desarrollo de aplicaciones de telefonía.La versión inicial de Erlang se implementó en Prolog y estuvo influenciada por el lenguaje de programación PLEX utilizado en intercambios anteriores de Ericsson. En 1988, Erlang había demostrado que era adecuado para crear prototipos de centrales telefónicas, pero el intérprete de Prolog era demasiado lento. Un grupo dentro de Ericsson estimó que tendría que 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 combinación de código compilado de forma nativa y código enhebrado para lograr un equilibrio entre el rendimiento y el espacio en disco. 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 el próximo intercambio de modo de transferencia asíncrono (ATM) AXD.

En febrero de 1998, Ericsson Radio Systems prohibió el uso interno de Erlang para nuevos productos, citando una preferencia por lenguajes no patentados. La prohibición hizo que Armstrong y otros hicieran planes para dejar Ericsson. En marzo de 1998, Ericsson anunció el conmutador AXD301, que contenía más de un millón de líneas de Erlang e informó que lograba una alta disponibilidad de nueve "9". 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. Ericsson finalmente relajó la prohibición y volvió a contratar a Armstrong en 2004.

En 2006, se agregó soporte de multiprocesamiento simétrico nativo al sistema de tiempo de ejecución y la VM.

Procesos

Las aplicaciones de Erlang se crean a partir de procesos de Erlang muy ligeros en el sistema de tiempo 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 de comportamiento durante el tiempo de ejecución. El sistema de tiempo de ejecución de Erlang proporciona un aislamiento de proceso estricto entre los procesos de Erlang (esto incluye datos y recolección de elementos no utilizados, separados individualmente por cada proceso de Erlang) y una comunicación transparente entre procesos en diferentes nodos de Erlang (en diferentes hosts).

Joe Armstrong, co-inventor de Erlang, resumió los principios de los procesos en su tesis doctoral:

• Todo es un proceso.
• Los procesos están fuertemente aislados.
• La creación y destrucción de procesos es una operación ligera.
• El paso de mensajes es la única manera de que los procesos interactúen.
• Los procesos tienen nombres únicos.
• Si conoce el nombre de un proceso, puede 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 fallan.

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'".

Uso

En 2014, Ericsson informó que Erlang estaba siendo utilizado 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.

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 de O'Reilly (OSCON) en julio de 2008:

Si alguien viniera a mí y quisiera pagarme una gran cantidad de dinero para construir un sistema de manejo de mensajes a gran escala que realmente tuviera que estar activo todo el tiempo, que nunca pudiera darse el lujo de dejar de funcionar durante años, sin dudarlo elegiría Erlang para incorpóralo.

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

El lenguaje de programación Elixir se compila en el código de bytes BEAM (a través del formato abstracto Erlang).

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, automotriz, internet de las cosas y blockchain. Aparte 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.

Ejemplos de programación funcional

Factorial

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 aridad 1 (1 parámetro, sin tipo, sin nombre)

fact (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). 
% Determine recursivamente, luego devuelva el resultado 
% (tenga en cuenta el punto. que significa 'endif' o 'fin de la función') 
%% Esta función fallará si se proporciona algo que no sea un entero no negativo. 
%% Ilustra la filosofía "Let it crash" de Erlang.

Secuencia 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 (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 sola 
función %% llamada fib que toma 1 argumento (IE tiene una aridad de 1) 
%% La sintaxis general para -exportar es una lista que contiene el nombre y la 
aridad %% de cada función pública 
- exportar ([ mentira / 1 ]).

%% ------------------------------------------------ --------------------- 
%% API pública 
%% ----------------------- ----------------------------------------------

%% Manejar 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 se pasa fib/1 precisamente el entero 0, entonces devuelve 0 
fib (0)  ->  0;

%% Si fib/1 recibe un número negativo, devuelve el átomo err_neg_val 
%% Normalmente, este tipo de codificación defensiva se desaconseja debido a la 
filosofía de Erlang 'Deja que %% se bloquee'; sin embargo, en este caso deberíamos 
%% prevenir explícitamente una situación que bloquee el motor de tiempo 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 devuelve 1 
%% Las dos firmas de función anteriores manejan todos los casos donde N < 1, 
%% por lo que esta firma de función maneja los casos donde 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. Dado que no estamos interesados ​​en el 
valor %% del segundo argumento, indicamos esto 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: 
%% - decrementa el contador N 
%% - Toma 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 ]).

mentirilla (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).

Ordenación rápida

Quicksort en Erlang, usando la lista de comprensión:

%% qsort:qsort(Lista) 
%% Ordenar una lista de elementos 
- módulo (qsort).      % Este es el archivo 'qsort.erl' 
- export ([ qsort / 1 ]).  % Se exporta una función 'qsort' con 1 parámetro (sin tipo, sin nombre)

qordenar ([])  ->  [];  % 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 ' Pivot' luego 'Back' para todos los elementos que deberían estar después de 'Pivot' 
    qsort ([ Front  ||  Front  <-  Rest,  Front  <  Pivot ])  ++  
    [ Pivot ]  ++ 
    qsort ([ Back  ||  Back  <-  Rest,  >=  pivote ]).

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

Se puede usar 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)  ->  % Usa 'qsort/2' y proporciona una función anónima como parámetro 
   qsort (Lists,  fun (A, B)  ->  length (A)  <  length (B)  end ).

qordenar ([],  _) ->  [];  % Si la lista está vacía, devuelve una lista vacía (ignore el segundo parámetro) 
qsort ([ Pivot | Rest ],  Smaller)  -> 
    % Lista de particiones con elementos 'Pequeños' delante de 'Pivote' y elementos no 'Pequeños' 
    % después de 'Pivote' y ordene las sublistas. 
    qsort ([ X  ||  X  <-  Rest,  Smaller (X, Pivot)],  Smaller) 
    ++  [ Pivot ]  ++ 
    qsort ([ Y  || Y  <-  Resto,  no (Más pequeño (Y,  Pivote))],  Más pequeño).

A Pivotse toma del primer parámetro dado a qsort()y el resto Listsse nombra Rest. Nótese que la expresión

[ X  ||  X  <-  Descanso,  Menor (X, Pivote)]

no es diferente en forma de

[ Frente  ||  Delantero  <-  Descanso,  Delantero  <  Pivote ]

(en el ejemplo anterior) excepto por el uso de una función de comparación en la última parte, diciendo "Construya una lista de elementos Xtal que Xsea miembro de Rest, y Smallersea verdadero", Smallersiendo definida anteriormente como

diversión (A, B)  ->  longitud (A)  <  longitud (B)  fin

La función anónima se nombra Smalleren la lista de parámetros de la segunda definición de qsortpara que ese nombre pueda hacer referencia a ella 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.

Tipos de datos

Erlang tiene ocho tipos de datos primitivos:enterosLos números enteros se escriben como secuencias de dígitos decimales, por ejemplo, 12, 12375 y -23427 son números enteros. La aritmética de enteros es exacta y solo está limitada por la memoria disponible en la máquina. (Esto se llama aritmética de precisión arbitraria).ÁtomosLos átomos se utilizan dentro de un programa para denotar valores distinguidos. Se escriben como cadenas de caracteres alfanuméricos consecutivos, siendo el primer carácter en minúsculas. Los átomos pueden contener cualquier carácter si están encerrados entre comillas simples y existe una convención de escape que permite usar cualquier carácter dentro de un átomo. Los átomos nunca se recolectan como basura y deben usarse con precaución, especialmente si se usa la generación dinámica de átomos.flotadoresLos números de punto flotante utilizan la representación IEEE 754 de 64 bits.ReferenciasLas referencias son símbolos únicos a nivel mundial cuya única propiedad es que se pueden comparar para la igualdad. Se crean evaluando la primitiva Erlang make_ref().binariosUn binario es una secuencia de bytes. Los archivos binarios proporcionan una forma eficiente en cuanto al espacio de almacenar datos binarios. Las primitivas de Erlang existen para componer y descomponer binarios y para la entrada/salida eficiente de binarios.PidsPid es la abreviatura de identificador de proceso: el primitivo Erlang crea un Pid. Los Pid spawn(...)son referencias a los procesos de Erlang.PuertosLos puertos se utilizan para comunicarse con el mundo exterior. Los puertos se crean con la función incorporada open_port. Los mensajes se pueden enviar y recibir desde los puertos, pero estos mensajes deben obedecer al llamado "protocolo de puerto".diversionesLas diversiones son cierres de funciones. Las diversiones se crean mediante expresiones de la forma: fun(...) ->... end.

Y tres tipos de datos compuestos:tuplasLas 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 tipos de datos compuestos. Se puede acceder a cualquier elemento de una tupla en tiempo constante.LizaLas 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 Dhy 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 denomina encabezado de la lista. El resto de una lista cuando se le ha quitado la cabeza se llama la cola de la lista.mapasLos 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 cuerdaLas cadenas se escriben como listas de caracteres entre comillas dobles. Esto es azúcar sintáctico para una lista de puntos de código Unicode enteros para los caracteres de la cadena. Así, por ejemplo, la cadena "gato" es una abreviatura de [99,97,116].RegistrosLos registros proporcionan una forma conveniente de asociar una etiqueta con cada uno de los elementos de una tupla. Esto permite referirse a un elemento de una tupla por nombre y no por posición. Un precompilador toma la definición de registro y la reemplaza con la referencia de tupla adecuada.

Erlang no tiene un método para definir clases, aunque hay bibliotecas externas disponibles.

Estilo de codificación "Let it crash"

Erlang está diseñado con un mecanismo que facilita que los procesos externos supervisen los bloqueos (o fallas de hardware), en lugar de un mecanismo en proceso como el manejo de excepciones que se usa en muchos otros lenguajes de programación. Los bloqueos se informan como otros mensajes, que es la única forma en que los procesos pueden comunicarse entre sí y los subprocesos pueden generarse de manera económica. La filosofía de "dejar que se estrelle" prefiere que un proceso se reinicie por completo en lugar de tratar de recuperarse de una falla grave. 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.

Árboles supervisores

Una aplicación típica de Erlang está escrita en forma de árbol de supervisores. 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 más supervisores de nivel inferior. Tales jerarquías pueden existir en profundidades arbitrarias y han demostrado proporcionar un entorno altamente escalable y tolerante a fallas dentro del cual se puede implementar la funcionalidad de la aplicación.

Dentro de un árbol de supervisores, todos los procesos supervisores son responsables de administrar el ciclo de vida de sus procesos secundarios, y esto incluye el manejo de situaciones en las que esos procesos secundarios colapsan. Cualquier proceso puede convertirse en supervisor generando primero un proceso secundario y luego llamando erlang:monitor/2a 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.

Orientación a la concurrencia y distribución

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íncronos. Los procesos son el medio principal para estructurar una aplicación Erlang. No son procesos ni subprocesos del sistema operativo, sino procesos ligeros programados por BEAM. Al igual que los procesos del sistema operativo (pero a diferencia de los subprocesos del sistema operativo), no comparten estado entre sí. La sobrecarga mínima estimada para cada uno es de 300 palabras.Por lo tanto, se pueden crear muchos procesos sin degradar el rendimiento. En 2005, se realizó con éxito un benchmark con 20 millones de procesos con Erlang de 64 bits en una máquina con 16 GB de memoria de acceso aleatorio (RAM; total de 800 bytes/proceso). Erlang admite el multiprocesamiento simétrico desde el lanzamiento 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 simultaneidad 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 aún usa internamente un esquema de bloqueo).

La comunicación entre procesos funciona a través de un sistema de paso de mensajes asincrónico sin nada compartido: cada proceso tiene un "buzón", una cola de mensajes que han sido enviados por otros procesos y aún no consumidos. Un proceso usa la receiveprimitiva para recuperar mensajes que coinciden con los patrones deseados. Una rutina de manejo de mensajes prueba los mensajes a su vez contra 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 las primitivas (enteros, flotantes, caracteres, átomos), tuplas, listas y funciones.

El siguiente ejemplo de código muestra el soporte integrado para procesos distribuidos:

 % Cree un proceso e invoque 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 (asincrónicamente). 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 }  ->  manejar (Contenido de datos); 
         { hola,  Texto }  ->  io : format ("Recibí un mensaje de saludo: ~s ",  [ Texto ]); 
         { adiós,  Texto }  ->  io : format ("Recibí un mensaje de despedida: ~s ",  [ Texto]) 
 fin .

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 como la comunicación con los procesos locales.

La concurrencia es compatible con el método principal de manejo de errores en Erlang. Cuando un proceso se bloquea, sale ordenadamente y envía un mensaje al proceso de control que luego puede tomar medidas, como iniciar un nuevo proceso que se hace cargo de la tarea del proceso anterior.

Implementación

La implementación de referencia oficial de Erlang utiliza BEAM. BEAM está incluido en la distribución oficial de Erlang, denominada Erlang/OTP. BEAM ejecuta el código de bytes que se convierte en código enhebrado en el momento de la carga. También incluye un compilador de código nativo en la mayoría de las plataformas, desarrollado por High Performance Erlang Project (HiPE) en la Universidad de Uppsala. Desde octubre de 2001, el sistema HiPE está completamente integrado en el sistema Open Source Erlang/OTP de Ericsson. También admite la interpretación, directamente desde el código fuente a través del árbol de sintaxis abstracta, a través de un script a partir de la versión R11B-5 de Erlang.

Módulos y carga de código caliente

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 simultáneamente el código de cada uno. Las versiones se denominan versión "nueva" y "antigua". Un proceso no pasará a la nueva versión hasta que haga una llamada externa a su módulo.

Un ejemplo del mecanismo de carga de código caliente:

  %% Un proceso cuyo único trabajo es mantener un contador. 
  %% Primera versión 
  - módulo (contador). 
  - exportar ([ inicio / 0,  codeswitch / 1 ]).

  inicio ()  ->  bucle (0).

  bucle (Suma)  -> 
    recibir 
       { incremento,  Cuenta }  -> 
          bucle (Suma + Cuenta); 
       { contador,  Pid }  -> 
          Pid  !  { contador,  Suma }, 
          bucle (Suma); 
       cambio_de_código  -> 
          ? MÓDULO: codeswitch (Suma) 
          % Forzar 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,  codeswitch / 1 ]).

  inicio ()  ->  bucle (0).

  bucle (Suma)  -> 
    recibir 
       { incremento,  Cuenta }  -> 
          bucle (Suma + Cuenta); 
       restablecer  -> 
          bucle (0); 
       { contador,  Pid }  -> 
          Pid  !  { contador,  Suma }, 
          bucle (Suma); 
       cambio_de_código  -> 
          ? MÓDULO: final del interruptor de código (Suma) 
.

  interruptor de código (Suma)  ->  bucle (Suma).

Solo cuando recibe un mensaje que consiste en el átomo code_switch, el ciclo ejecutará una llamada externa a codeswitch/1 (?MODULEes 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 le 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 los principios de diseño de Open Telecom Platform, lo que conduce a más diseños actualizables de código. La carga exitosa de código caliente es exigente. El código debe escribirse con cuidado para hacer uso de las instalaciones de Erlang.

Distribución

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 de OTP. Ericsson y algunas otras empresas respaldan comercialmente a Erlang.

Desde el lanzamiento de código abierto, Erlang ha sido utilizado por varias empresas en todo el mundo, incluidas Nortel y T-Mobile. Aunque Erlang fue diseñado para llenar un nicho y se ha mantenido como un lenguaje oscuro durante la mayor parte de su existencia, su popularidad está creciendo debido a la demanda de servicios concurrentes. Erlang ha encontrado algún uso en el campo de servidores de juegos de rol en línea multijugador masivo (MMORPG).