Erlang (linguagem de programação)

Erlang (UR-lang) é uma linguagem de programação funcional de alto nível, concorrente e de uso geral e um sistema de tempo de execução com coleta de lixo. O termo Erlang é usado de forma intercambiável com Erlang/OTP, ou Open Telecom Platform (OTP), que consiste no sistema de tempo de execução Erlang, vários componentes prontos para uso (OTP) escritos principalmente em Erlang e um conjunto de princípios de design para Erlang programas.

O sistema de tempo de execução Erlang é projetado para sistemas com estas características:

• Distribuição
• tolerante a falhas
• Macio em tempo real
• Aplicações altamente disponíveis, sem parar
• Troca quente, onde o código pode ser alterado sem parar um sistema.

A linguagem de programação Erlang possui dados imutáveis, correspondência de padrões e programação funcional. O subconjunto sequencial da linguagem Erlang oferece suporte a avaliação ansiosa, atribuição única e digitação dinâmica.

Um aplicativo Erlang normal é construído a partir de centenas de pequenos processos Erlang.

Era originalmente um software proprietário da Ericsson, desenvolvido por Joe Armstrong, Robert Virding e Mike Williams em 1986, mas foi lançado como software livre e de código aberto em 1998. Erlang/OTP é suportado e mantido pela Open Telecom Platform (OTP) na Ericsson.

História

O nome Erlang, atribuído a Bjarne Däcker, foi presumido por aqueles que trabalham nos comutadores de telefonia (para quem o idioma foi projetado) como uma referência ao matemático e engenheiro dinamarquês Agner Krarup Erlang e uma abreviação silábica de "Ericsson Language". Erlang foi projetado com o objetivo de melhorar o desenvolvimento de aplicações de telefonia. A versão inicial do Erlang foi implementada em Prolog e foi influenciada pela linguagem de programação PLEX usada nas trocas anteriores da Ericsson. Em 1988, Erlang provou que era adequado para prototipar centrais telefônicas, mas o interpretador Prolog era muito lento. Um grupo dentro da Ericsson estimou que precisaria ser 40 vezes mais rápido para ser adequado para uso em produção. Em 1992, o trabalho começou na máquina virtual BEAM (VM) que compila Erlang para C usando uma mistura de código compilado nativamente e código encadeado para encontrar um equilíbrio entre desempenho e espaço em disco. De acordo com o co-inventor Joe Armstrong, a linguagem passou de produto de laboratório para aplicações reais após o colapso da central telefônica AX de próxima geração chamada AXE-N em 1995. Como resultado, Erlang foi escolhido para o próximo Modo de Transferência Assíncrona (ATM).) troque AXD.

Robert Virding e Joe Armstrong, 2013

Mike Williams

Em fevereiro de 1998, a Ericsson Radio Systems proibiu o uso interno de Erlang para novos produtos, citando uma preferência por idiomas não proprietários. A proibição fez com que Armstrong e outros fizessem planos para deixar a Ericsson. Em março de 1998, a Ericsson anunciou o switch AXD301, contendo mais de um milhão de linhas de Erlang e relatado para atingir uma alta disponibilidade de nove "9"s. Em dezembro de 1998, a implementação de Erlang foi de código aberto e a maior parte da equipe de Erlang renunciou para formar uma nova empresa Bluetail AB. A Ericsson acabou relaxando a proibição e recontratou Armstrong em 2004.

Em 2006, o suporte de multiprocessamento simétrico nativo foi adicionado ao sistema de tempo de execução e à VM.

Processos

Os aplicativos Erlang são construídos com processos Erlang muito leves no sistema de tempo de execução Erlang. Os processos Erlang podem ser vistos como "vivos" objetos (programação orientada a objetos), com encapsulamento de dados e passagem de mensagens, mas capaz de mudar o comportamento durante o tempo de execução. O sistema de tempo de execução Erlang fornece isolamento de processo estrito entre processos Erlang (isso inclui dados e coleta de lixo, separados individualmente por cada processo Erlang) e comunicação transparente entre processos (consulte Transparência de localização) em diferentes nós Erlang (em hosts diferentes).

Joe Armstrong, co-inventor de Erlang, resumiu os princípios dos processos em sua tese de doutorado:

