Erlang

У этого термина существуют и другие значения, см. Эрланг (значения).

Erlang

Семантика |  мультипарадигмальный: параллельное, функциональное программирование
Класс языка |  мультипарадигмальный, многопоточный[вд], функциональный, декларативный язык программирования, язык программирования, открытое программное обеспечение, свободное программное обеспечение и умение
Появился в |  1986[2]
Автор |  Джо Армстронг
Разработчик |  Джо Армстронг, Ericsson и Роберт Вирдинг[вд]
Расширение файлов |  `.erl`
Выпуск |

* 28.0.1 (16 июня 2025)[1]

Система типов |  сильная, динамическая
Испытал влияние |  ML, Пролог, Лисп, PLEX[вд], Smalltalk, Миранда, Ада, Модула-2 и CHILL
Лицензия |  Apache License 2.0[3]
Сайт |  erlang.org (англ.)
ОС |  кроссплатформенность[4]
Медиафайлы на Викискладе

Erlang (ˈɜːlæŋ)[5] — функциональный язык программирования с сильной динамической типизацией, предназначенный для создания распределённых вычислительных систем. Разработан и поддерживается компанией Ericsson. Язык включает в себя средства порождения параллельных легковесных процессов и их взаимодействия через обмен асинхронными сообщениями в соответствии с моделью акторов.

Erlang был целенаправленно разработан для применения в распределённых, отказоустойчивых, параллельных системах реального времени,➤ для которых, кроме средств самого языка, имеется стандартная библиотека модулей➤ и библиотека шаблонных решений (так называемых поведений) — фреймворк OTP (англ. Open Telecom Platform).➤ Программа на Erlang транслируется в байт-код, исполняемый виртуальными машинами, находящимися на различных узлах распределённой вычислительной сети. Erlang-системы поддерживают горячую замену кода,➤ что позволяет эксплуатировать оборудование безостановочно.

Свой синтаксис и некоторые концепции Erlang унаследовал от языка логического программирования Пролог[6]. Язык поддерживает многие типы данных,➤ условные конструкции,➤ сопоставление с образцом,➤ обработку исключений,➤ списковые включения➤ и выражения битовых строк,➤ функции➤ (анонимные функции,➤ функции высшего порядка, рекурсивные определения функций, оптимизацию хвостовой рекурсии), модули,➤ приём и отправку сообщений➤ между процессами. Препроцессор➤ поддерживает работу с макросами и включение заголовочных файлов.

Популярность Erlang начала расти в связи с расширением его области применения (телекоммуникационные системы) на высоконагруженные параллельные распределённые системы, обслуживающие миллионы пользователей WWW, такие как чаты, системы управления содержимым, веб-серверы и распределённые, требующие масштабирования базы данных. Erlang применяется в нескольких NoSQL-базах данных высокой доступности[7].

## Содержание

* 1 История
* 2 Философия
* 3 Основные особенности
* 3.1 Высокоуровневые конструкции
* 3.2 Параллельные вычисления
* 3.3 Распределённые вычисления
* 3.4 Мягкое реальное время
* 3.5 Горячая замена кода
* 4 Описание языка
* 4.1 Типы данных
* 4.1.1 Числа
* 4.1.2 Атомы
* 4.1.3 Битовые строки и бинарные данные
* 4.1.4 Кортеж
* 4.1.5 Список
* 4.1.6 Строка
* 4.1.7 Логические значения
* 4.1.8 Функциональный объект (Fun)
* 4.1.9 Запись
* 4.1.10 Ассоциативный массив
* 4.1.11 Другие типы
* 4.1.12 Встроенные функции для работы с типами
* 4.2 Операции
* 4.2.1 Арифметические операции
* 4.2.2 Битовые операции
* 4.2.3 Логические операции
* 4.2.4 Операции сравнения
* 4.3 Переменные
* 4.4 Сопоставление с образцом
* 4.5 Функции
* 4.5.1 Примеры
* 4.6 Условные выражения
* 4.7 Препроцессор и макросы
* 4.8 Обработка ошибок
* 4.9 Модули
* 4.10 Процессы
* 4.10.1 Создание процессов
* 4.10.2 Отправка и приём сообщений
* 4.10.3 Обработка ошибок и завершение процессов
* 4.11 Ввод-вывод
* 5 Библиотеки
* 5.1 Стандартная библиотека модулей
* 5.1.1 Таблицы ETS и DETS
* 5.2 Фреймворк OTP
* 5.3 Разработка графического интерфейса пользователя
* 6 Программирование на Erlang
* 6.1 Интерактивная оболочка
* 6.2 Документирование и оформление кода
* 6.3 Типы и анализ кода
* 6.4 Тестирование, профилирование, рефакторинг
* 6.5 Эффективность
* 7 Erlang и другие языки программирования
* 7.1 Интеграция и гибридные языки
* 7.2 Сравнение Erlang и C++ по производительности
* 7.3 Сравнение взаимодействия процессов в Erlang и Go
* 8 Критика
* 9 Сфера применения
* 10 Сообщество
* 11 Примечания
* 12 Литература
* 13 Статьи
* 14 Ссылки

## История

[править | править код]

Роберт Вирдинг (слева) и Джо Армстронг в 2013 году

В середине 1980-х годов в компьютерной лаборатории компании Ericsson исследовали применимость существовавших на тот момент языков программирования для программного обеспечения телекоммуникационных систем. Джо Армстронг, Роберт Вирдинг (Robert Virding) и Майк Вильямс (Mike Williams) под руководством Бьярне Деккера (Bjarne Däcker), написав прототипы программ на различных языках, пришли к выводу, что ни один из этих языков не имел полного набора возможностей, необходимых в области телекоммуникационных систем. В результате был создан новый язык программирования — Erlang[8]. Своё название язык, вероятно, получил в честь датского математика и инженера Агнера Эрланга, основателя научного направления по изучению сетевого трафика в телекоммуникационных системах. По другой версии, название языка изначально было сокращением от «Ericsson language»[9].

Влияние на Erlang оказали ML, Миранда, Ада, Модула-2, CHILL, Пролог. Кроме того, на способ обновления программного обеспечения повлиял Smalltalk и использованные Ericsson проприетарные языки EriPascal и PLEX[8].

Потребовалось четыре года развития языка и прототипирования с использованием виртуальной машины Пролога, после чего в 1991 году Майк Вильямс переписал виртуальную машину для Erlang на Си. В 1992 году Erlang был впервые использован в коммерческом проекте[8]. В 1995 году вышла новая версия Erlang, вобравшая накопившийся к тому моменту опыт использования языка. Язык был сочтён достаточно развитым для использования в других продуктах компании (решения для широкополосной связи, GPRS, ATM)[8].

В декабре 1995 года случилось событие, которое Джо Армстронг считает решающим для Erlang: проект AXE-N в Ellemtel по созданию нового маршрутизатора (как оборудования, так и системного программного обеспечения на C++) потерпел неудачу. В результате реорганизации проекта удалось, использовав разработанное оборудование и язык программирования Erlang, начать работы над ATM-маршрутизаторами серии AXD. Ресурсов лаборатории для такого проекта оказалось недостаточно, поэтому для работ по Erlang было создано производственное подразделение под названием OTP (Open Telecom Platform)[10]. В 1996 году увидел свет одноимённый фреймворк OTP[8].

Неожиданно[11], в 1998 году топ-менеджмент Ericsson решил не брать на себя обязательств по разработке и поддержке собственного языка программирования, сосредоточившись вместо этого на Java. Использование Erlang было запрещено в новых проектах Ericsson Radio AB в связи с реализацией плана по аутсорсингу программной технологии компании Rational Inc.[12][13] Это решение очень сильно повлияло на будущее Erlang: оно привело к открытию кода Erlang под открытой лицензией EPL (аналог Mozilla Public License)[14], а также послужило главной причиной начала распространения языка за пределами создавшей его компании. Основным возражением против открытия исходного кода являлось решение вопросов, касающихся патентов, но эти трудности были преодолены[15]. Вскоре многие из основных разработчиков покинули Ericsson, чтобы организовать собственный бизнес — Bluetail AB[15][12].

В начале 2000-х годов научные круги стали проявлять интерес к Erlang. С 2002 года стал проводиться ежегодный Erlang Workshop. Ericsson продолжал спонсирование проекта HiPE (от англ. High-Performance Erlang — высокопроизводительный Erlang)[16] уппсальского университета[Примечание 1]. Проект HiPE занимался эффективной реализацией языка и инструментами для проверки типов, а с 2001 года созданный в группе проекта компилятор в машинный код входит в поставку свободно распространяемой версии Erlang/OTP[10]. Работы, связанные с Erlang, ведут и другие высшие учебные заведения. Инструменты для рефакторинга созданы в Кентском университете в Великобритании и университете Ло́ранда Э́твёша в Венгрии, инструменты для различных видов тестирования — в Мадридском политехническом университете, техническом университете Чалмерса и Гётеборгском университете[17].

Когда системы с симметричной многопроцессорностью только начинали завоёвывать рынок серверов и настольных компьютеров, бросая вызов разработчикам программного обеспечения, уже в 2006 году первая версия Erlang с поддержкой SMP была выпущена совместными усилиями команды OTP из Ericsson и команды HiPE[16]. Вскоре после этого вышла первая почти за десятилетие крупная монография по Erlang: «Programming Erlang» Джо Армстронга[18], после чего многие разработчики «открыли» для себя Erlang/OTP[16], и язык стал набирать популярность[19].

Процесс развития языка включает в себя рассмотрение предложений по развитию — EEP (англ. Erlang Enhancement Proposal). Через эти предложения Erlang-сообщество вносит изменения в стандартную поставку Erlang[20]. С внесёнными предложениями можно ознакомиться на веб-странице erlang.org/eeps[21].

## Философия

[править | править код]

По свидетельству Майка Вильямса, Erlang задумывался для решения трёх проблем разработки распределённых систем мягкого реального времени с высокой степенью параллелизма: возможности быстрой и эффективной разработки ПО; получения системы, устойчивой к программным и аппаратным сбоям, и возможности обновления системы «на лету», без простоя оборудования[22].

По словам Вильямса, философия, которой придерживались разработчики Erlang, подходит и для разработки программного обеспечения на этом языке[23]:

>   * Найдите наиболее подходящие методы. Проектируйте с использованием прототипов;
>   * Одних идей мало: нужно уметь их реализовать и знать, что они работают;
>   * Делайте ошибки в небольшом масштабе, а не в производственном проекте.

> Оригинальный текст (англ.)

>   * Find the right methods—Design by Prototyping.
>   * It is not good enough to have ideas, you must also be able to implement them and know

> they work.

>   * Make mistakes on a small scale, not in a production project.

Большинство языков, созданных прежде Erlang, было разработано без предварительного нахождения своей области применения, тогда как Erlang был разработан специально на основе требований к распределённым, отказоустойчивым, параллельным системам реального времени. С развитием сети Интернет оказалось, что многие приложения имеют аналогичные требования[14], чем и объясняется растущий интерес к языку[24].

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

> Позвольте приложению упасть, и пускай что-то другое имеет с этим дело.[25]

> Оригинальный текст (англ.)

> Let it crash and let someone else deal with it

