Эрланг (язык программирования)

Эрланг

Парадигмы	Мультипарадигма : параллельная , функциональная , объектно-ориентированная.
Разработано	Джо Армстронг Роберт Вирдинг Майк Уильямс
Разработчик	Эрикссон
Впервые появился	1986 год ( 1986 )
Стабильная версия	27.0.1   / 10 июля 2024 г ( 10 июля 2024 г. )
Дисциплина набора текста	Динамичный , сильный
Лицензия	Лицензия Апач 2.0
Расширения имен файлов	.erl, .hrl
Веб-сайт	www .эрланг .org
Основные реализации
Эрланг
Под влиянием
Лисп , ПЛЕКС , Пролог , Смолток
Под влиянием
Например , Clojure , Дротик , Эликсир , F# , Опа , Оз , Рейя , Ржавчина , Масштаб , вперед
Программирование на Erlang в Wikibooks

Эрланг ( / ˈ ɜːr l æ ŋ / UR -lang ) — универсальный , параллельный , функциональный высокого уровня язык программирования и со сборкой мусора система времени выполнения . Термин Erlang используется взаимозаменяемо с Erlang/OTP или Open Telecom Platform (OTP), которая состоит из системы времени выполнения Erlang , нескольких готовых к использованию компонентов (OTP), в основном написанных на Erlang, и набора принципов проектирования для Erlang. программы.

Erlang Система времени выполнения предназначена для систем со следующими характеристиками:

• Распределенный
• Отказоустойчивый
• Мягкий режим реального времени
• Высокодоступные , бесперебойные приложения
• Горячая замена , при которой код можно изменить, не останавливая систему.

Erlang Язык программирования имеет неизменяемые данные, сопоставление с образцом и функциональное программирование . Последовательное подмножество языка Erlang поддерживает быстрое вычисление , однократное присваивание и динамическую типизацию .

Обычное приложение Erlang состоит из сотен небольших процессов Erlang.

Первоначально это было проприетарное программное обеспечение компании Ericsson , разработанное Джо Армстронгом , Робертом Вирдингом и Майком Уильямсом в 1986 году. но был выпущен как бесплатное программное обеспечение с открытым исходным кодом в 1998 году. Erlang/OTP поддерживается и обслуживается подразделением продуктов Open Telecom Platform (OTP) компании Ericsson .

История

имя Erlang Те, кто работал над телефонными коммутаторами (для которых был разработан этот язык), предположили, что , приписываемое Бьярну Дэккеру, является отсылкой к датскому математику и инженеру Агнеру Крарупу Эрлангу и слоговой аббревиатурой «Ericsson Language». Erlang был разработан с целью улучшения разработки телефонных приложений. Первоначальная версия Erlang была реализована на Прологе и находилась под влиянием языка программирования PLEX, использовавшегося на более ранних биржах Ericsson. К 1988 году Эрланг доказал, что он пригоден для создания прототипов телефонных станций, но интерпретатор Пролога был слишком медленным. Одна группа из Ericsson подсчитала, что для промышленного использования он должен быть в 40 раз быстрее. В 1992 году началась работа над виртуальной машиной BEAM (VM), которая компилирует Erlang в C, используя сочетание скомпилированного кода и многопоточного кода для достижения баланса между производительностью и дисковым пространством. По словам соавтора Джо Армстронга, язык превратился из лабораторного продукта в реальные приложения после краха телефонной станции AX следующего поколения под названием AXE-N в 1995 году. В результате Erlang был выбран в качестве следующего режима асинхронной передачи (ATM). ) обмен AXD .

Роберт Вирдинг и Джо Армстронг, 2013 г.

Майк Уильямс

В феврале 1998 года Ericsson Radio Systems запретила внутреннее использование Erlang для новых продуктов, сославшись на предпочтение непатентованных языков. Запрет заставил Армстронга и других строить планы покинуть Ericsson. В марте 1998 года Ericsson анонсировала коммутатор AXD301. содержит более миллиона строк Erlang и, как сообщается, обеспечивает высокую доступность девяти «9» . В декабре 1998 года реализация Erlang была открыта, и большая часть команды Erlang ушла в отставку и основала новую компанию Bluetail AB. В конце концов Эрикссон ослабил запрет и повторно нанял Армстронга в 2004 году.