• Tudo é um processo.
• Os processos são fortemente isolados.
• Criação de processos e destruição é uma operação leve.
• A passagem da mensagem é a única maneira de os processos interagirem.
• Os processos têm nomes únicos.
• Se você sabe o nome de um processo, você pode enviar uma mensagem.
• Processos não compartilham recursos.
• O tratamento de erros não é local.
• Os processos fazem o que devem fazer ou falhar.

Joe Armstrong comentou em uma entrevista para a Rackspace em 2013: "Se Java é 'escreva uma vez, execute em qualquer lugar', então Erlang é 'escreva uma vez, execute para sempre'. "

Uso

Em 2014, a Ericsson informou que o Erlang estava sendo usado em seus nós de suporte e nas redes móveis GPRS, 3G e LTE em todo o mundo e também pela Nortel e T-Mobile.

Erlang é usado no RabbitMQ. Como Tim Bray, diretor de tecnologias da Web da Sun Microsystems, expressou em sua palestra na O'Reilly Open Source Convention (OSCON) em julho de 2008:

Se alguém veio até mim e queria me pagar muito dinheiro para construir um sistema de manuseamento de mensagens de grande escala que realmente tinha que estar acordado o tempo todo, nunca poderia dar ao luxo de descer por anos de cada vez, eu escolheria sem hesitar Erlang para construí-lo.

Erlang é a linguagem de programação usada para codificar o WhatsApp.

Elixir é uma linguagem de programação que compila em código de bytes BEAM (via Erlang Abstract Format).

Desde que foi lançado como código aberto, o Erlang tem se espalhado além das telecomunicações, estabelecendo-se em outros mercados verticais, como FinTech, jogos, saúde, automotivo, internet das coisas e blockchain. Além do WhatsApp, existem outras empresas listadas como histórias de sucesso de Erlang: Vocalink (empresa MasterCard), Goldman Sachs, Nintendo, AdRoll, Grindr, BT Mobile, Samsung, OpenX e SITA.

Exemplos de programação funcional

Fatorial

Um algoritmo fatorial implementado em Erlang:

- Não.módulo(facto). % Este é o arquivo 'fact.erl', o módulo e o nome do arquivo devem corresponder- Não.exportação(Fac.../1). % Isso exporta a função 'fac' de arity 1 (1 parâmetro, nenhum tipo, nenhum nome)Fac...(0) - Sim. 1; % Se 0, então retornar 1, caso contrário (note o ponto e vírgula; significando 'else')Fac...(N) quando N > 0, Imposição(N) - Sim. N * Fac...(N- Não.1).% Determine novamente, em seguida, retorne o resultado% (note o período. significa "endif" ou "function end")% Esta função irá falhar se algo além de um inteiro nonnegative for dado.% Ele ilustra a filosofia "Deixe cair" de Erlang.

Sequência de Fibonacci

Um algoritmo recursivo de cauda que produz a sequência de Fibonacci:

% A declaração do módulo deve corresponder ao nome do arquivo "series.erl" - Não.módulo(séries).% A declaração de exportação contém uma lista de todas as funções que formam%% da API pública do módulo. Neste caso, este módulo expõe um único%% função chamada fib que leva 1 argumento (I.E. tem uma aridade de 1)% A sintaxe geral para -export é uma lista contendo o nome e%% aridade de cada função pública- Não.exportação(Fim./1).% -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------%% API pública% -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------%% Lidar com casos em que o fib/1 recebe valores específicos% A ordem em que estas assinaturas de função são declaradas é vital%% parte da funcionalidade deste módulo%% Se o fib/1 é passado precisamente o inteiro 0, então retorna 0Fim.(0) - Sim. 0;%% Se fib/1 receber um número negativo, em seguida, retornar o atom err_neg_val%% Normalmente, tal codificação defensiva é desencorajada devido a Erlang 'Let%% ela Crash' filosofia; no entanto, neste caso devemos explicitamente%% evitar uma situação que vai travar o motor de tempo de execução de ErlangFim.(N) quando N < 0 - Sim. Erro:;%% Se o fib/1 for passado um inteiro inferior a 3, então retorna 1% As assinaturas de duas funções anteriores lidam com todos os casos em que N < 1,%% assim que esta assinatura de função lida com casos em que N = 1 ou N = 2Fim.(N) quando N < 3 - Sim. 1;% Para todos os outros valores, ligue para a função privada fib_int/3 para executar%% do cálculoFim.(N) - Sim. - Não.(N, 0, 1).% -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------%% API privada% -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------% Se fib_int/3 receber um 1 como seu primeiro argumento, então estamos acabados, então%% retorna o valor no argumento B. Desde que não estamos interessados em%% valor do segundo argumento, denotamos este uso _ para indicar um%% "não se importa" valor- Não.(1, Não. B) - Sim. B;% Para todas as outras combinações de argumentos, recursivamente chame fib_int/3%% em que cada chamada faz o seguinte:%% - contador de decrement N%% - Tomar o valor fibonacci anterior no argumento B e passá-lo como%% argumento A%% - Calcular o valor do número de fibonacci atual e passá-lo%% como argumento B- Não.(N, A, B) - Sim. - Não.(N- Não.1, B, A+B).