или сокращённо — «let it crash» («пусть падает»). Связано это с тем, что в Erlang-системе легко следить за завершением процесса, завершать процессы, связанные со сбойным, и запускать новые процессы[26].

## Основные особенности

[править | править код]

### Высокоуровневые конструкции

[править | править код]

Erlang является декларативным языком программирования, который скорее используется для описания того, что должно быть вычислено, нежели того,как. Например, определение функции,➤ которое использует сопоставление с образцом➤ для выбора одного из вариантов вычисления или извлечения элемента данных из составной структуры напоминает уравнение. Сопоставление с образцом распространено даже на битовые строки,➤ что упрощает реализацию телекоммуникационных протоколов[14].

Функции являются объектами первого класса в Erlang. В языке также широко применяются характерные для функциональной парадигмы программирования списковые включения (генераторы списков)[27].

### Параллельные вычисления

[править | править код]

Обмен сообщениями между процессами в Erlang

Отличительной особенностью языка является применение легковесных процессов в соответствии с моделью акторов. Такой подход позволяет выполнять одновременно сотни тысяч и даже миллионы таких процессов, каждый из которых может иметь скромные требования по памяти[28]. Процессы изолированы друг от друга и не имеют общего состояния, но между ними можно установить связь и получать сообщения об их состоянии. Для взаимодействия процессов используется асинхронный обмен сообщениями. Каждый процесс имеет свою очередь сообщений, обработка которой использует сопоставление с образцом. Процесс, отправивший сообщение, не получает уведомления о доставке, даже если идентификатор процесса-получателя недействителен или получатель игнорирует сообщение. Таким образом, ответственность за правильно организованное взаимодействие между процессами лежит на разработчике[29].

Например, при реализации на Erlang сетевого чата структура программы может напрямую отражать одновременность действий пользователей по обмену сообщениями путём запуска новых процессов. Эффективность передачи сообщений сохраняется и при увеличении числа процессов, а требования к памяти минимизируются за счёт того, что легковесными процессами управляет виртуальная машина, а не средства нижележащей операционной системы[30].

### Распределённые вычисления

[править | править код]

Erlang с самого начала проектировался для распределённых вычислений и масштабируемости. Распределение вычислений встроено в синтаксис и семантику языка, поэтому построение системы можно вести, абстрагируясь от конкретного места вычислений. В стандартной поставке Erlang может наладить связь процессов по протоколу TCP/IP независимо от поддерживаемых им нижележащих платформ (операционных систем)[31].

Работающий экземпляр среды выполнения Erlang (англ. Erlang runtime system) называется узлом (англ. node). Программы, написанные на Erlang, способны работать на нескольких узлах. Узлами могут быть процессоры, многие ядра одного процессора, и даже целый кластер машин. Узел имеет имя и «знает» о существовании других узлов на данной машине или в сети. Создание и взаимодействие процессов разных узлов не отличается от организации взаимодействия процессов внутри узла. Для создания процесса на другом узле процессу достаточно знать его имя и, без особых на то оснований, он может не интересоваться физическим расположением взаимодействующего с ним процесса. Синтаксис отправки сообщения процессу на своём узле и удалённом — один и тот же[31].

Благодаря встроенным в язык возможностям распределённых вычислений объединение в кластер, балансировка нагрузки, добавление узлов и серверов, повышение надёжности вызывают лишь небольшие затраты на дополнительный код. По умолчанию узлы спроектированы для работы внутри обособленного сегмента сети (DMZ), но, если необходимо, коммуникация между узлами может происходить с применением защищённого криптографическими методами протокола SSL[31].

### Мягкое реальное время

[править | править код]

Программы на высокоуровневом языке Erlang могут быть использованы в системах мягкого реального времени (которое иногда переводят как «псевдореальное» или «квазиреальное»[32]). Автоматизированное управление памятью и сборка мусора действуют в рамках одного процесса, что даёт возможность создавать системы с миллисекундным временем отклика (даже несмотря на необходимость сборки мусора), не испытывающие ухудшения пропускной способности при высокой нагрузке[33].

### Горячая замена кода

[править | править код]

Для систем, которые не могут быть остановлены для обновления кода, Erlang предлагает горячую замену кода (англ. hot code upgrade). При этом в приложении могут одновременно работать старая и новая версии кода. Таким способом программное обеспечение на Erlang может быть модернизировано без простоев, а выявленные ошибки исправлены[9][34].

## Описание языка

[править | править код]

### Типы данных

[править | править код]

Типизация в Erlang является сильной и динамической. Динамическая типизация была выбрана для языка Erlang по причине того, что первые разработчики были больше с ней знакомы[35]. По мнению Джо Армстронга, статическая типизация потребовала бы очень больших трудозатрат, в частности, реализовать систему горячей дозагрузки кода было бы крайне затруднительно[36]. Такая типизация, при которой возможные ошибки типов выявляются только во время выполнения, тем не менее, не помешала создавать системы с очень высоким уровнем доступности[35]. Данные в Erlang являются неизменяемыми: операции не переписывают старые значения, находящиеся в памяти. Если необходимо, модули на Erlang можно снабдить описаниями и определениями новых типов (не влияющими на компиляцию программы) для автоматической проверки типов с помощью утилиты Dialyzer[37].

#### Числа

[править | править код]

В Erlang есть два типа числовых литералов: целые и с плавающей запятой, например: `125`, `4.5e-20`. Кроме обычной нотации, числа можно задавать через символ ASCII (например, `$B` означает `66`) или вместе с указанием системы счисления с основанием от 2 до 36 (в старых версиях — до 16), например: `16#3f`, `2#1010`. В Erlang применяются целые числа произвольной точности и действительные числа двойной точности (64 бита), в стандарте IEEE 754—1985[38].

Для работы с числами можно использовать модуль `math`, который содержит обычный набор математических функций и функцию `math:pi/0`, возвращающую число  π {\displaystyle \pi } [39]. Пример вычислений в интерактивной оболочке➤:

Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4] [async-threads:0] [kernel-poll:false]

Eshell V5.9.1 (abort with ^G)
1> 123/23 + 12*(2+3).
65.34782608695652
2> math:cos(math:pi()).
-1.0
3> random:uniform(10).

#### Атомы

[править | править код]

Атом — константа с именем, которая должна быть заключена в одинарные кавычки, если не начинается со строчной буквы или содержит знаки, кроме букв, цифр, подчёркивания, точки и символа `@`. Понятие атома заимствовано из Пролога и его можно считать аналогом перечислений (enum) в других языках программирования (без необходимости предварительной декларации)[40]. Атомы используются почти исключительно в сравнениях, имеющих в Erlang очень эффективную реализацию[41]. Кроме того, некоторые атомы имеют определённый смысл в возвращаемых значениях и описании исключений. К ним относятся: `error`, `ignore`, `noreply`, `ok`, `reply`, `stop`, `undefined`[42].

#### Битовые строки и бинарные данные

[править | править код]

Битовая строка используется для хранения в памяти нетипизированных данных. Строки, состоящие из целого количества октетов, называются бинарными (или двоичными) данными (англ. binaries). Синтаксис описания битовой строки довольно гибок, так как описывает значения битов отдельных диапазонов и может быть снабжён модификатором типа[43]. Несколько примеров в интерактивной командной оболочке:

1> <<23,89,120>>.
<<23,89,120>>
2> <<"ABC">>.
<<65,66,67>>
3> <<10,17,42:16>>.
<<10,17,0,42>>
4> <<$a, $b, $c>>.
<<"abc">>
5> <<1024/utf8>>.
<<208,128>>

Выражения битовых строк (англ. bitstring comprehension) аналогичны списковым включениям, но работают над битовыми строками[44]:

1> << <<bnot(X):1>> || <<X:1>> <= <<2#111011:6>> >>.
<<4:6>>

В этом примере переменная X последовательно получает биты числа `2#111011`, которые затем инвертируются операцией битового отрицания `bnot` (от англ. binary NOT), в результате чего получается число 4.

#### Кортеж

[править | править код]

Кортеж (англ. tuple) — составной тип данных с фиксированным количеством элементов. При доступе к элементам кортежа с помощью встроенных функций нумерация элементов начинается с единицы, а не с нуля. Первый элемент кортежа принято использовать для указания роли кортежа в программе. Если первый элемент — атом, его называют тегом (англ. tag — «метка»). В Erlang принято строить различные типы данных на основе кортежей с тегами, что облегчает отладку программы и считается хорошим стилем программирования[45].

Для работы с кортежами есть несколько встроенных функций, например[45]:

1> tuple_size({a, 1, "777"}).

2> element(1, {b, 2, 3, 4}).

3> setelement(1, {c, 5}, d).
{d,5}

#### Список

[править | править код]

Список (англ. list) — составной тип данных, содержащий переменное число элементов. Для манипуляции со списками можно применять функции модуля `lists` стандартной библиотеки[46]. Формально список определяется как имеющий голову (англ. head) и хвост (англ. tail), что выражается синтаксически в виде `[HEAD|TAIL]`, где хвост обычно является списком (возможно, пустым). Пустой список обозначается `[]`[47].

Списки можно записывать и более привычным способом. Следующие записи эквивалентны:

1> [a|[b|[c|[]]]].
[a,b,c]

Для работы со списками можно применять списковые включения[48] (генераторы списков), например:

1> [ X / 2 || X <- [1,2,3,4]].
[0.5,1.0,1.5,2.0]

Модуль `lists` стандартной библиотеки➤ содержит функции для обработки списков (и строк, так как в Erlang строка является списком)[49], такие как нахождение максимума, сортировка, изменение порядка элементов на противоположный, суммирование элементов и т. п. В следующем примере два списка склеиваются операцией конкатенации, а затем разбиваются на две части функцией `lists:split/2`:

1> lists:split(2, [l,2,3]++[4,5,6]).
{[l,2],[3,4,5,6]}

В модуле `lists` имеется также набор функций высшего порядка, таких как `lists:all/2`, `lists:any/2`, `lists:dropwhile/2`, `lists:filter/2`, `lists:foldl/3`, `lists:foldr/3`, `lists:map/2`, `lists:foreach/2`. Следующий пример иллюстрирует работу функции `lists:foldr` (англ. fold — свернуть, «r» от англ. right — правая) для свёртки списка, первым параметром которой должна быть функция:

1> D = fun(V, A) -> V / A end. % функция D - деление V на A
#Fun<erl_eval.12.82930912>
2> lists:foldr(D, 1, [1, 2, 4, 8]).
0.25
3> 1/(2/(4/(8/1))).
0.25

Результат выполнения свёртки справа налево (в строке 2) тождественен цепочечному делению (строка 3). Второй параметр `foldr` даёт начальное значение для так называемого аккумулятора. Для каждого элемента списка (справа налево) к элементу и аккумулятору применяется функция, заданная первым аргументом `foldr`, а значение записывается в аккумулятор. По исчерпанию списка функция возвращает значение аккумулятора[50]. Функция является достаточно мощным средством, если учесть, что аккумулятор может быть списком или кортежем[51].

#### Строка

[править | править код]

В Erlang нет самостоятельного типа для строк: внутренне строки представляются списками. Синтаксически строку можно задать кавычками. Так, `"Привет!"` равносилен (в подходящей кодировке) списку `[1055,1088,1080,1074,1077,1090,33]`. Erlang поддерживает Unicode как в строке, так и в записи отдельного знака (через `$`)[52].