В 2006 году симметричной многопроцессорности . в систему выполнения и виртуальную машину была добавлена ​​встроенная поддержка

Процессы

Приложения Erlang состоят из очень легких процессов Erlang в системе времени выполнения Erlang. Процессы Erlang можно рассматривать как «живые» объекты ( объектно-ориентированное программирование ), с инкапсуляцией данных и передачей сообщений , но способные изменять поведение во время выполнения. Система времени выполнения Erlang обеспечивает строгую изоляцию процессов между процессами Erlang (сюда входят данные и сбор мусора, разделенные индивидуально каждым процессом Erlang) и прозрачную связь между процессами (см. Прозрачность расположения ) на разных узлах Erlang (на разных хостах).

Джо Армстронг, соавтор Эрланга, обобщил принципы процессов в своей докторской диссертации :

• Все есть процесс.
• Процессы сильно изолированы.
• Создание и уничтожение процессов — это легкая операция.
• Передача сообщений — единственный способ взаимодействия процессов.
• Процессы имеют уникальные имена.
• Если вы знаете имя процесса, вы можете отправить ему сообщение.
• Процессы не имеют общих ресурсов.
• Обработка ошибок нелокальна.
• Процессы делают то, что должны делать, или терпят неудачу.

Джо Армстронг заметил в интервью Rackspace в 2013 году: «Если Java — это « напиши один раз, запускай где угодно », то Erlang — это «напиши один раз, работай вечно».

Использование

В 2014 году Ericsson сообщила, что Erlang используется в ее узлах поддержки, а также в мобильных сетях GPRS , 3G и LTE по всему миру, а также Nortel и T-Mobile .

Эрланг используется в RabbitMQ . Как сказал Тим Брэй , директор по веб-технологиям компании Sun Microsystems , в своем программном докладе на конференции O'Reilly Open Source Convention (OSCON) в июле 2008 года:

Если бы кто-то пришел ко мне и захотел заплатить мне много денег за создание крупномасштабной системы обработки сообщений, которая действительно должна была бы постоянно работать и не могла позволить себе выходить из строя в течение многих лет, я бы без колебаний выбрал Erlang встроить его.

Erlang — это язык программирования, используемый для написания кода WhatsApp .

Это также язык, выбранный для Ejabberd — сервера обмена сообщениями XMPP .

Эликсир — это язык программирования, который компилируется в байт-код BEAM (через абстрактный формат Erlang).

С момента выпуска с открытым исходным кодом Erlang вышел за пределы телекоммуникаций, зарекомендовав себя на других вертикальных рынках, таких как финансовые технологии, игры, здравоохранение, автомобилестроение, Интернет вещей и блокчейн. Помимо WhatsApp, в список историй успеха Erlang входят и другие компании: Vocalink (компания MasterCard), Goldman Sachs , Nintendo , AdRoll, Grindr , BT Mobile , Samsung , OpenX и SITA .

Примеры функционального программирования

Факториал

Алгоритм факториала, реализованный в Erlang:

-module(fact). % This is the file 'fact.erl', the module and the filename must match
-export([fac/1]). % This exports the function 'fac' of arity 1 (1 parameter, no type, no name)

fac(0) -> 1; % If 0, then return 1, otherwise (note the semicolon ; meaning 'else')
fac(N) when N > 0, is_integer(N) -> N * fac(N-1).
% Recursively determine, then return the result
% (note the period . meaning 'endif' or 'function end')
%% This function will crash if anything other than a nonnegative integer is given.
%% It illustrates the "Let it crash" philosophy of Erlang.

Последовательность Фибоначчи

Алгоритм хвостовой рекурсии, создающий последовательность Фибоначчи :

%% The module declaration must match the file name "series.erl" 
-module(series).