Aqui está o mesmo programa sem os comentários explicativos:

- Não.módulo(séries).- Não.exportação(Fim./1).Fim.(0) - Sim. 0;Fim.(N) quando N < 0 - Sim. Erro:;Fim.(N) quando N < 3 - Sim. 1;Fim.(N) - Sim. - Não.(N, 0, 1).- Não.(1, Não. B) - Sim. B;- Não.(N, A, B) - Sim. - Não.(N- Não.1, B, A+B).

Classificação rápida

Quicksort em Erlang, usando compreensão de lista:

%% qsort: qsort (Lista)% Ordenar uma lista de itens- Não.módulo(Qsort). % Este é o arquivo 'qsort.erl '- Não.exportação(Qsort/1). % Uma função 'qsort' com 1 parâmetro é exportada (nenhum tipo, nenhum nome)Qsort([]) - Sim. [] % Se a lista [] estiver vazia, retorne uma lista vazia (nada a classificar)Qsort(Pivot|Descanso] - Sim. % Compose recursivamente uma lista com 'Front' para todos os elementos que devem ser antes 'Pivot' % então 'Pivot' então 'Back' para todos os elementos que devem ser após 'Pivot ' Qsort(Frente | Frente < Descanso, Frente < Pivot] ++  Não.Pivot] ++ Qsort(Voltar | Voltar < Descanso, Voltar - Sim. Pivot).

O exemplo acima invoca recursivamente a função qsort até que não reste nada para ser classificado. A expressão [Frente || Frente <- Descanso, Frente < Pivot] é uma compreensão de lista, significando "Construa uma lista de elementos Front de modo que Front seja um membro de Rest, e Frente é menor que Pivot." ++ é o operador de concatenação da lista.

Uma função de comparação pode ser usada para estruturas mais complicadas para facilitar a leitura.

O código a seguir classificaria as listas de acordo com o tamanho:

% Este é o arquivo 'listsort.erl' (o compilador é feito desta forma)- Não.módulo(lista).% Exportar 'by_length' com 1 parâmetro (não se importa com o tipo e o nome)- Não.exportação(por_comprimento/1).por_comprimento(Listas) - Sim. % Use 'qsort/2' e fornece uma função anônima como parâmetro Qsort(Listas, diversão(A,B) - Sim. comprimento(A) < comprimento(B) fim).Qsort[[] O quê?- Sim. [] % Se a lista estiver vazia, retorne uma lista vazia (ignore o segundo parâmetro)Qsort(Pivot|Descanso] Mais pequeno) - Sim. % Lista de partições com elementos 'Smaller' em frente aos elementos 'Pivot' e não-'Smaller' % após 'Pivot' e classificar as sublistas. Qsort(X | X < Descanso, Mais pequeno(X,Pivot)], Mais pequeno) ++ Não.Pivot] ++ Qsort(Y | Y < Descanso, não(Mais pequeno(Y, Pivot)], Mais pequeno).

Um Pivot é retirado do primeiro parâmetro dado a qsort() e o resto das Lists é nomeado Rest. Note que a expressão

Não.X | X < Descanso, Mais pequeno(X,Pivot)

não é diferente em forma de

Não.Frente | Frente < Descanso, Frente < Pivot]

(no exemplo anterior) exceto pelo uso de uma função de comparação na última parte, dizendo "Construa uma lista de elementos X tal que X é um membro de Rest e Smaller é true", com Smaller sendo definido anteriormente como

diversão(A,B) - Sim. comprimento(A) < comprimento(B) fim

A função anônima é nomeada Smaller na lista de parâmetros da segunda definição de qsort para que possa ser referenciada por esse nome dentro dessa função. Ela não é nomeada na primeira definição de qsort, que lida com o caso base de uma lista vazia e, portanto, não precisa dessa função, muito menos de um nome para ela.