Атомы и строки внешне достаточно похожи, но имеют совершенно различные реализации. Тогда как атомы можно только сравнивать, строки поддерживают многие другие операции, для них есть множество функций в модулях `lists` и `string`. Строка может выполнять функции атома, но память, занимаемая строкой пропорциональна её длине, тогда как атомы хранятся в системной таблице и на каждое использование атома в программе приходится лишь пара байтов, вне зависимости от длины атома. Сравнение двух атомов — это сравнение двух внутренних идентификаторов, выполняемое за одну операцию, тогда как сравнение строк предполагает поэлементный проход элементов строк[53].

#### Логические значения

[править | править код]

Для значений истина и ложь в Erlang применяются атомы `true` (истина) и `false` (ложь), которые и используются операциями сравнения, логическими операциями, встроенными функциями[54]. Пример:

1> 2 < 3.
true
2> is_boolean(125).
false

#### Функциональный объект (Fun)

[править | править код]

Fun-выражение позволяет создать анонимную функцию, например, для передачи в качестве параметра другим функциям. С помощью `fun` можно также получить функциональный объект для функции из модуля[55]. Примеры:

1> lists:map(fun(X) -> X + 1 end, [1, 2, 3]).
[2,3,4]
2> Belongs = fun lists:member/2.
#Fun<lists.member.2>
3> Belongs(a, [a, b]).
true

#### Запись

[править | править код]

Чтобы помечать отдельные элементы кортежей и избежать ошибок при написании программы, в Erlang был внесён синтаксис записей (англ. record). Для работы с записями, необходимо в начале дать описание записи директивой `-record`, например, для записи `user` описание может быть следующим[56]:

-record(user, {login="anon", password, nick}).

Из этого описания компилятор узнаёт, что имеются в виду кортежи из четырёх элементов, в которых элементы со второго по четвёртый соответствуют полям `login`, `password`, `nick` (порядок важен) записи с именем `user` (определяется атомом в первом элементе кортежа). Значением по умолчанию для поля `login` является строка `"anon"`. Если значение по умолчанию не указано явно, подразумевается атом `undefined`.

Создание записей и извлечение элементов записи всегда требует явного указания имени записи[56]:

R0 = #user{} % все поля получают значения по умолчанию
R1 = #user{login="user1", password="secret", nick="john"} % все поля получили значения

Синтаксис доступа к значениям полей записи: `R1#user.login`, `R0#user.nick`[56].

#### Ассоциативный массив

[править | править код]

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

Map = #{a => 2, b => 3, c=> 4, "a" => 1, "b" => 2, "hi" => 42},
Key = "hi",
maps:find(Key,Map).
{ok,42}

#### Другие типы

[править | править код]

В языке Erlang имеются и другие типы данных. Тип ссылка (англ. reference) является практически уникальной в среде времени выполнения Erlang[57]. Ссылка создаётся вызовом функции `make_ref/0` и может повториться через 282 вызовов этой функции[58]. Ссылки можно сравнивать на равенство, а применяются они для одноразовых пометок или «волшебного печенья»[59].

Идентификатор порта (англ. port identifier) определяет порт для связи с внешним по отношению к Erlang-системе миром. Порт позволяет создавшему его процессу-владельцу (так называемому присоединённому процессу) обмениваться бинарными сообщениями со сторонними программами и ОС способом, принятым в данной операционной системе[59][60][41].

Идентификатор процесса (англ. Pid), как и следует из его названия, идентифицирует процесс, порождаемый различными функциями `spawn`. Идентификатор можно считать уникальным во время работы Erlang-системы, но в долго работающих системах могут всё-таки быть использованы повторно, что обычно не является проблемой на практике[59].

#### Встроенные функции для работы с типами

[править | править код]

Для преобразования типов используются встроенные функции (BIF, от англ. builtin function) вида x_to_y («из x в y»), а для проверки принадлежности значения тому или иному типу — функции вида is_x («является x»):

1> atom_to_list(hello).
"hello"
2> list_to_binary("world").
<<"world">>
3> tuple_to_list({1,2,3,4}).
[1,2,3,4]
1> is_integer(3).
true
2> is_tuple("abc").
false
3> is_integer(3.0).
false

### Операции

[править | править код]

#### Арифметические операции

[править | править код]

Erlang предоставляет наиболее распространённые арифметические операции для целых чисел и чисел с плавающей запятой:

Обозначение | Выполняемая операция | Пример | Результат примера

|
|
|

`+` | Унарный плюс | `+3` | `3`
`-` | Унарный минус | `-3` | `-3`
`+` | Сложение | `2+3` | `5`
`-` | Вычитание | `7-3` | `4`
`*` | Умножение | `1.2*0.4` | `0.48`
`/` | Деление | `5 / 3` | `1.6666666666666667`
`div` | Целочисленное деление | `5 div 3` | `1`
`rem` | Нахождение остатка от деления | `5 rem 3` | `2`

Все эти операции левоассоциативны. Унарные операции имеют наивысший приоритет, затем следует умножение и деление, наименьший приоритет у сложения и вычитания. При необходимости целое может приводиться к типу с плавающей запятой[61].

#### Битовые операции

[править | править код]

Битовые операции работают над целыми числами и дают в результате целое число[62].

Обозначение | Выполняемая операция | Пример | Результат примера

|
|
|

`bnot` | Побитовое отрицание | `bnot (2#1000)` | `-9`
`band` | Побитовое И | `2 band 3` | `2`
`bor` | Побитовое ИЛИ | `1 bor 2` | `3`
`bxor` | Побитовое исключающее ИЛИ | `5 bxor 3` | `6`
`bsr` | Побитовый сдвиг вправо | `32 bsr 2` | `8`
`bsl` | Побитовый сдвиг влево | `1 bsl 5` | `32`

#### Логические операции

[править | править код]

Логические операции работают над логическими значениями `true` (истина) и `false` (ложь), получаемыми в результате сравнений и применения функций проверки типа[63].

Обозначение | Выполняемая операция | Пример | Результат примера

|
|
|

`not` | Отрицание (НЕ) | `not true` | `false`
`and` | Конъюнкция (И) | `true and (1 < 5)` | `true`
`andalso` | Аналогично `and`, но не вычисляет второй операнд, если первый `false` | `false andalso (1 < 5)` | `false`
`or` | Дизъюнкция (ИЛИ) | `is_atom("1") or is_atom(1)` | `false`
`orelse` | Аналогично `or`, но не вычисляет второй операнд, если первый `true` | `true orelse (1 < 5)` | `true`
`xor` | Исключающее ИЛИ | `true xor true` | `false`

#### Операции сравнения

[править | править код]

Операции сравнения получают два операнда, а результатом операции является логическое значение `true` или `false`. В Erlang есть следующие операции: `==` (равно), `/=` (не равно), `=<` (меньше или равно), `<` (меньше), `>` (больше), `>=` (больше или равно), а также сравнения, которые работают без приведения к одному типу: `=/=` (не равно в точности) и `=:=` (равно в точности).

Можно сравнивать и значения разных типов, но они считаются в Erlang упорядоченными следующим образом[64]:

число < атом < ссылка < функция < порт < идентификатор процесса < кортеж < список < бинарные данные

Списки считаются упорядоченными в лексикографическом порядке, а кортежи сравниваются по длине, и только затем в лексикографическом порядке[64].

### Переменные

[править | править код]

Переменные служат для хранения значений простых и составных типов. Имя переменной начинается с прописной буквы (в специальных случаях — с подчёркивания) и может содержать буквы, цифры, подчёркивания. Значение можно присвоить переменной лишь один раз — это свойство языка программирования называется единичным присваиванием (англ. single assignment)[65]. К достоинствам единичного присваивания можно отнести устранение необходимости в блокировках, а также упрощение отладки программы[66].

Передача параметров в функцию происходит по значению, поэтому все они вычисляются перед вызовом функции[65].

Область видимости переменной распространяется от момента её появления в заголовочной части описания функции или присваивания до конца части описания функции. Пример[67]:

binomial(X) -> Y = X*X, X + Y.
prod([1|T]) -> prod(T);
prod([Y|T]) -> Y * prod(T);
prod([]) -> 1.

В этом примере область видимости `X` — всё описание функции `binomial/1`, а `Y` — от присваивания до конца описания. Переменная `Y` во второй части (клоза) описания функции `prod/1` не имеет отношения к переменной `Y` из `binomial/1`: её область видимости распространяется до конца этого клоза.

При выходе вычислений за пределы области видимости переменной память, занятая её содержимым, может быть освобождена в процессе сборки мусора, если значение переменной не используется в другой части программы[68].

### Сопоставление с образцом

[править | править код]

Сопоставление с образцом используется в Erlang для присваивания (в том числе, при работе с параметрами функций), управления потоком выполнения программы, извлечения значений составных типов, выбора сообщения из очереди. В левой части сравнения (или в заголовке функции) могут находиться связанные (уже имеющие значение) и несвязанные (получающие значение) переменные, а также литералы (атомы, числа, строки). В результате исполнения сравнение может оказаться успешным (в этом случае переменные связываются со значениями) и неуспешным — переменные остаются несвязанными. В образце могут быть переменные, значение которых для образца безразлично: их имена записываются начинающимися с подчёркивания[69]. Переменная с именем `_` (подчёркивание) сопоставляется с любым значением, но при этом не происходит связывания. Такую переменную можно применять много раз.

### Функции

[править | править код]

Программы на Erlang состоят из функций, которые вызывают друг друга. Количество параметров функции называется арностью. При вызове функции заголовочные части описания функции сопоставляются с образцом. В случае совпадения параметров вызова, формальные параметры связываются с фактическими и исполняется соответствующая часть тела функции[70]. Запись варианта вычисления функции для некоторого образца может называется клозом от англ. clause, а определение функции — это набор из одного или более клозов[71].

Для уточнения сопоставления с образцом в функциях можно использовать охранные выражения, которые следуют после ключевого слова `when`[72]. В примере ниже определена функция вычисления знака числа, которая рассчитывается в зависимости от сравнения параметра с нулём:

sign(X) when X > 0 -> 1;
sign(X) when X == 0 -> 0;
sign(X) when X < 0 -> -1.

Клозы Erlang перебирает в том порядке, в котором они записаны, пока не будет найден подходящий заголовок[73]. В охранных выражениях можно использовать только ограниченный набор встроенных функций, так как эти функции не должны иметь побочных эффектов.

Разумеется, функции Erlang поддерживают рекурсивные вызовы. В случае, когда определение функции оканчивается рекурсивным вызовом (хвостовая рекурсия), Erlang использует оптимизацию: стек вызовов не применяется[74].

Как параметром, так и результатом функции может быть другая функция. В следующем примере функция одного аргумента возвращает функцию для прибавления аргумента[75]:

1> Plus = fun (X) -> fun(Y) -> X+Y end end. % Определение функции, возвращающей функцию
#Fun<erl_eval.6.82930912>
2> Plus(2).                                 % Функция возвращает Fun-объект
#Fun<erl_eval.6.82930912>
3> Plus(2)(3).                              % Такой синтаксис не работает
* 1: syntax error before: '('
4> (Plus(2))(3).                            % Дополнительные скобки позволяют добиться требуемого результата