%% The export statement contains a list of all those functions that form
%% the module's public API.  In this case, this module exposes a single
%% function called fib that takes 1 argument (I.E. has an arity of 1)
%% The general syntax for -export is a list containing the name and
%% arity of each public function
-export([fib/1]).

%% ---------------------------------------------------------------------
%% Public API
%% ---------------------------------------------------------------------

%% Handle cases in which fib/1 receives specific values
%% The order in which these function signatures are declared is a vital
%% part of this module's functionality

%% If fib/1 receives a negative number, then return the atom err_neg_val
%% Normally, such defensive coding is discouraged due to Erlang's 'Let
%% it Crash' philosophy, but here the result would be an infinite loop.
fib(N) when N < 0 -> err_neg_val;

%% If fib/1 is passed precisely the integer 0, then return 0
fib(0) -> 0;

%% For all other values, call the private function fib_int/3 to perform
%% the calculation
fib(N) -> fib_int(N-1, 0, 1).

%% ---------------------------------------------------------------------
%% Private API
%% ---------------------------------------------------------------------

%% If fib_int/3 receives 0 as its first argument, then we're done, so
%% return the value in argument B. The second argument is denoted _ to
%% to disregard its value.
fib_int(0, _, B) -> B;

%% For all other argument combinations, recursively call fib_int/3
%% where each call does the following:
%%  - decrement counter N
%%  - pass the third argument as the new second argument
%%  - pass the sum of the second and third arguments as the new
%%    third argument
fib_int(N, A, B) -> fib_int(N-1, B, A+B).

Если опустить комментарии, программа станет гораздо короче.

-module(series).
-export([fib/1]).

fib(N) when 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).

Быстрая сортировка

Быстрая сортировка в Erlang с использованием понимания списка :

%% qsort:qsort(List)
%% Sort a list of items
-module(qsort).     % This is the file 'qsort.erl'
-export([qsort/1]). % A function 'qsort' with 1 parameter is exported (no type, no name)

qsort([]) -> []; % If the list [] is empty, return an empty list (nothing to sort)
qsort([Pivot|Rest]) ->
    % Compose recursively a list with 'Front' for all elements that should be before 'Pivot'
    % then 'Pivot' then 'Back' for all elements that should be after 'Pivot'
    qsort([Front || Front <- Rest, Front < Pivot]) ++ 
    [Pivot] ++
    qsort([Back || Back <- Rest, Back >= Pivot]).

В приведенном выше примере рекурсивно вызывается функция qsort пока не останется ничего, что нужно было бы сортировать. Выражение [Front || Front <- Rest, Front < Pivot] это понимание списка , что означает «Создать список элементов Front такой, что Front является членом Rest, и Front меньше, чем Pivot." ++ — оператор конкатенации списков.

Функцию сравнения можно использовать для более сложных структур ради удобства чтения.

Следующий код будет сортировать списки по длине:

% This is file 'listsort.erl' (the compiler is made this way)
-module(listsort).
% Export 'by_length' with 1 parameter (don't care about the type and name)
-export([by_length/1]).

by_length(Lists) -> % Use 'qsort/2' and provides an anonymous function as a parameter
   qsort(Lists, fun(A,B) -> length(A) < length(B) end).

qsort([], _)-> []; % If list is empty, return an empty list (ignore the second parameter)
qsort([Pivot|Rest], Smaller) ->
    % Partition list with 'Smaller' elements in front of 'Pivot' and not-'Smaller' elements
    % after 'Pivot' and sort the sublists.
    qsort([X || X <- Rest, Smaller(X,Pivot)], Smaller)
    ++ [Pivot] ++
    qsort([Y || Y <- Rest, not(Smaller(Y, Pivot))], Smaller).

А Pivot берется из первого параметра, заданного для qsort() и остальная часть Lists назван Rest. Обратите внимание, что выражение

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

по форме ничем не отличается от

[Front || Front <- Rest, Front < Pivot]

(в предыдущем примере), за исключением использования функции сравнения в последней части, в которой говорится: «Построить список элементов X такой, что X является членом Rest, и Smaller верно», с Smaller определялся ранее как

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

функция Анонимная называется Smaller в списке параметров второго определения qsort чтобы на него можно было ссылаться по этому имени внутри этой функции. Он не указан в первом определении qsort, который имеет дело с базовым случаем пустого списка и поэтому не нуждается в этой функции, не говоря уже о ее имени.

Типы данных

В Erlang имеется восемь примитивных типов данных :

Целые числа

Целые числа записываются как последовательности десятичных цифр, например, 12, 12375 и -23427 — целые числа. Целочисленная арифметика точна и ограничена только доступной памятью машины. (Это называется арифметикой произвольной точности .)

Атомы

Атомы используются в программе для обозначения выдающихся значений. Они записываются как строки последовательных буквенно-цифровых символов, причем первый символ имеет нижний регистр. Атомы могут содержать любой символ, если они заключены в одинарные кавычки и существует соглашение об экранировании, которое позволяет использовать любой символ внутри атома. Атомы никогда не подвергаются сборке мусора, и их следует использовать с осторожностью, особенно при использовании динамической генерации атомов.

Плавает

Числа с плавающей запятой используют 64-битное представление IEEE 754 .

Ссылки

Ссылки — это глобально уникальные символы, единственным свойством которых является возможность сравнения на равенство. Они создаются путем оценки примитива Erlang make_ref().

Бинарные файлы

Двоичный файл — это последовательность байтов. Двоичные файлы обеспечивают экономичный способ хранения двоичных данных. Примитивы Erlang существуют для составления и разложения двоичных файлов, а также для эффективного ввода/вывода двоичных файлов.

Пиды

Pid — это сокращение от идентификатора процесса — Pid создается примитивом Erlang. spawn(...) Pids — это ссылки на процессы Erlang.

Порты

Порты используются для связи с внешним миром. Порты создаются с помощью встроенной функции open_port. Сообщения можно отправлять и получать из портов, но эти сообщения должны подчиняться так называемому «протоколу порта».

Веселье

Funs — это замыкания функций . Забавы создаются выражениями вида: fun(...) -> ... end.

И три составных типа данных:

Кортежи

Кортежи — это контейнеры для фиксированного количества типов данных Erlang. Синтаксис {D1,D2,...,Dn} обозначает кортеж, аргументами которого являются D1, D2, ... Dn. Аргументы могут быть примитивными типами данных или составными типами данных. Доступ к любому элементу кортежа возможен за постоянное время.

Списки

Списки — это контейнеры для переменного количества типов данных Erlang. Синтаксис [Dh|Dt] обозначает список, первым элементом которого является Dh, а остальные элементы которого представляют собой список Dt. Синтаксис [] обозначает пустой список. Синтаксис [D1,D2,..,Dn] это сокращение от [D1|[D2|..|[Dn|[]]]]. Доступ к первому элементу списка возможен за постоянное время. Первый элемент списка называется главой списка. Оставшаяся часть списка после удаления его заголовка называется хвостом списка.

Карты

Карты содержат переменное количество ассоциаций ключ-значение. Синтаксис: #{Key1=>Value1,...,KeyN=>ValueN}.

две формы синтаксического сахара Предусмотрены :

Струны

Строки записываются как списки символов в двойных кавычках. Это синтаксический сахар для списка целочисленных кодовых точек Юникода для символов в строке. Так, например, строка «кошка» является сокращением от [99,97,116].

Рекорды

Записи предоставляют удобный способ связать тег с каждым элементом кортежа. Это позволяет ссылаться на элемент кортежа по имени, а не по позиции. Прекомпилятор берет определение записи и заменяет его соответствующей ссылкой на кортеж.

В Erlang нет метода определения классов, хотя доступны внешние библиотеки .

Стиль кодирования «Пусть сломается»

Erlang разработан с использованием механизма, который позволяет внешним процессам легко отслеживать сбои (или аппаратные сбои), а не внутрипроцессный механизм, такой как обработка исключений, используемый во многих других языках программирования. О сбоях сообщается так же, как и о других сообщениях, и это единственный способ взаимодействия процессов друг с другом. и подпроцессы можно создавать дешево (см. ниже ). Философия «позволить сбою» предпочитает полностью перезапустить процесс, а не пытаться восстановиться после серьезного сбоя. Хотя эта философия по-прежнему требует обработки ошибок, эта философия приводит к тому, что для защитного программирования выделяется меньше кода , где код обработки ошибок очень контекстуален и специфичен.

Деревья супервизора

Типичное приложение Erlang написано в виде дерева супервизоров. Эта архитектура основана на иерархии процессов, в которой процесс верхнего уровня известен как «супервизор». Затем супервизор порождает несколько дочерних процессов, которые действуют либо как рабочие, либо как супервизоры более низкого уровня. Такие иерархии могут существовать на произвольной глубине и доказали, что они обеспечивают высокомасштабируемую и отказоустойчивую среду, в которой могут быть реализованы функциональные возможности приложения.

В дереве супервизоров все процессы-супервизоры отвечают за управление жизненным циклом своих дочерних процессов, включая обработку ситуаций, в которых эти дочерние процессы выходят из строя. Любой процесс может стать супервизором, если сначала создать дочерний процесс, а затем вызвать erlang:monitor/2 на этом процессе. Если затем отслеживаемый процесс выйдет из строя, супервизор получит сообщение, содержащее кортеж, первым членом которого является атом. 'DOWN'. Супервизор несет ответственность, во-первых, за прослушивание таких сообщений и, во-вторых, за принятие соответствующих мер по исправлению ошибочного состояния.

Ориентация на параллелизм и распространение

Основная сила Erlang — поддержка параллелизма . Он имеет небольшой, но мощный набор примитивов для создания процессов и взаимодействия между ними. Erlang концептуально похож на язык occam , хотя он переосмысливает идеи взаимодействия последовательных процессов (CSP) в функциональной структуре и использует асинхронную передачу сообщений. Процессы являются основным средством структурирования приложения Erlang. Это не операционной системы процессы и не потоки , а легкие процессы , запланированные BEAM. Подобно процессам операционной системы (но в отличие от потоков операционной системы), они не имеют общего состояния друг с другом. Предполагаемый минимальный объем накладных расходов для каждого составляет 300 слов . Таким образом, многие процессы могут быть созданы без снижения производительности. В 2005 году тест с 20 миллионами процессов был успешно выполнен с использованием 64-битного Erlang на машине с оперативной памятью 16 ГБ (ОЗУ; всего 800 байт на процесс). Erlang поддерживает симметричную многопроцессорную обработку с момента выпуска R11B от мая 2006 года.

Хотя потоки нуждаются в поддержке внешних библиотек на большинстве языков, Erlang предоставляет функции уровня языка для создания процессов и управления ими с целью упрощения параллельного программирования. Хотя в Erlang весь параллелизм является явным, процессы взаимодействуют, используя передачу сообщений вместо общих переменных, что устраняет необходимость в явных блокировках (схема блокировки по-прежнему используется внутри виртуальной машины).

Межпроцессное взаимодействие работает через без общего доступа асинхронную систему передачи сообщений : каждый процесс имеет «почтовый ящик» — очередь сообщений , которые были отправлены другими процессами и еще не использованы. Процесс использует receive примитив для получения сообщений, соответствующих желаемым шаблонам. Процедура обработки сообщений по очереди проверяет сообщения на соответствие каждому шаблону, пока один из них не совпадет. Когда сообщение потребляется и удаляется из почтового ящика, процесс возобновляет выполнение. Сообщение может содержать любую структуру Erlang, включая примитивы (целые числа, числа с плавающей запятой, символы, атомы), кортежи, списки и функции.

В примере кода ниже показана встроенная поддержка распределенных процессов:

 % Create a process and invoke the function web:start_server(Port, MaxConnections)
 ServerProcess = spawn(web, start_server, [Port, MaxConnections]),

 % Create a remote process and invoke the function
 % web:start_server(Port, MaxConnections) on machine RemoteNode
 RemoteProcess = spawn(RemoteNode, web, start_server, [Port, MaxConnections]),

 % Send a message to ServerProcess (asynchronously). The message consists of a tuple
 % with the atom "pause" and the number "10".
 ServerProcess ! {pause, 10},

 % Receive messages sent to this process
 receive
         a_message -> do_something;
         {data, DataContent} -> handle(DataContent);
         {hello, Text} -> io:format("Got hello message: ~s", [Text]);
         {goodbye, Text} -> io:format("Got goodbye message: ~s", [Text])
 end.

Как показывает пример, процессы могут создаваться на удаленных узлах, и связь с ними прозрачна в том смысле, что связь с удаленными процессами работает точно так же, как связь с локальными процессами.

Параллелизм поддерживает основной метод обработки ошибок в Erlang. Когда процесс выходит из строя, он аккуратно завершает работу и отправляет сообщение управляющему процессу, который затем может предпринять действия, например запустить новый процесс, который возьмет на себя задачу старого процесса.

Выполнение

Официальная эталонная реализация Erlang использует BEAM . BEAM включен в официальный дистрибутив Erlang под названием Erlang/OTP. BEAM выполняет байт-код , который преобразуется в многопоточный код во время загрузки. Он также включает в себя компилятор собственного кода для большинства платформ, разработанный проектом High Performance Erlang Project (HiPE) в Университете Упсалы . С октября 2001 года система HiPE полностью интегрирована в систему Erlang/OTP с открытым исходным кодом Ericsson. Он также поддерживает интерпретацию непосредственно из исходного кода через абстрактное синтаксическое дерево через скрипт, начиная с версии Erlang R11B-5.

Загрузка горячего кода и модулей

на уровне языка Erlang поддерживает динамическое обновление программного обеспечения . Для реализации этого код загружается и управляется как «модуль»; модуль является единицей компиляции . Система может одновременно хранить в памяти две версии модуля, и процессы могут одновременно запускать код каждой из них. Версии называются «новой» и «старой» версией. Процесс не перейдет в новую версию, пока не выполнит внешний вызов своего модуля.

Пример механизма горячей загрузки кода:

  %% A process whose only job is to keep a counter.
  %% First version
  -module(counter).
  -export([start/0, codeswitch/1]).

  start() -> loop(0).

  loop(Sum) ->
    receive
       {increment, Count} ->
          loop(Sum+Count);
       {counter, Pid} ->
          Pid ! {counter, Sum},
          loop(Sum);
       code_switch ->
          ?MODULE:codeswitch(Sum)
          % Force the use of 'codeswitch/1' from the latest MODULE version
    end.

  codeswitch(Sum) -> loop(Sum).

Для второй версии мы добавляем возможность обнулить счетчик.

  %% Second version
  -module(counter).
  -export([start/0, codeswitch/1]).

  start() -> loop(0).

  loop(Sum) ->
    receive
       {increment, Count} ->
          loop(Sum+Count);
       reset ->
          loop(0);
       {counter, Pid} ->
          Pid ! {counter, Sum},
          loop(Sum);
       code_switch ->
          ?MODULE:codeswitch(Sum)
    end.

  codeswitch(Sum) -> loop(Sum).

Только при получении сообщения, состоящего из атома code_switch выполнит ли цикл внешний вызов codeswitch/1 ( ?MODULE — макрос препроцессора для текущего модуля). Если в памяти имеется новая версия модуля счетчика , то будет вызвана его функция codeswitch/1. Практика использования конкретной точки входа в новую версию позволяет программисту преобразовывать состояние в то, что необходимо в более новой версии. В примере состояние сохраняется как целое число.

На практике системы создаются с использованием принципов проектирования Open Telecom Platform, что приводит к увеличению количества проектов, допускающих обновление кода. Успешная загрузка горячего кода требует усилий. Код должен быть написан с осторожностью, чтобы использовать возможности Erlang.

Распределение

В 1998 году Ericsson выпустила Erlang как бесплатное программное обеспечение с открытым исходным кодом , чтобы обеспечить его независимость от одного поставщика и повысить осведомленность об этом языке. Erlang вместе с библиотеками и распределенной базой данных реального времени Mnesia образует коллекцию библиотек OTP. Ericsson и несколько других компаний поддерживают Erlang на коммерческой основе.

С момента выпуска с открытым исходным кодом Erlang использовался несколькими фирмами по всему миру, включая Nortel и T-Mobile . Хотя Erlang был разработан, чтобы заполнить нишу, и большую часть своего существования оставался малоизвестным языком, его популярность растет из-за спроса на параллельные сервисы. Эрланг нашел некоторое применение в создании серверов многопользовательских ролевых онлайн-игр (MMORPG).

См. также

• Эликсир - функциональный, параллельный язык программирования общего назначения, работающий на BEAM.
• Luerl — Lua на BEAM, разработанный и реализованный одним из создателей Erlang.
• Lisp Flavored Erlang (LFE) — язык программирования на основе Lisp, работающий на BEAM.
• Mix (инструмент сборки)
• Феникс (веб-фреймворк)
• Gleam (язык программирования)

Дальнейшее чтение

• Армстронг, Джо (2003). Создание надежных распределенных систем при наличии ошибок в программном обеспечении (PDF) (PhD). Королевский технологический институт, Стокгольм, Швеция. Архивировано из оригинала (PDF) 23 марта 2015 года . Проверено 13 февраля 2016 г.
• Армстронг, Джо (2007). «История Эрланга». Материалы третьей конференции ACM SIGPLAN по истории языков программирования — HOPL III . стр. 6–1. дои : 10.1145/1238844.1238850 . ISBN  978-1-59593-766-7 . S2CID   555765 .
• Ранняя история Erlang. Архивировано 29 августа 2019 года в Wayback Machine Бьярном Дакером.
• Мэттссон, Х.; Нильссон, Х.; Викстрем, К. (1999). «Мнезия - распределенная надежная СУБД для телекоммуникационных приложений». Первый международный семинар по практическим аспектам декларативных языков (PADL '99) : 152–163.
• Армстронг, Джо; Видинг, Роберт; Уильямс, Майк; Викстрем, Клаас (16 января 1996 г.). Параллельное программирование в Erlang (2-е изд.). Прентис Холл . п. 358. ИСБН  978-0-13-508301-7 . Архивировано из оригинала 6 марта 2012 года.
• Армстронг, Джо (11 июля 2007 г.). Программирование на Erlang: программное обеспечение для параллельного мира (1-е изд.). Прагматичная книжная полка . п. 536 . ISBN  978-1-934356-00-5 .
• Томпсон, Саймон Дж.; Чезарини, Франческо (19 июня 2009 г.). Программирование на Erlang: параллельный подход к разработке программного обеспечения (1-е изд.). Севастополь, Калифорния: O'Reilly Media , Inc., с. 496. ИСБН  978-0-596-51818-9 .
• Логан, Мартин; Мерритт, Эрик; Карлссон, Ричард (28 мая 2010 г.). Эрланг и OTP в действии (1-е изд.). Гринвич, Коннектикут: Публикации Мэннинга . п. 500. ИСБН  978-1-933988-78-8 .
• Мартин, Браун (10 мая 2011 г.). «Введение в программирование на Erlang, Часть 1: Основы» . РазработчикWorks . ИБМ . Проверено 10 мая 2011 г.
• Мартин, Браун (17 мая 2011 г.). «Введение в программирование на Erlang, часть 2: Использование расширенных функций и возможностей» . РазработчикWorks . ИБМ . Проверено 17 мая 2011 г.
• Вигер, Ульф (30 марта 2001 г.). «Четырехкратное увеличение производительности и качества: промышленное функциональное программирование в продуктах телекоммуникационного класса» (PDF) . FEmSYS 2001 Развертывание на распределенных архитектурах . Эрикссон Телеком АБ. Архивировано из оригинала (PDF) 19 августа 2019 года . Проверено 16 сентября 2014 г.

Внешние ссылки

• «Эрланг: Фильм»
• Официальный сайт