Tipos de dados

Erlang tem oito tipos de dados primitivos:

Integers

Os inteiros são escritos como sequências de dígitos decimais, por exemplo, 12, 12375 e -23427 são inteiros. A aritmética do inteiro é exata e limitada apenas pela memória disponível na máquina. (Isso é chamado aritmética de precisão arbitrária.)

Átomos

Os átomos são usados dentro de um programa para denotar valores distintos. Eles são escritos como cordas de caracteres alfanuméricos consecutivos, o primeiro caractere sendo minúsculo. Os átomos podem conter qualquer personagem se forem incluídos dentro de citações únicas e existe uma convenção de escape que permita que qualquer personagem seja usado dentro de um átomo. Os átomos nunca são coletados e devem ser usados com cautela, especialmente se usar geração de átomos dinâmicos.

Floats

Os números de ponto flutuante usam a representação de 64 bits IEEE 754.

Referências

As referências são símbolos globalmente únicos cuja única propriedade é que eles podem ser comparados para a igualdade. Eles são criados avaliando o primitivo Erlang make_ref().

Binários

Um binário é uma sequência de bytes. Os binários fornecem uma maneira eficiente de armazenar dados binários. Os primitivos Erlang existem para compor e decompor binários e para entrada/saída eficiente de binários.

Planejadores do casamento

Pid é curto para identificador de processo– um Pid é criado pelo primitivo Erlang spawn(...) Pids são referências aos processos Erlang.

Portos

Os portos são usados para se comunicar com o mundo externo. Os portos são criados com a função embutida open_port. As mensagens podem ser enviadas e recebidas dos portos, mas essas mensagens devem obedecer ao chamado "protocolo de porto".

Funs

Funs são fechamentos de função. Funs são criados por expressões da forma: fun(...) ->... end.

E três tipos de dados compostos:

Tuplas

Tuplas são recipientes para um número fixo de tipos de dados Erlang. A sintaxe {D1,D2,...,Dn} denota um tupla cujos argumentos são D1, D2,... Dn. Os argumentos podem ser tipos de dados primitivos ou tipos de dados compostos. Qualquer elemento de um tupla pode ser acessado em tempo constante.

Listas

As listas são recipientes para um número variável de tipos de dados Erlang. A sintaxe [Dh|Dt] denota uma lista cujo primeiro elemento é Dh, e cujos elementos restantes são a lista Dt. A sintaxe [] denota uma lista vazia. A sintaxe [D1,D2,..,Dn] é curto para [D1|[D2|..|[Dn|[]]]]. O primeiro elemento de uma lista pode ser acessado em tempo constante. O primeiro elemento de uma lista é chamado de cabeça da lista. O restante de uma lista quando sua cabeça foi removida é chamado de cauda da lista.

Mapas

Os mapas contêm um número variável de associações de valor-chave. A sintaxe é#{Key1=>Value1,...,KeyN=>ValueN}.

Duas formas de açúcar sintático são fornecidas:

Cordas

As cordas são escritas como duplamente citadas listas de caracteres. Este é o açúcar sintático para uma lista dos pontos de código Unicode inteiro para os caracteres na string. Assim, por exemplo, a string "cat" é shorthand para [99,97,116].

Registros

Os registros fornecem uma maneira conveniente para associar uma tag com cada um dos elementos em um tupla. Isso permite se referir a um elemento de um tupla por nome e não por posição. Um pré-compilador toma a definição de registro e substitui-a com a referência de tupla apropriada.

Erlang não possui método para definir classes, embora existam bibliotecas externas disponíveis.

"Deixa travar" estilo de codificação

Erlang foi projetado com um mecanismo que facilita o monitoramento de falhas (ou falhas de hardware) por processos externos, em vez de um mecanismo em processo, como o tratamento de exceções usado em muitas outras linguagens de programação. As falhas são relatadas como outras mensagens, que é a única maneira pela qual os processos podem se comunicar uns com os outros, e os subprocessos podem ser gerados de forma barata (veja abaixo). O "deixá-lo travar" A filosofia prefere que um processo seja completamente reiniciado em vez de tentar se recuperar de uma falha grave. Embora ainda exija tratamento de erros, essa filosofia resulta em menos código dedicado à programação defensiva, onde o código de tratamento de erros é altamente contextual e específico.