5> Plus2 = Plus(2), Plus2(3).               % То же самое с использованием дополнительной переменной

#### Примеры

[править | править код]

Вычисление факториала на Erlang:

-module(fact).
-export([fac/1]).

fac(0) -> 1;
fac(N) when N > 0, is_integer(N) -> N * fac(N-1).

Алгоритм сортировки, напоминающий быструю сортировку[34]:

-module(qsort).
-export([qsort/1]).

qsort([]) -> []; % Тривиальный случай пустого списка
qsort([Pivot|Rest]) ->
% Конкатенация списка элементов до Pivot, списка из одного элемента Pivot и после Pivot
qsort([Front || Front <- Rest, Front < Pivot])
++ [Pivot] ++
qsort([Back || Back <- Rest, Back >= Pivot]).

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

### Условные выражения

[править | править код]

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

case выражение-выбора of
образец1 when охрана1 -> выражение11, выражение12, ...;
образец2 when охрана2 -> выражение21, выражение22, ...;
...
образецN when охранаN -> выражениеN1, выражениеN2, ...
end

Это выражение всегда возвращает значение, соответствующее последнему вычисленному выражению в строке с подошедшим образцом. Это возвращаемое значение может служить возвращаемым значением функции, а может быть присвоено переменной[76]. Как и в заголовочной части функции, после образца может следовать охранное выражение.

Упрощённым вариантом case-выражения является if-выражение:

охрана1 -> выражение11, выражение12, ...;
охрана2 -> выражение21, выражение22, ...;
...
охранаN -> выражениеN1, выражениеN2, ...
end

Здесь `охранаi` — охранное выражение. Первое истинное охранное выражение вызывает выполнение соответствующих выражений, последнее из которых и является значением всего if-выражение[77]. Следует заметить, что и здесь в охранном выражении можно применять только ограниченный набор операций и встроенных функций.

Запятые в охранном выражении работают как операция `and`, например[78]:

X =< 0 -> 'меньше или равно нулю';
X > 0, X < 10 -> 'больше нуля и меньше десяти';
X >= 10 -> 'больше или равно десяти';
end

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

-module(badexample).
-export([broken_if/1]).
broken_if(X) ->

X < 0 -> Z = -1;
X >= 0 -> Y = 1
end,
Y * Z.

При попытке откомпилировать модуль возникают сообщения об ошибках, так как в таком коде одна из переменных не связывается со значением:

1> c(badexample).
badexample.erl:8: variable 'Y' unsafe in 'if' (line 4)
badexample.erl:8: variable 'Z' unsafe in 'if' (line 4)
error

Правильным было бы определить все используемые далее по коду переменные во всех ветвях if-выражения[79].

### Препроцессор и макросы

[править | править код]

Препроцессор Erlang (EPP) позволяет вкладывать файлы с исходным кодом один в другой, определять макросы и осуществлять простые и параметризованные макроподстановки[80]. Макрос определяется с помощью директивы `-define`, а макроподстановка осуществляется указанием имени макроса и возможных параметров после вопросительного знака (`?`). Следующий пример показывает определение и применение параметризованного макроса:

-define(ZERO(X),X == 0)
is_zero(T) when ?ZERO(X) -> true;
is_zero(T) -> false.

Имя макроса обычно пишется прописными буквами. Определение макроса должно содержать лексемы Erlang целиком (например, попытка задать часть имени переменной с помощью макроса вызовет синтаксическую ошибку). Макросы могут использоваться для повышения удобочитаемости кода в охранных выражениях, для операторов отладки и т. п.[81] Препроцессор имеет несколько предопределённых макросов, которые нельзя переопределить: `?MODULE`, `?MODULE_STRING`, `?FILE`, `?LINE`, `?MACHINE`[82].

Заголовочный файл (расширение `.hrl`) с определениями макросов и записей можно включить при помощи директивы `-include`[83].

### Обработка ошибок

[править | править код]

Для обработки исключительных ситуаций в Erlang можно применять конструкцию `try-catch`, в общем случае записываемую в следующем виде[84]:

try вычисляемое-выражение of
образец1 when охрана1 -> выражение1;
образец2 when охрана2 -> выражение2;
...
образецN when охранаN -> выражениеN
catch
класс1:образецИскл1 when охранаИскл1 -> выражениеИскл1;
...
классM:образецИсклM when охранаИсклM -> выражениеИсклM;
end

Как и в случае case-выражения, вычисляемое выражение сопоставляется с образцом (части между `of` и `catch`) для получения результата[Примечание 2][85]. После ключевого слова `catch` следуют части обработки исключений, в которых в дополнение к образцам исключений могут быть указаны классы исключений (перед двоеточием): `error`, `throw` и `exit`. Подчёркивание может использоваться как в образце, так и в классе исключения[86]. Следующий простой пример иллюстрирует перехват ошибки класса `error` при вычислении квадратного корня:

1> try math:sqrt(-1) catch error:Error -> {error, Error} end.
{error, badarith}
2> try math:sqrt(4) catch error:Error -> {error, Error} end.
2.0

Для создания исключений, определённых пользователем, используется функция `throw/1`, которая принимает кортеж с более детальным описанием возникшей ошибки[87] и генерирует исключение класса `throw`. Использование этой функции нежелательно из-за ухудшения удобочитаемости кода программы, но может потребоваться в некоторых случаях при работе с вложенными структурами данных, например, при разборе XML[86]. Исключения класса `exit` возникают в результате вызова встроенной функции `exit/1` или сигнала выхода[86].

До разработки Ричардом Карлссоном (Richard Carlsson) из команды проекта HiPE описанного выше нового механизма обработки исключений (появился в версии R10B) в Erlang использовались catch-выражения[88].

### Модули

[править | править код]

Код программы на Erlang можно разбить на отдельные модули. Модуль — имя для набора функций, организованных в одном файле. Имя модуля должно совпадать с именем файла (если отбросить расширение)[89]. Модуль можно откомпилировать в байт-код как из командной строки операционной системы, так и из командной оболочки Erlang[90]. В файле модуля можно записать объявления функций и директивы (иногда называются атрибутами)[91]. Обязательным атрибутом является только `-module(атом_имени_модуля).` Другой часто используемый атрибут — `-export` — применяется для указания списка экспортируемых функций, то есть функций, которые можно использовать за пределами модуля.

Функции в Erlang однозначно определяются модулем, именем и арностью. Например, `math:cos/1` соответствует функции `cos` из модуля `math`, принимающей один аргумент. Вызвать функцию можно так: `math:cos(1.2)`[89].