Árvores do supervisor

Um aplicativo Erlang típico é escrito na forma de uma árvore supervisora. Essa arquitetura é baseada em uma hierarquia de processos em que o processo de nível superior é conhecido como "supervisor". O supervisor então gera vários processos filho que atuam como trabalhadores ou mais, supervisores de nível inferior. Essas hierarquias podem existir em profundidades arbitrárias e provaram fornecer um ambiente altamente escalável e tolerante a falhas no qual a funcionalidade do aplicativo pode ser implementada.

Em uma árvore de supervisor, todos os processos supervisores são responsáveis por gerenciar o ciclo de vida de seus processos filhos, e isso inclui lidar com situações em que esses processos filhos falham. Qualquer processo pode se tornar um supervisor primeiro gerando um processo filho e, em seguida, chamando erlang:monitor/2 nesse processo. Se o processo monitorado travar, o supervisor receberá uma mensagem contendo uma tupla cujo primeiro membro é o átomo 'DOWN'. O supervisor é responsável, em primeiro lugar, por ouvir essas mensagens e, em segundo lugar, por tomar as medidas adequadas para corrigir a condição de erro.

Orientação para simultaneidade e distribuição

A principal força de Erlang é o suporte para simultaneidade. Possui um conjunto pequeno, mas poderoso, de primitivas para criar processos e se comunicar entre eles. Erlang é conceitualmente semelhante à linguagem occam, embora reformule as ideias de comunicação de processos sequenciais (CSP) em uma estrutura funcional e use passagem de mensagens assíncrona. Os processos são os principais meios para estruturar um aplicativo Erlang. Eles não são processos do sistema operacional nem threads, mas processos leves que são agendados pelo BEAM. Como os processos do sistema operacional (mas ao contrário dos encadeamentos do sistema operacional), eles não compartilham nenhum estado entre si. A sobrecarga mínima estimada para cada um é de 300 palavras. Assim, muitos processos podem ser criados sem degradação do desempenho. Em 2005, um benchmark com 20 milhões de processos foi realizado com sucesso com Erlang de 64 bits em uma máquina com 16 GB de memória de acesso aleatório (RAM; total de 800 bytes/processo). Erlang suporta multiprocessamento simétrico desde o lançamento R11B de maio de 2006.

Embora os threads precisem de suporte de biblioteca externa na maioria das linguagens, o Erlang fornece recursos de nível de linguagem para criar e gerenciar processos com o objetivo de simplificar a programação simultânea. Embora toda a simultaneidade seja explícita em Erlang, os processos se comunicam usando passagem de mensagem em vez de variáveis compartilhadas, o que elimina a necessidade de bloqueios explícitos (um esquema de bloqueio ainda é usado internamente pela VM).

A comunicação entre processos funciona através de um sistema de passagem de mensagens assíncronas sem compartilhamento: cada processo tem uma "caixa de correio", uma fila de mensagens que foram enviadas por outros processos e ainda não foram consumidas. Um processo usa a primitiva receive para recuperar mensagens que correspondem aos padrões desejados. Uma rotina de manipulação de mensagens testa as mensagens em cada padrão, até que uma delas corresponda. Quando a mensagem é consumida e removida da caixa de correio, o processo retoma a execução. Uma mensagem pode incluir qualquer estrutura Erlang, incluindo primitivas (inteiros, floats, caracteres, átomos), tuplas, listas e funções.

O exemplo de código abaixo mostra o suporte integrado para processos distribuídos:

 % Criar um processo e invocar a função web:start_server(Port, MaxConnections) Processos de Servidor = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Sábio(Web site web, start_server, Não.Porto, MaxConnections] % Criar um processo remoto e invocar a função % web:start_server(Port, MaxConnections) na máquina RemoteNode Processos remotos = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Sábio(Node remoto, Web site web, start_server, Não.Porto, MaxConnections] % Enviar mensagem para ServerProcess (assincronamente). A mensagem consiste em um tupla % com o átomo "pausa" e o número "10". Processos de Servidor ! (pausa, 10.} % Receber mensagens enviadas para este processo receber a_message - Sim. Do_algo; (dados, Contenção de dados? - Sim. alça(Contenção de dados); (Olá., Texto? - Sim. I:formato("Olá à mensagem: ~", Não.Texto); (Adeus., Texto? - Sim. I:formato("Tem uma mensagem de despedida: ~", Não.Texto] fim.

Como o exemplo mostra, processos podem ser criados em nós remotos, e a comunicação com eles é transparente no sentido de que a comunicação com processos remotos funciona exatamente como comunicação com processos locais.

A simultaneidade oferece suporte ao método principal de tratamento de erros em Erlang. Quando um processo trava, ele sai e envia uma mensagem para o processo de controle, que pode então agir, como iniciar um novo processo que assume a tarefa do processo antigo.

Implementação

A implementação de referência oficial de Erlang usa BEAM. O BEAM está incluído na distribuição oficial do Erlang, chamada Erlang/OTP. BEAM executa bytecode que é convertido em código encadeado no tempo de carregamento. Ele também inclui um compilador de código nativo na maioria das plataformas, desenvolvido pelo High Performance Erlang Project (HiPE) na Uppsala University. Desde outubro de 2001, o sistema HiPE está totalmente integrado ao sistema Open Source Erlang/OTP da Ericsson. Ele também oferece suporte à interpretação, diretamente do código-fonte via árvore de sintaxe abstrata, via script a partir do lançamento R11B-5 de Erlang.

Carregamento de hot code e módulos

Erlang suporta atualização dinâmica de software em nível de idioma. Para implementar isso, o código é carregado e gerenciado como "módulo" unidades; o módulo é uma unidade de compilação. O sistema pode manter duas versões de um módulo na memória ao mesmo tempo e os processos podem executar simultaneamente o código de cada um. As versões são chamadas de "novo" e o "velho" versão. Um processo não passará para a nova versão até que faça uma chamada externa para seu módulo.

Um exemplo do mecanismo de carregamento de hot code:

 %% Um processo cujo único trabalho é manter um contador. %% Primeira versão - Não.módulo(contador). - Não.exportação(início/0, Códigoswitch/1). início() - Sim. loop(0). loop(Sumário) - Sim. receber (incremento, Contagem? - Sim. loop(Sumário+Contagem); (contador, Pid? - Sim. Pid ! (contador, Sumário} loop(Sumário); Códigos - Sim. ?MODULO:Códigoswitch(Sumário) % Forçar o uso de 'codeswitch/1' da última versão MODULE fim. Códigoswitch(Sumário) - Sim. loop(Sumário).

Para a segunda versão, adicionamos a possibilidade de zerar a contagem.

 %% Segunda versão - Não.módulo(contador). - Não.exportação(início/0, Códigoswitch/1). início() - Sim. loop(0). loop(Sumário) - Sim. receber (incremento, Contagem? - Sim. loop(Sumário+Contagem); resetar - Sim. loop(0); (contador, Pid? - Sim. Pid ! (contador, Sumário} loop(Sumário); Códigos - Sim. ?MODULO:Códigoswitch(Sumário) fim. Códigoswitch(Sumário) - Sim. loop(Sumário).

Somente ao receber uma mensagem que consiste no átomo code_switch o loop executará uma chamada externa para codeswitch/1 (?MODULE é uma macro de pré-processador para o módulo atual). Se houver uma nova versão do módulo contador na memória, então sua função codewitch/1 será chamada. A prática de ter um ponto de entrada específico em uma nova versão permite que o programador transforme o estado para o que é necessário na versão mais recente. No exemplo, o estado é mantido como um número inteiro.

Na prática, os sistemas são construídos usando princípios de design da Open Telecom Platform, o que leva a mais designs de código atualizáveis. O carregamento de hot code bem-sucedido é exigente. O código deve ser escrito com cuidado para fazer uso das facilidades de Erlang.

Distribuição

Em 1998, a Ericsson lançou o Erlang como software livre e de código aberto para garantir sua independência de um único fornecedor e aumentar o conhecimento do idioma. Erlang, juntamente com as bibliotecas e o banco de dados distribuído em tempo real Mnesia, forma a coleção OTP de bibliotecas. A Ericsson e algumas outras empresas oferecem suporte comercial ao Erlang.

Desde o lançamento do código aberto, Erlang tem sido usado por várias empresas em todo o mundo, incluindo Nortel e T-Mobile. Embora o Erlang tenha sido projetado para preencher um nicho e tenha permanecido uma linguagem obscura durante a maior parte de sua existência, sua popularidade está crescendo devido à demanda por serviços simultâneos. Erlang encontrou algum uso em servidores de jogos de RPG online massivamente multijogador (MMORPG).