Исходный текст модуля компилируется в BEAM-файл — файл, содержащий байт-код виртуальной машины BEAM (англ. Bogdan’s/Björn's Erlang Abstract Machine[90]). В свою очередь, ERTS (англ. Erlang Runtime System — система времени выполнения Erlang) выполняет этот код[55].

### Процессы

[править | править код]

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

#### Создание процессов

[править | править код]

Для создания нового процесса служит несколько встроенных функций (`spawn` и её аналоги)[92]. Функции возвращают идентификатор процесса, который может использоваться, например, для отправки сообщений вновь созданному процессу. В интерактивной консоли erl можно получить список процессов и другую информацию посредством вызова функций `processes().` и `i().` соответственно[93].

#### Отправка и приём сообщений

[править | править код]

Как и язык Оккам, Erlang использует для отправки сообщения синтаксис с восклицательным знаком: `ИдПроцесса ! Сообщение`. Приём сообщения — то есть извлечение его из очереди («почтового ящика») процесса — выполняется с помощью receive-выражений, обычно записываемых следующим образом[94]:

receive
образец1 when охрана1 -> выражение11, выражение12, ...;
образец2 when охрана2 -> выражение21, выражение22, ...;
...
образецN when охранаN -> выражениеN1, выражениеN2, ...;
НесвязаннаяПеременнаяДляОстальныхСообщений -> выражение1, выражение2, ...
end

Встретив такое выражение, интерпретатор последовательно просматривает сообщения из очереди. Каждое сообщение интерпретатор сопоставляет с образцом и, если оно удовлетворяет образцу, вычисляются соответствующие выражения. Когда все сообщения перебраны, и подходящего не оказалось, процесс блокируется в ожидании новых сообщений, после чего перебор очереди повторяется. Если в receive-выражении отсутствует образец, которому удовлетворяет любое сообщение, такое выражение называется выборочным receive-выражением[93].

#### Обработка ошибок и завершение процессов

[править | править код]

Процесс можно связать с другим, в результате чего между процессами устанавливается двунаправленное соединение (англ. link). В случае, если один из процессов завершается ненормально, всем связанным с ним процессам передаётся сигнал выхода (англ. exit signal). Процессы, получившие сигнал, завершаются, распространяя сигнал дальше[95][96]. Сигнал выхода является кортежем, элементами которого являются атом `'EXIT'` (выход), идентификатор завершившегося процесса и причину завершения процесса. Причина завершения передаётся по цепочке завершающихся процессов[97].

Процесс может осуществить перехват ошибки (англ. trapping errors), если у него установлен флаг перехвата выхода[Примечание 3]. Такой процесс получает сигналы выхода связанных с ним процессов в виде обычных сообщений с той же структурой кортежа. Перехваченный сигнала выхода более не передаётся связанным с процессом-перехватчиком процессам[98]. Сигнал выхода с причиной — атомом `normal` (нормальное завершение процесса) не вызывает завершения связанного процесса. Если же причина — атом `kill`, процесс завершается безусловно (независимо от флага перехвата выхода), а связанным с ним процессам в качестве причины отправляется атом `killed`, что даёт им возможность среагировать[99].

В Erlang есть возможность установить и однонаправленное соединение. При завершении наблюдаемого процесса процесс-наблюдатель получает сообщение с указанием причины завершения[100].

Процесс может остановить сам себя или другой процесс, вызвав функцию `exit`[101].

### Ввод-вывод

[править | править код]

В планировщике процессов Erlang-системы проблема ввода-вывода, присущая многим другим языкам параллельного программирования, решена достаточно элегантно. Управление вводом-выводом, интегрированное с планировщиком, уже на самом нижнем уровне осуществляется на основе событий, что позволяет программе обрабатывать входящие и исходящие данные без излишних блокировок. Такой подход требует меньшего числа установки и разрыва соединений, а также убирает необходимость в блокировках и переключениях контекста. К сожалению, такой достаточно эффективный способ более сложен для понимания программистами, и находит применение в основном в системах с явными требования по высокой доступности и низкому времени отклика. Реализация событийно-ориентированного ввода-вывода встроена в Erlang-систему, что является ещё одним преимуществом при проектировании параллельных приложений[102].

Стандартная библиотека содержит модуль `io` с функциями ввода-вывода. Такие функции содержат побочные эффекты, заключающиеся в появлении выведенной информации на консоли или записывании данных в файл на диске. Например, функция `io:format` для форматированного вывода выводит строку с подстановкой параметров, возвращая в случае успеха атом `ok`[103]:

1> io:format("Пример вывода: ~p~n", [1]).
Пример вывода: 1

Функции модуля `io` включают в себя стандартный серверный интерфейс ввода-вывода. Протокол ввода-вывода Erlang (англ. The Erlang I/O-protocol) детально определяет связь клиента и сервера. Под сервером ввода-вывода понимается процесс, который обрабатывает запросы и выполняет запрошенные команды, например, на устройстве ввода-вывода. Клиентом является любой Erlang-процесс, которому требуется работать с устройством[104][105].

## Библиотеки

[править | править код]

### Стандартная библиотека модулей

[править | править код]

Согласно официальной документации, стандартная библиотека модулей STDLIB[106] является обязательной для включения в минимальную систему Erlang/OTP[107] наряду с ядром Erlang. В библиотеку входят модули, предоставляющие разнообразные функции для работы со встроенными типами и другими структурами данных, ввода-вывода, обращения к среде окружения, для работы с файловой системой, процессами и т. п.

Модуль `array` определяет (функциональный) абстрактный тип данных для динамического массива и имеет функции, позволяющие извлекать и обновлять элементы массива, определять рекурсивные функции для работы с массивами. Модуль `string` расширяет возможности модуля `lists` функциями для работы конкретно со списками символов, какими являются строки в Erlang. Модуль `dict` (от англ. dictionary — словарь) содержит функции для ассоциативного массива, позволяющие хранить, извлекать и удалять значения по ключу, соединять массивы и производить итерации по элементам. Математические функции можно найти в модуле `math`, а функции для генерации псевдослучайных чисел содержатся в модуле `random`. Модуль `calendar` предоставляет функции для григорианского календаря: запросы текущей даты, преобразования единиц измерения и интервалов времени, а модуль `timer` содержит функции перевода интервалов времени к миллисекундам, запуска событий по таймеру и другие, связанные со временем, функции. Модуль `erlang` содержит все встроенные функции Erlang, как общие, так и относящиеся к виртуальной машине. Модуль `file` даёт доступ к функциям файловой системы, таким как открытие, чтение, запись, удаление файлов, а модуль `filename` позволяет писать функции для манипуляции с именами и путями к файлам, абстрагируясь от конкретной операционной системы. Модуль `io` предоставляет функции ввода-вывода. Кроме этих наиболее важных модулей, стандартная библиотека содержит и многие другие, с которыми можно познакомиться по документации[108].

#### Таблицы ETS и DETS

[править | править код]

Для организации коллекций в оперативной памяти Erlang предлагает модуль ets (ETS, англ. Erlang Term Storage — «хранилище термов Erlang»[Примечание 4]). ETS может хранить четыре вида коллекций: множество (англ. set), упорядоченное множество (англ. ordered set), мультимножество (англ. bag), мультимножество с повторениями (англ. duplicate bag)[109]. Доступ к элементам коллекций происходит по ключевому полю кортежа (ключи могут быть любых типов). Упорядоченные множества реализованы в виде бинарных сбалансированных АВЛ-деревьев, а остальные коллекции — с использованием хеш-таблиц[110].

DETS-таблицы дополняют функциональность ETS-таблиц (за исключением упорядоченных множеств), позволяя сохранять данные в файлах[111].

### Фреймворк OTP

[править | править код]

Основная статья: Open Telecom Platform

Дерево процессов

OTP (англ. Open Telecom Platform) является хорошо отлаженным набором полезных поведений (англ. behaviours) процессов и используется для создания серверных приложений. OTP формализует действия процессов и позволяет строить на их основе OTP-приложения (не следует путать с приложением — готовым программным продуктом). В модулях ОТР определены общие, стандартизированные шаблоны для конструирования параллельных приложений[112]. Наиболее популярными поведениями являются обобщённый сервер и наблюдатель (англ. supervisor), но имеются и другие: конечный автомат, обработчик событий[113]. OTP содержит и другое связующее программное обеспечение (англ. middleware), например, СУБД Mnesia.

OTP-поведения делятся на рабочие процессы (англ. worker processes), выполняющие собственно обработку запросов, и процессов-наблюдателей (англ. supervisors). В задачу последних входит слежение за рабочими процессами и другими процессами-наблюдателями — потомками. Деревья наблюдателей составляют OTP-приложение (англ. application)[114]. Документация по Erlang определяет OTP-приложение как компонент, реализующий некоторую функциональность, которая может быть независимо запущена на исполнение и остановлена как целое, а также повторно использована в других системах[115]. Разработчик приложения пишет код модулей функций обратного вызова (англ. call-back module), в которых и находится специфичная для данного приложения часть функциональности[114].

Хотя OTP строго говоря не является частью языка Erlang, он настолько вошёл в культуру и практику разработчиков на Erlang, что подчас между ними сложно провести границу[113].

### Разработка графического интерфейса пользователя

[править | править код]

Разработка приложений с графическим интерфейсом пользователя (не считая веб-интерфейсов) может вестись при помощи библиотеки wxErlang — библиотеки wxWidgets, портированной для Erlang. WxErlang входит в стандартную поставку Erlang/OTP. WxWidgets написан на C++, поэтому перед разработчиками wxErlang стояла задача выразить средствами Erlang иерархию объектов. Несколько упрощая, в wxErlang классам соответствуют модули, а объектам — ссылки. Макросам на C++ соответствуют макросы Erlang. Некоторые типы данных, для которых в C++ были использованы классы, представляются в Erlang с помощью других типов данных, например, wxPoint задаётся в виде кортежа из двух элементов. События в wxErlang могут быть обработаны в Erlang либо с помощью функций обратного вызова (англ. call-back functions), либо более естественной в среде Erlang передачей сообщений[116].

## Программирование на Erlang

[править | править код]

### Интерактивная оболочка

[править | править код]

Интерактивная оболочка erl в отдельном окне

Интерактивная оболочка (англ. shell) для Erlang может быть вызвана в Unix-подобных системах по команде `erl`, в Windows — `werl`[117]. В оболочке можно вводить выражения и получать результат их выполнения, опробовать новый код, заниматься интерактивной отладкой, а также управлять системой, находящейся в промышленной эксплуатации[118].

В оболочке можно использовать дополнительные функции («команды»), доступные только в ней. Например, команда `q().` осуществляет выход из оболочки с завершением всего, что делает Erlang-система[118].

В оболочке можно вызвать BREAK-меню с помощью `Ctrl`+`C` (в Unix-подобных ОС) или `Ctrl`+`Break` (в Windows). В этом меню есть различные команды, в том числе `a` — немедленный останов, `c` — продолжение работы в оболочке и другие информационные и вспомогательные команды для работы с Erlang-системой[118]. Комбинацией клавиш `Ctrl`+`G` вызывается ещё одно командное меню, с помощью которого можно, среди прочего, остановить «завесивший» оболочку процесс и вернуться в оболочку (`i` и затем `c`)[119].

### Документирование и оформление кода

[править | править код]

Текст от знака процента (`%`) до конца строки считается комментарием в Erlang. Генерация документации из исходного кода в Erlang может производиться системой документирования EDoc. Для документирования кода модуля достаточно добавить определённым образом размеченный текст, а также файл `overview.edoc` для документации уровня проекта (в последнем необязательно использовать знаки комментария)[120]. Инструменты для работы с кодом на Erlang, например, erlang-режим в Emacs, подразумевают некоторые соглашения по употреблению символов комментария. Так, утроенный знак процента вызывает выравнивание по левому краю, удвоенный — выравнивание на уровне окружающего кода, а одиночный знак процента используется для обозначения комментария после кода, в конце строки[121]. Разработчики Erlang выработали определённые стилевые соглашения, касающиеся организации и оформления исходного кода. Например, хорошим стилем считается понижение вложенности синтаксических структур, написание коротких модулей (менее 400 строк кода) и функций (не длиннее 15-20 строк кода), использование осмысленных имён для переменных и функций и т. п.[122][123]

### Типы и анализ кода

[править | править код]

Приложение Dialyzer, разработанное в рамках проекта HiPE и входящее в стандартную поставку, позволяет выявить ошибки (в том числе ошибки типизации) путём статического анализа кода. Программа TypEr, написанная Тобиасом Линдалом (Tobias Lindahl) и Костисом Сагонасом (Kostis Sagonas), является частью Dialyzer. Эта программа позволяет проверять определения типов функций, сверять указанный в директиве `-spec` тип функции с её определением, выполнить вывод типов[124]. Программа TypEr выводит все типы, соответствующие успешному применению функции, в общем случае — лишь приблизительно, в более грубую сторону. Использование функции любым другим способом обязательно приведёт к ошибке времени исполнения[124]. В следующем примере показан синтаксис определения типа (директива `-type`), объявление типа полей записи и директива `-spec` вместе с определением функции:

-type(user_status() :: disabled | enabled). % статус - один из двух атомов

-record(user, {login="anon" ::string(), % типы полей записи
password ::string(),
status :: user_status(),
nickname ::string()}).

-spec(check_password(string(), #user{}) -> ok | {error, string()}). % объявление функции

check_password(Password, User) -> % определение функции
...

Dialyzer (от англ. DIscrepancy AnaLYZer for ERlang Programs — «анализатор противоречий для Erlang-программ») выявляет в коде отдельных модулей и целых приложений избыточные проверки, ошибки типов, недостижимый код. Все выявленные инструментом дефекты требуют устранения, так как инструмент не даёт ложных срабатываний. Для каждой функции всех проверяемых модулей Dialyzer устанавливает тип, используя основанный на ограничениях вывод типов и анализ потоков данных. После определения типов функций производится анализ противоречий в программе[125].

### Тестирование, профилирование, рефакторинг

[править | править код]

Erlang предоставляет EUnit для модульного тестирования и фреймворк Common Test для системного тестирования. EUnit содержит средства для описания тестов, включая необходимый для этого набор макросов, а также производит вывод отчёта по окончании тестирования. Тестирование модулей происходит путём подключения заголовочного файла из EUnit, а функции с тестами могут быть как включены в сам тестируемый модуль, а так и вынесены в отдельный[126].

Тестирование параллельных программ можно выполнить с помощью Quviq Quick Check (версия Mini этого продукта доступна бесплатно)[127]. Кроме тестирования, можно провести проверку всех возможных вариантов исходных данных с помощью метода проверки моделей. Для этого можно воспользоваться созданной в Мадридском политехническом университете отдельно распространяемой утилитой McErlang[128].

Для профилирования кода и выявления степени покрытия кода тестами можно обратиться к модулям `eprof`, `fprof`, `cover` и утилите cprof[129].

Для Erlang разработаны несколько инструментов рефакторинга исходного кода, такие как RefactorErl, Wrangler, а также автоматическая, независимая от IDE утилита tidier. Утилита tidier позволяет автоматически находить и производить эквивалентные преобразование кода, например, заменяет

`lists:filter(fun (X) -> is_something(X) end, L)`

`[X || X <- L, is_something(X)]`[130].

### Эффективность

[править | править код]

Как и многие другие языки программирования, Erlang имеет свои секреты написания эффективного кода. Совершенствование языка делает некоторые из трюков устаревшими, поэтому документация является лучшим руководством в вопросах оптимизации, в совокупности с профилированием и стресс-тестированием.

Например, при работе со списками не рекомендуется добавлять элемент в конец длинного списка с помощью конкатенации или функции добавления элемента к списку. Вместо этого сто́ит рассмотреть возможность добавления элемента в начало списка, а конечный результат обработать функцией обращения порядка элементов списка[131].

Свои рекомендации есть и для увеличения эффективности параллельных программ. Например, действия, требующие много памяти, лучше всего выделять в отдельный процесс, так как при этом затраты на сборку мусора будут минимальны: память будет освобождена по завершении процесса[132].

## Erlang и другие языки программирования

[править | править код]

Подробное сравнение возможностей Erlang с другими языками можно найти в статье сравнение языков программирования.

### Интеграция и гибридные языки

[править | править код]

Erlang-система позволяет выполнять интеграцию с системами на других языках программирования. Имеются механизмы для сетевого взаимодействия с Си, Java, Лисп, Perl, Python, Ruby. Например, для более эффективного синхронного вызова небольших функций на Си можно использовать платформно-зависимые функции (англ. NIF, natively implemented function). Высокоуровневые библиотеки позволяют Erlang-системе представлять С или Java-узлы как обычные Erlang-узлы. Другие языки могут быть более тесно сопряжены со средой выполнения Erlang с помощью драйверов или сетевых сокетов посредством протоколов вроде HTTP, SNMP, IIOP[133]. Например, Ruby может взаимодействовать с Erlang посредством пакета erlectricity, а для Python разработана реализация Erlang-узла в виде пакета py-interface[134].

Виртуальная машина Erlang находит применение и в других языках программирования, например, Elixir[135][136] и проекте Erl2 Джо Армстронга[137][136]. Кроме того, Роберт Вирдинг поддерживает проект Lisp Flavored Erlang («Erlang, приправленный Лиспом»), в котором синтаксис Лиспа используется с компилятором Erlang[138]. Есть и другие BEAM-языки: Efene, Joxa, Reia[139], Luerl, Erlog[140].

Официальный сайт упоминает[141] проект Erjang[142], в котором используется виртуальная машина Java.

### Сравнение Erlang и C++ по производительности

[править | править код]

Хотя опытные Erlang-программисты давно заметили, что их программы для тех же задач получаются более краткими по сравнению с другими широко используемыми в промышленности языками программирования, эмпирическое исследование показало, что для изученных телекоммуникационных приложений код на Erlang был на 70—85 % короче, чем на C++, а производительность системы при переписывании кода с C++ на Erlang возросла почти на 100 %[143][144]. Для одного из использованных в исследовании проектов разница была объяснена написанием дополнительного C++-кода в рамках защитного программирования, управления памятью и кода для высокоуровневой коммуникации, то есть возможностями, которые являются частью языка Erlang и библиотек OTP[144].

### Сравнение взаимодействия процессов в Erlang и Go

[править | править код]

Влияние теории взаимодействующих последовательных процессов Чарльза Э. Хоара чувствуется как в Go, так и в Erlang. В Erlang процессы, в соответствии с моделью акторов, отправляют сообщения друг другу напрямую. В Go то же самое происходит посредством каналов (англ. channels)[145]. Другим отличием является то, что каналы в Go имеют типы. В Erlang же нет типизации времени компиляции за исключением охранных выражений, что позволяет посылать процессам сообщения любого типа, но «непонятое» сообщение либо будет проигнорировано, либо навсегда останется в очереди[145]. Go позволяет легко организовать группу «go-программ» (англ. goroutine — намёк на англ. co-routine — сопрограмма) для получения сообщений из некоторого канала (такой подход известен как пул потоков). В Erlang, при проектировании которого уделялось особое внимание детерминизму и времени задержки (англ. latency), реализация рабочего пула возможна, но требует дополнительных усилий. Множественные отправители тривиально реализуются в обоих языках[145]. Erlang-процесс может послать сообщение и ждать на него ответ (соответствующий некоторому образцу), игнорируя другие сообщения в очереди. В Go такое невозможно, но подобная функциональность может быть достигнута созданием (в том числе, динамическим) новых вводов, то есть разделением каналов по назначению[145]. Go требует явного указания того, какие go-программы будут взаимодействовать с другими передачей сообщений, тогда как в Erlang отсутствует разделяемое между процессами изменяемое состояние (англ. shared mutable state) и поэтому изолированный процесс очень редко представляет интерес[145].

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

## Критика

[править | править код]

Как и любой язык программирования, Erlang не свободен от недостатков[146]. К погрешностям синтаксиса можно отнести зависимость от символа окончания выражения от контекста (это может быть `.`, `,` или `;`), что требует дополнительного внимания при перемене выражений местами, излишнюю многословность записей (тип записи приходится упоминать при каждом доступе к члену записи), необходимость полного перечисления альтернатив в if-выражении во избежание выбрасывания исключения, если ни одно из условий не выполнено. К недостаткам можно отнести строго ограниченный набор функций, которые можно использовать в if-выражениях (этот недостаток можно обойти использованием case-выражений). Функциональный стиль и неизменяемые переменные приводят в некоторых приложениях (например, тесты) к бо́льшему количеству правок, чем в других языках программирования, так как вставка некоторой промежуточной обработки может потребовать новых имён переменных, что может привести к изменениям в коде, следующем далее по тексту. Из недостатков системы типов можно указать отсутствие строкового типа, а также невозможность динамически добавлять в записи новые члены. Есть проблемы и с организацией исходного кода, которая возможна только через создание нового файла, а также отсутствие пространств имён, классов или других средств для организации кода. Уровень качества модулей, за исключением основных, и документации оставляет желать лучшего[146].

Один из создателей языка, Джо Армстронг, в своём выступлении на конференции по истории языков программирования в 2007 году перечислил список областей, в которых Erlang можно было бы улучшить[147]:

* Использование сборки мусора для атомов.
* Улучшение средств сопряжения со внешним кодом (англ. foreign code).
* Усиление изоляции между процессами.
* Более избирательная система безопасности среди узлов Erlang, основанная на различной степени доверия.
* Отдельные обозначения для протоколов и систем.
* Модули должны быть объектами первого класса.

Массовое распространение Erlang может сдерживать необычный для большинства программистов синтаксис, использование функциональной парадигмы, а также то, что наилучшая на 2010 год реализация языка использует виртуальную машину BEAM, а не более распространённую JVM[148].

## Сфера применения

[править | править код]

Типичная архитектура системы, использующей Erlang/OTP. Приложения Erlang пользуются службами Mnesia, SASL, агентами SNMP-мониторинга и другими на базе фреймворка OTP, который в свою очередь использует ERTS. Программы других систем программирования поддерживаются в меньшей степени[149].

В силу своих особенностей Erlang и существующих библиотек модулей Erlang подходит для создания сетевых серверов, распределённых систем, программ с GUI и подобных им интерактивных программ, инструментов для тестирования, управления и слежения, в общем, приложений с нерегулярным параллелизмом, в которых распараллеливаемые задачи достаточно разнообразны. Erlang не особенно хорош для написания кода, содержащего интенсивные вычисления с плавающей запятой, требующего включения нативного кода конкретной платформы или сильной оптимизации, а также для создания приложений, требующих синхронного параллельного выполнения задач. Не подходит Erlang и для проектов, в которых код должен исполняться на JVM или CLR, или проектов, требующих множества библиотек из других систем программирования[150].

Можно сказать, что Erlang стал применяться для разработки облачных систем ещё до того, как сформировалось само понятие облачных вычислений[151]. Язык Erlang используется в масштабных телекоммуникационных и Интернет-приложениях многими компаниями, включая Amazon EC2 с реализацией SimpleDB, сервис социальных закладок Delicious, Facebook (бэкенд для чата), T-Mobile (сервис SMS и системы аутентификации)[152]. Серверное программное обеспечение WhatsApp написано на Erlang. В январе 2012 года серверы WhatsApp под FreeBSD с 96 ГБ оперативной памяти смогли обрабатывать от 1 до 2,8 миллиона соединений[153][154].

Erlang часто ставят в заслугу легендарную надёжность ATM-коммутатора AXD301 (полтора миллиона строк кода на Erlang, полмиллиона — на C/C++) в сети British Telecom. По данным Ericsson, с момента установки в январе 2002 года за несколько лет случилась только одна незначительная неполадка, на основании чего надёжность системы по расчётам составила 99,9999999 %[155]. Хотя более реальные оценки, учитывающие многие другие факторы, говорят всё-таки о «пяти девятках», успех маршрутизатора связывают с легкодоступными средствами разработки надёжных параллельных вычислений, встроенными в Erlang[155].

Используется Erlang и в приложениях с открытым исходным кодом, среди которых CouchDB — документо-ориентированная база данных с REST-интерфейсом, Disco — фреймворк для распределённых вычислений на основе парадигмы MapReduce[151][156], Ejabberd — свободный (GNU GPL), распределённый и устойчивый к отказам Jabber-сервер, написанный в основном на Erlang, RabbitMQ — платформа, ориентированная на обработку сообщений (реализует AMQP, MQTT[157]), Wings 3D — программа 3D-моделирования и другие.[152]

Для Erlang были написаны несколько веб-серверов: Yaws (англ. Yet Another Web Server), Cowboy, а также MochiWeb — библиотека для создания HTTP-серверов[158]. Кроме того, были созданы несколько веб-фреймворков и систем управления содержимым, таких как N2O[159], Nitrogen, Chicago Boss, Zotonic, а также более не разрабатываемые активно BeepBeep, Erlang Web, ErlyWeb[160].

Среди другого известного программного обеспечения, выполненного на Erlang, можно выделить распределённую NoSQL базу данных Riak, спроектированную по принципам Amazon DynamoDB[161], Flussonic (ранее известный как Erlyvideo) — видеостриминговый сервер, поддерживающий несколько протоколов[162]. Для стресс-тестирования распределённых систем можно применять (также распределённый) написанный на Erlang инструмент Tsung, который позволяет эмулировать тысячи (при достаточном количестве тестовых серверов — миллионы) одновременных пользователей[163].

Erlang практически идеально подходят для задач искусственного интеллекта (особенно вычислительного интеллекта, нейроэволюции), основанных на нейронных сетях. Подобное применение возможно благодаря имеющимся у Erlang пяти ключевым свойствам «языка программирования нейронных сетей»: изолированные процессы-нейроны (англ. encapsulation), параллелизм (англ. concurrency, одновременность), механизм обнаружения сбоев, независимость от местоположения (англ. location transparency) и горячая замена кода. Примером такого применения является реализация одного из подходов к нейроэволюции — DXNN[164].

## Сообщество

[править | править код]

Вокруг технологий Erlang образовалось сообщество разработчиков, не отказывающее в поддержке новичкам. Исходный код Erlang доступен через сервис совместной разработки GitHub. Разработчики и пользователи Erlang могут общаться через список рассылки Erlang-questions (вопросы по Erlang) или на IRC-канале #erlang на Freenode. Erlang Factory (www.erlang-factory.com) устраивает по всему миру мероприятия и конференции, среди которых конференция пользователей Erlang (Erlang User Conference). Специальная группа SIGPLAN ACM регулярно проводит Erlang-мастерскую (Erlang Workshop), а конференция OSCON включает секцию по Erlang[165].

## Примечания

[править | править код]

1. ↑ Сайт проекта: The High-Performance Erlang Project (неопр.). Uppsala University. Дата обращения: 6 декабря 2013. Архивировано из оригинала 16 июня 2011 года.
2. ↑ Вариант с `of` употребляется редко.
3. ↑ Флаг `trap_exit` можно установить с помощью функции `process_flag/2`.
4. ↑ Правильно сформированная структура данных любого типа называется термом.

Источники

1. ↑ Release 28.0.1 — 2025.
2. ↑ Virding R. A History of the Erlang VM
3. ↑ Erlang/OTP 18.0 has been released
4. ↑ https://www.erlang.org/downloads
5. ↑ Definition of «erlang» — Collins English Dictionary (неопр.). Дата обращения: 7 января 2015. Архивировано 8 апреля 2015 года.
6. ↑ Чезарини, Томпсон, 2012, с. 42.
7. ↑ Dan McCreary, Ann Kelly, 2013, 10.3 Examples of functional programming languages.
8. ↑ 1 2 3 4 5 Чезарини, Томпсон, 2012, с. 25—26.
9. ↑ 1 2 Знакомьтесь, Erlang, 2009.
10. ↑ 1 2 Armstrong, A History of Erlang, 2007, 6-14.
11. ↑ Armstrong, A History of Erlang, 2007, 6-16.
12. ↑ 1 2 Martin Logan, et al, 2011, p. xxxi.
13. ↑ Bjarne Däcker, Master thesis, 2000, Backlash.
14. ↑ 1 2 3 Чезарини, Томпсон, 2012, с. 26.
15. ↑ 1 2 Armstrong, A History of Erlang, 2007, 6-17.
16. ↑ 1 2 3 Martin Logan, et al, 2011, p. xxxii.
17. ↑ Чезарини, Томпсон, 2012, с. 24—25.
18. ↑ Armstrong, 2007.
19. ↑ Lars-Åke Fredlund. Erlang – a platform for developing distributed software systems (неопр.). — Component Based Software: 2011—2012, Universidad Politécnica de Madrid. Дата обращения: 6 декабря 2013. Архивировано 19 октября 2012 года.
20. ↑ Чезарини, Томпсон, 2012, с. 381.
21. ↑ EEP 0: Index of Erlang Enhancement Proposals (EEPs) (неопр.) (31 мая 2007). Дата обращения: 1 декабря 2013. Архивировано 1 октября 2013 года.
22. ↑ Чезарини, Томпсон, 2012, с. 15.
23. ↑ Cesarini, Thompson, 2009, p. 14.
24. ↑ Simon St. Laurent, 2013, с. vii.
25. ↑ Чезарини, Томпсон, 2012, с. 167.
26. ↑ Tate, 2010, p. 183.
27. ↑ Чезарини, Томпсон, 2012, с. 27.
28. ↑ Чезарини, Томпсон, 2012, с. 117.
29. ↑ Simon St. Laurent, 2013, с. 88.
30. ↑ Чезарини, Томпсон, 2012, с. 117—118.
31. ↑ 1 2 3 Чезарини, Томпсон, 2012, с. 30—31.
32. ↑ Чезарини, Томпсон, 2012, с. 23—24.
33. ↑ Чезарини, Томпсон, 2012, с. 29.
34. ↑ 1 2 Joe Armstrong, Bjarne Däcker, Thomas Lindgren, Håkan Millroth, Erlang product team at Ericsson. Open-source Erlang — White Paper (англ.). Ericsson AB (2013). Архивировано 25 октября 2011 года.
35. ↑ 1 2 Hebert, 2013, Types (or lack thereof).
36. ↑ Чезарини, Томпсон, 2012, с. 39.
37. ↑ Hebert, 2013, Type Specifications and Erlang.
38. ↑ Чезарини, Томпсон, 2012, с. 38—39.
39. ↑ math, STDLIB Reference Manual Version 1.19.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 2 декабря 2013 года.
40. ↑ Martin Logan, et al, 2011, p. 31—32.
41. ↑ 1 2 Чезарини, Томпсон, 2012, с. 41—42.
42. ↑ Simon St. Laurent, 2013, с. 172.
43. ↑ Чезарини, Томпсон, 2012, с. 230—235.
44. ↑ Чезарини, Томпсон, 2012, с. 233—234.
45. ↑ 1 2 Чезарини, Томпсон, 2012, с. 44—45.
46. ↑ Чезарини, Томпсон, 2012, с. 48—51.
47. ↑ Чезарини, Томпсон, 2012, с. 47—48.
48. ↑ Hebert, 2013, Starting Out (for real).
49. ↑ Чезарини, Томпсон, 2012, с. 48—50.
50. ↑ Чезарини, Томпсон, 2012, с. 223.
51. ↑ Simon St. Laurent, 2013, с. 84—85.
52. ↑ Simon St. Laurent, 2013, с. 62.
53. ↑ Чезарини, Томпсон, 2012, с. 46.
54. ↑ Чезарини, Томпсон, 2012, с. 43.
55. ↑ 1 2 Simon St. Laurent, 2013, с. 17.
56. ↑ 1 2 3 Martin Logan, et al, 2011, p. 69—71.
57. ↑ Data Types, Erlang Reference Manual User's Guide Version 5.10.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 2 декабря 2013 года.
58. ↑ Чезарини, Томпсон, 2012, с. 238.
59. ↑ 1 2 3 Martin Logan, et al, 2011, p. 36.
60. ↑ Ports and Port Drivers, Reference Manual User's Guide Version 5.10.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 3 декабря 2013 года.
61. ↑ Чезарини, Томпсон, 2012, с. 40—41.
62. ↑ Чезарини, Томпсон, 2012, с. 235—236.
63. ↑ Чезарини, Томпсон, 2012, с. 43—44.
64. ↑ 1 2 Чезарини, Томпсон, 2012, с. 51—52.
65. ↑ 1 2 Чезарини, Томпсон, 2012, с. 53—55.
66. ↑ Zachary Kessin, 2012, p. 2—3.
67. ↑ Чезарини, Томпсон, 2012, с. 74.
68. ↑ Martin Logan, et al, 2011, p. 56.
69. ↑ Чезарини, Томпсон, 2012, с. 57—62.
70. ↑ Чезарини, Томпсон, 2012, с. 62—65.
71. ↑ Душкин Р. Функциональное программирование на языке Haskell. — ДМК-Пресс, 2007. — С. 120. — 608 с. — ISBN 5-94074-335-8.
72. ↑ Simon St. Laurent, 2013, с. 30—31.
73. ↑ Simon St. Laurent, 2013, с. 32.
74. ↑ Simon St. Laurent, 2013, с. 51.
75. ↑ Чезарини, Томпсон, 2012, с. 220.
76. ↑ Чезарини, Томпсон, 2012, с. 71—73.
77. ↑ Чезарини, Томпсон, 2012, с. 75—76.
78. ↑ Simon St. Laurent, 2013, с. 42.
79. ↑ Simon St. Laurent, 2013, с. 44—45.
80. ↑ Чезарини, Томпсон, 2012, с. 193.
81. ↑ Чезарини, Томпсон, 2012, с. 194—195.
82. ↑ The Preprocessor, Predefined Macros, Erlang Reference Manual User's Guide Version 5.10.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 2 декабря 2013 года.
83. ↑ Чезарини, Томпсон, 2012, с. 196—197.
84. ↑ Чезарини, Томпсон, 2012, с. 98.
85. ↑ Simon St. Laurent, 2013, с. 108.
86. ↑ 1 2 3 Чезарини, Томпсон, 2012, с. 98—102.
87. ↑ Simon St. Laurent, 2013, с. 110.
88. ↑ Чезарини, Томпсон, 2012, с. 102.
89. ↑ 1 2 Чезарини, Томпсон, 2012, с. 65—66.
90. ↑ 1 2 Hebert, 2013, Modules.
91. ↑ Simon St. Laurent, 2013, с. 18.
92. ↑ Martin Logan, et al, 2011, p. 75.
93. ↑ 1 2 Чезарини, Томпсон, 2012, с. 120—124.
94. ↑ Чезарини, Томпсон, 2012, с. 118—120.
95. ↑ Чезарини, Томпсон, 2012, с. 167—168.
96. ↑ Cesarini, Thompson, 2009, p. 139.
97. ↑ Чезарини, Томпсон, 2012, с. 168—169.
98. ↑ Чезарини, Томпсон, 2012, с. 170—171, 175.
99. ↑ Чезарини, Томпсон, 2012, с. 176—177.
100. ↑ Чезарини, Томпсон, 2012, с. 172—174.
101. ↑ Чезарини, Томпсон, 2012, с. 174.
102. ↑ Martin Logan, et al, 2011, p. 19.
103. ↑ Чезарини, Томпсон, 2012, с. 83—84.
104. ↑ The Erlang I/O-protocol, STDLIB User's Guide Version 1.19.4 (англ.). Ericsson AB (2013). Дата обращения: 21 декабря 2013. Архивировано 24 декабря 2013 года.
105. ↑ Cesarini, Thompson, 2009, p. 79.
106. ↑ STDLIB Reference Manual Version 1.19.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 3 декабря 2013 года.
107. ↑ STDLIB, STDLIB Reference Manual Version 1.19.3 (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 7 ноября 2013 года.
108. ↑ Чезарини, Томпсон, 2012, с. 107—108.
109. ↑ Simon St. Laurent, 2013, с. 131.
110. ↑ Чезарини, Томпсон, 2012, с. 241—247.
111. ↑ Чезарини, Томпсон, 2012, с. 257.
112. ↑ Чезарини, Томпсон, 2012, с. 291.
113. ↑ 1 2 Simon St. Laurent, 2013, с. 151.
114. ↑ 1 2 Чезарини, Томпсон, 2012, с. 291—294.
115. ↑ application, Kernel Reference Manual Version 2.16.3 (англ.). Ericsson AB (2013). Архивировано 1 ноября 2013 года.
116. ↑ Чезарини, Томпсон, 2012, с. 337—339,348.
117. ↑ Simon St. Laurent, 2013, с. 2—3.
118. ↑ 1 2 3 Martin Logan, et al, 2011, p. 23—27.
119. ↑ Hebert, 2013, Starting Out.
120. ↑ Simon St. Laurent, 2013, с. 20—21.
121. ↑ Simon St. Laurent, 2013, с. 21.
122. ↑ Klas Eriksson, M. Williams, J. Armstrong. Programming Rules and Conventions (неопр.). Ericsson AB. Дата обращения: 2 декабря 2013. Архивировано 30 ноября 2013 года.
123. ↑ Чезарини, Томпсон, 2012, с. 460—465.
124. ↑ 1 2 Чезарини, Томпсон, 2012, с. 424—430.
125. ↑ Aronis, et al, 2012.
126. ↑ Чезарини, Томпсон, 2012, с. 442.
127. ↑ Чезарини, Томпсон, 2012, с. 449—450.
128. ↑ Чезарини, Томпсон, 2012, с. 449—450,478.
129. ↑ Simon St. Laurent, 2013, с. 166—167.
130. ↑ Avgerinos, Sagonas, 2009.
131. ↑ Чезарини, Томпсон, 2012, с. 470.
132. ↑ Чезарини, Томпсон, 2012, с. 471.
133. ↑ Чезарини, Томпсон, 2012, с. 31.
134. ↑ Zachary Kessin, 2012, p. 125—128.
135. ↑ elixir (англ.). Plataformatec (2013). Дата обращения: 1 декабря 2013. Архивировано 18 апреля 2012 года.
136. ↑ 1 2 Simon St. Laurent, 2013, с. 168.
137. ↑ Joe Armstrong. erl2, a new dialect of erlang (англ.) (2013). Дата обращения: 1 декабря 2013. Архивировано 5 сентября 2013 года.
138. ↑ Lisp Flavored Erlang (англ.). Дата обращения: 8 декабря 2013. Архивировано 13 декабря 2013 года.
139. ↑ Why I’m stopping work on Reia  Архивная копия от 15 сентября 2015 на Wayback Machine, 2011
140. ↑ Federico Carrone, et al Spawned Shelter! Архивная копия от 5 ноября 2015 на Wayback Machine
141. ↑ Academic and Historical Questions (англ.). Ericsson AB (2013). Дата обращения: 1 декабря 2013. Архивировано 6 октября 2013 года.
142. ↑ Welcome to Erjang! (англ.). Trifork A/S (2013). Дата обращения: 1 декабря 2013. Архивировано 10 марта 2017 года.
143. ↑ Nyström, Trinder, King, 2008.
144. ↑ 1 2 Чезарини, Томпсон, 2012, с. 35—36.
145. ↑ 1 2 3 4 5 6 David Chisnall. A Tale of Two Concurrency Models: Comparing the Go and Erlang Programming Languages (англ.). Pearson Education, Informit (14 ноября 2011). Дата обращения: 1 декабря 2013. Архивировано 3 декабря 2013 года.
146. ↑ 1 2 Damien Katz (создатель CouchDB). What Sucks About Erlang (англ.) (9 марта 2008). Дата обращения: 24 ноября 2013. Архивировано 5 декабря 2013 года.
147. ↑ Armstrong, A History of Erlang, 2007, 6-19,6-20.
148. ↑ Tate, 2010, p. 221.
149. ↑ Dan McCreary, Ann Kelly, 2013.
150. ↑ Larson, Erlang for Concurrent Programming, 2008.
151. ↑ 1 2 Ной Гифт. Работа с большими объемами данных в облаке с помощью MapReduce (неопр.). IBM (1 марта 2012). Дата обращения: 7 декабря 2013. Архивировано 11 декабря 2013 года.
152. ↑ 1 2 Чезарини, Томпсон, 2012, с. 23—25.
153. ↑ Scaling to Millions of Simultaneous Connections Архивная копия от 9 июля 2012 на Wayback Machine, Rick Reed (WhatsApp) // Erlang Factory SF, March 30, 2012
154. ↑ 1 million is so 2011 Архивная копия от 19 февраля 2014 на Wayback Machine // WhatsApp Blog, January 6, 2012
155. ↑ 1 2 Чезарини, Томпсон, 2012, с. 33.
156. ↑ Disco (страница проекта) (неопр.). Дата обращения: 7 декабря 2013. Архивировано 16 сентября 2010 года.
157. ↑ Pivotal Software, Inc. RabbitMQ MQTT Adapter (неопр.). Дата обращения: 10 декабря 2015. Архивировано 1 декабря 2015 года.
158. ↑ Martin Brown. Introduction to programming in Erlang, Part 2: Use advanced features and functionality (англ.). IBM (2013). Дата обращения: 1 декабря 2013. Архивировано 3 декабря 2013 года.
159. ↑ Выпущен новый веб-фреймворк N2O на языке Erlang (неопр.). linux.org.ru. Дата обращения: 13 декабря 2014. Архивировано 14 декабря 2014 года.
160. ↑ Zachary Kessin, 2012, p. 121—123.
161. ↑ Simon St. Laurent, 2013, с. 167.
162. ↑ Flussonic — мультипротокольный видеостриминговый сервер (неопр.). Flussonic, LLC. Дата обращения: 7 мая 2012. Архивировано 16 июня 2012 года.
163. ↑ Bradley Holt. Chapter 6. Distributed Load Testing // Scaling CouchDB. — O'Reilly Media, Inc., 2011. — P. 39. — 72 p. — ISBN 978-1-4493-0343-3.
164. ↑ Sher, 2013, Chapter 5 The Unintentional Neural Network Programming Language, pp. 144—150.
165. ↑ Simon St. Laurent, 2013, с. 168—169.

## Литература

[править | править код]

на русском языке

* Чезарини Ф., Томпсон С. Программирование в Erlang = Erlang Programming. — М.: ДМК Пресс, 2012. — 488 с. — ISBN 978-5-94074-617-1.
* Хеберт Ф. Изучай Erlang во имя добра! = Learn You Some Erlang for Great Good! — М.: ДМК Пресс, 2015. — 686 с. — ISBN 978-5-97060-086-3.
* Чезарини Ф., Виноски С. Проектирования масштабируемых систем в Erlang/OTP = Designing for Scalability with Erlang/OTP. — ДМК Пресс, 2017. — 486 с. — ISBN 978-5-97060-212-6.

на английском языке

* Francesco Cesarini, Simon Thompson. Erlang Programming. — O’Reilly Media, Inc., 2009. — 498 p. — ISBN 978-0-596-51818-9.
* Joe Armstrong. Programming Erlang: Software for a Concurrent World. — Pragmatic Bookshelf, 2007. — 536 p. — ISBN 978-1-93435-600-5.
* Bruce A. Tate. Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages. — Pragmatic Bookshelf, 2010. — ISBN 9781934356593.
* Simon St. Laurent. Introducing Erlang. — O’Reilly Media, Inc., 2013. — 185 p. — ISBN 978-1-449-33176-4.
* Zachary Kessin. Building Web Applications with Erlang. — O’Reilly Media, Inc., 2012. — 156 p. — ISBN 978-1-4493-0996-1.
* Martin Logan, Eric Merritt, Richard Carlsson. Erlang and OTP in Action. — Manning, 2011. — 397 p. — ISBN 9781933988788.
* Fred Hébert. Learn You Some Erlang for Great Good!: A Beginner's Guide. — No Starch Press, 2013. — 624 p. — ISBN 978-1593274351.
* Dan McCreary, Ann Kelly. 10.5. Case study: building NoSQL systems with Erlang // Making Sense of NoSQL: A guide for managers and the rest of us. — Manning Publications, 2013. — 312 p. — ISBN 978-1-61729-107-4.
* Sher, Gene I. Handbook of Neuroevolution Through Erlang. — Springer, 2013. — 831 p. — ISBN 978-1-4614-4462-6.

* Robert Virding, Claes Wikström, Mike Williams. Concurrent Programming in ERLANG / J. Armstrong. — 2nd ed. — Prentice Hall International (UK) Ltd., 1996. — ISBN 0-13-508301-X.
* Maurice Castro. Erlang in Real Time. — Department of Computer Science, RMIT, Australia, 2001. — ISBN 0864447434.

## Статьи

[править | править код]

* Дмитрий Васильев. Знакомьтесь, Erlang // Системный администратор. — 2009. — № 8. — ISSN 1813-5579.
* Joe Armstrong. Erlang (англ.) // Communications of the ACM. — 2010. — Vol. 53, no. 9. — P. 68—75. — doi:10.1145/1810891.1810910.
* Armstrong, Joe (Январь 2007). A History of Erlang. Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages. HOPL III. San Diego, California: ACM. pp. 6−1—6-26. doi:10.1145/1238844.1238850. 978-1-59593-766-7. Дата обращения: 6 декабря 2013.
* Jim Larson. Erlang for Concurrent Programming (англ.) // ACM Queue. — 2008. — No. 5. — P. 18—23. — doi:10.1.1.207.3752.
* J. H. Nyström and P. W. Trinder and D. J. King. High-level distribution for the rapid production of robust telecoms software: comparing C++ and ERLANG (англ.) // Concurrency and Computation: Practice and Experience. — 2008. — Vol. 20, no. 8. — P. 941—968. — doi:10.1002/cpe.1223.
* Bjarne Däcker. Concurrent Functional Programming for Telecommunications: A Case Study of Technology Introduction (англ.) // Master thesis, Royal Institute of Technology. — Stockholm, 2000.
* Avgerinos, Thanassis and Sagonas, Konstantinos. Cleaning Up Erlang Code is a Dirty Job but Somebody's Gotta Do It (англ.) // Proceedings of the 8th ACM SIGPLAN Workshop on ERLANG. — Edinburgh, Scotland: ACM, 2009. — doi:10.1145/1596600.1596602.
* Пол Крил. Функциональное программирование — друг параллелизма // Открытые системы. — 2010. — № 8.
* Начала работы с Erlang = Getting Started With Erlang // RSDN Magazine. — 2006. — № 3. — ISSN 0234-6621. Архивировано 5 августа 2025 года.
* Aronis, Stavros and Papaspyrou, Nikolaos and Roukounaki, Katerina and Sagonas, Konstantinos and Tsiouris, Yiannis and Venetis, Ioannis E. (2012). A Scalability Benchmark Suite for Erlang/OTP. Proceedings of the Eleventh ACM SIGPLAN Workshop on Erlang Workshop. Erlang '12. Copenhagen, Denmark: ACM. pp. 33–42\. doi:10.1145/2364489.2364495. ISBN 978-1-4503-1575-3. 978-1-59593-766-7. Дата обращения: 9 декабря 2013.33-42&rft.pub=ACM&rft.date=2012&rft_id=info:doi/10.1145/2364489.2364495&rft.isbn=978-1-4503-1575-3&rft.au=Aronis,+Stavros+and+Papaspyrou,+Nikolaos+and+Roukounaki,+Katerina+and+Sagonas,+Konstantinos+and+Tsiouris,+Yiannis+and+Venetis,+Ioannis+E.&rft_id=http://doi.acm.org/10.1145/1238844.1238850&rfr_id=info:sid/ru.wikipedia.org:Erlang" class="Z3988">`{{cite conference}}`: Википедия:Обслуживание CS1 (множественные имена: authors list) (ссылка)

## Ссылки

[править | править код]

* Официальный сайт Open-source Erlang (англ.).
* Erlang Community Site (англ.). Дата обращения: 22 января 2022. Архивировано из оригинала 5 мая 2019 года.
* Дмитрий Васильев. Язык программирования Erlang (неопр.).
* Андрей Зубинский. Erlang. Знакомство не по правилам (неопр.). «Компьютерное Обозрение» (20 июля 2009).
* J. David Eisenberg. Études for Erlang (англ.). Дата обращения: 5 декабря 2013. Архивировано из оригинала 29 октября 2013 года.
* Try Erlang (англ.). — онлайн-интерпретатор языка Erlang.
* Gene I. Sher. Neuroevolution Through Erlang (англ.). Erlang Factory. — Слайды с Erlang Factory в San Francisco, март 2012.

Языки программирования

* История
* Хронология

* 1C
* Ада
* Алгол
* Ассемблер
* APL
* Бейсик
* Си
* C++
* C#
* D
* Delphi
* Кобол
* Erlang
* F#
* Форт
* Фортран
* Go
* Groovy
* Haskell
* Java
* JavaScript
* Julia
* Kotlin
* Лисп
* Lua
* MATLAB
* Оберон
* Objective-C
* OCaml
* Паскаль
* Perl
* PL/SQL
* PHP
* Python
* Racket
* Ruby
* Rust
* Scala
* UNIX Shell
* Smalltalk
* Swift
* Visual Basic .NET
* Zig

Эта статья входит в число хороших статей русскоязычного раздела Википедии.

|

*[М.]: Москва