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

Erlang

Парадигмы	Мультипарадигма : параллельная , функциональная
Разработано	Джо Армстронг Роберт Вирдинг Майк Уильямс
Разработчик	Ericsson
Впервые появился	1986 ; 35 лет назад ( 1986 )
Стабильный выпуск	23.2.7 [1] / 3 марта 2021 г . ; 12 дней назад ( 2021-03-03 )
Печатная дисциплина	Динамичный , сильный
Лицензия	Лицензия Apache 2.0
Расширения имени файла	.erl, .hrl
Интернет сайт	www .erlang .org
Основные реализации
Erlang
Под влиянием
Lisp , PLEX , [2] Пролог , Smalltalk
Под влиянием
Akka , Clojure [ необходима ссылка ] , Dart , Elixir , F # , Opa , Oz , Reia , Rust , Scala
Программирование на Erlang в Викиучебнике

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

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

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

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

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

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

История [ править ]

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

В 1998 году Эрикссон анонсировал коммутатор AXD301, содержащий более миллиона строк Erlang, и сообщил о достижении высокой доступности в девять девяток . ^[11] Вскоре после этого Ericsson Radio Systems запретила внутреннее использование Erlang для новых продуктов, сославшись на предпочтение непатентованных языков. Запрет заставил Армстронга и других покинуть Ericsson. ^[12] В конце года исходный код реализации был открыт. ^[6] Эрикссон в конце концов снял запрет и повторно нанял Армстронга в 2004 году. ^[12]

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

Процессы [ править ]

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

Джо Армстронг, соавтор Erlang, резюмировал принципы процессов в своей докторской диссертации : ^[13]

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

Джо Армстронг заметил в интервью Rackspace в 2013 году: «Если Java - это« писать один раз, запускать где угодно », то Erlang - это« писать один раз, запускать вечно »». ^[14]

Использование [ править ]

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

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

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

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

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

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

Факториал [ править ]

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

- модуль ( факт ).  % Это файл "fact.erl", модуль и имя файла должны совпадать - экспорт ([ fac / 1 ]).  % Экспорт функции 'fac' арности 1 (1 параметр, без типа, без имени)fac ( 0 )  ->  1 ;  % Если 0, то вернуть 1, в противном случае (обратите внимание на точку с запятой; означает «иначе») fac ( N ),  когда  N  >  0 ,  is_integer ( N )  ->  N  *  fac ( N - 1 ). % Рекурсивно определить, а затем вернуть результат % (обратите внимание на точку., Означающую «endif» или «конец функции») %% Эта функция выйдет из строя, если будет задано что-либо, кроме неотрицательного целого числа. %% Это иллюстрирует философию Erlang «Пусть он рухнет».

Последовательность Фибоначчи [ править ]

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

%% Объявление модуля должно соответствовать имени файла "series.erl" - module ( series ).%% Оператор экспорта содержит список всех тех функций, которые составляют %% общедоступный API модуля. В этом случае этот модуль предоставляет единственную функцию %% с именем fib, которая принимает 1 аргумент (IE имеет арность 1) %% Общий синтаксис для -export - это список, содержащий имя и %% арность каждой публичной функции - export ([ fib / 1 ]).%% ------------------------------------------------ --------------------- %% Общедоступный API %% ----------------------- ----------------------------------------------%% Обработка случаев, когда fib / 1 получает определенные значения %% Порядок, в котором объявляются эти сигнатуры функций, является важной %% частью функциональности этого модуля.%% Если fib / 1 передается в точности целое число 0, то возвращается 0 fib ( 0 )  ->  0 ;%% Если fib / 1 получает отрицательное число, то возвращает атом err_neg_val %% Обычно такое защитное кодирование не приветствуется из-за философии Erlang «Let %% it Crash»; однако в этом случае мы должны явно %% предотвратить ситуацию, которая приведет к сбою механизма выполнения Erlang fib ( N ),  когда  N  <  0  ->  err_neg_val ;%% Если fib / 1 передается целое число меньше 3, то возвращается 1 %% Предыдущие две сигнатуры функций обрабатывают все случаи, когда N <1, %%, поэтому эта сигнатура функции обрабатывает случаи, когда N = 1 или N = 2 fib ( N )  при  N  <  3  ->  1 ;%% Для всех остальных значений вызовите частную функцию fib_int / 3, чтобы выполнить %% вычисление fib ( N )  ->  fib_int ( N ,  0 ,  1 ).%% ------------------------------------------------ --------------------- %% Частный API %% ----------------------- ----------------------------------------------%% Если fib_int / 3 получает 1 в качестве своего первого аргумента, тогда все готово, поэтому %% возвращает значение в аргументе B. Поскольку нас не интересует значение %% второго аргумента, мы обозначаем это с помощью _ для указания значения %% "безразлично" fib_int ( 1 ,  _,  B )  ->  B ;%% Для всех других комбинаций аргументов рекурсивно вызовите fib_int / 3 %%, где каждый вызов делает следующее: %% - счетчик уменьшения N %% - берет предыдущее значение фибоначчи в аргументе B и передает его как %% аргумент A %% - Вычислить значение текущего числа Фибоначчи и передать его %% в качестве аргумента B fib_int ( N ,  A ,  B )  ->  fib_int ( N - 1 ,  B ,  A + B ).

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

- модуль ( серия ). - экспорт ([ fib / 1 ]).fib ( 0 )  ->  0 ; fib ( N ),  когда  N  <  0  ->  err_neg_val ; fib ( N ),  когда  N  <  3  ->  1 ; fib ( N )  ->  fib_int ( N ,  0 ,  1 ).fib_int ( 1 ,  _,  B )  ->  B ; fib_int ( N ,  A ,  B )  ->  fib_int ( N - 1 ,  B ,  A + B ).

Быстрая сортировка [ править ]

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

%% qsort: qsort (Список) %% Сортировка списка элементов - модуль ( qsort ).  % Это файл 'qsort.erl' - экспорт ([ qsort / 1 ]).  % Экспортируется функция 'qsort' с 1 параметром (без типа, без имени)qsort ([])  ->  [];  % Если список [] пуст, вернуть пустой список (нечего сортировать) qsort ([ Pivot | Rest ])  ->  % Составить рекурсивно список с 'Front' для всех элементов, которые должны быть перед 'Pivot'  % then ' Pivot ', затем' Back 'для всех элементов, которые должны быть после' Pivot '  qsort ([ Front  ||  Front  <-  Rest ,  Front  <  Pivot ])  ++  [ Pivot ]  ++  qsort ([ Back  ||  Back  <-  Rest ,  > =  Pivot ]).

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

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

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

% Это файл listsort.erl (компилятор сделан таким образом) - модуль ( listsort ). % Export 'by_length' с 1 параметром (неважно тип и имя) - экспорт ([ by_length / 1 ]).by_length ( Lists )  ->  % Используйте 'qsort / 2' и предоставляет анонимную функцию в качестве параметра  qsort ( Lists ,  fun ( A , B )  ->  length ( A )  <  length ( B )  end ).qsort ([],  _) ->  [];  % Если список пуст, вернуть пустой список (игнорировать второй параметр) qsort ([ Pivot | Rest ],  Smaller )  ->  % Список разделов с элементами «меньшего размера» перед элементом «Pivot», а не элементами «меньшего размера»  % после «Pivot» и отсортируйте подсписки.  qsort ([ X  ||  X  <-  Остальное ,  Меньшее ( X , Pivot )],  Меньшее )  ++  [ Pivot ]  ++  qsort ([ Y  || Y  <-  Отдых , а  не ( Меньший ( Y ,  Pivot ))],  Меньший ).

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

[ X  ||  X  <-  Остальное ,  Меньшее ( X , Поворот )]

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

[ Спереди  ||  Передний  <-  Остальной ,  Передний  <  Поворотный ]

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

веселье ( A , B )  ->  длина ( A )  <  длина ( B )  конец

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

Типы данных [ править ]

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

Целые числа

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

Атомы

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

Поплавки

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

Рекомендации

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

Двоичные файлы

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

Pids

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

Порты

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

Funs

Funs - это закрытие функций . 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}.

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

Струны

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

Записи

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

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

Стиль кодирования "Let it Crash" ^{[22] [23]} [ править ]

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

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

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

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

Таким образом, стиль кодирования «Let it Crash» является практическим следствием работы с языком, который работает на этих принципах.

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

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

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

Кроме того, «Let it Crash» приводит к стилю кодирования, содержащему мало защитного кода, что приводит к уменьшению размера приложений.

Ориентация на параллелизм и распространение [ править ]

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

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

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

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

 % Создайте процесс и вызовите функцию web: start_server (Port, MaxConnections)  ServerProcess  =  spawn ( web ,  start_server ,  [ Port ,  MaxConnections ]), % Создайте удаленный процесс и вызовите функцию  % web: start_server (Port, MaxConnections) на машине RemoteNode  RemoteProcess  =  spawn ( RemoteNode ,  web ,  start_server ,  [ Port ,  MaxConnections ]), % Отправить сообщение в ServerProcess (асинхронно). Сообщение состоит из кортежа  % с атомом «пауза» и числом «10».  ServerProcess  !  { пауза ,  10 }, % Получать сообщения, отправленные этому процессу,  получить  a_message  ->  do_something ;  { данные ,  DataContent }  ->  дескриптор ( DataContent );  { привет ,  текст }  ->  io : format ( "Получил приветственное сообщение: ~ s " ,  [ Текст ]);  { Goodbye ,  Text }  ->  io : format ( "Получил прощальное сообщение: ~ s " ,  [ Text])  конец .

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

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

Реализация [ править ]

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

Загрузка горячего кода и модули [ править ]

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

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

 %% Процесс, единственная задача которого - вести счетчик.  %% Первая версия  - модуль ( счетчик ).  - экспорт ([ start / 0 ,  codewitch / 1 ]). start ()  ->  цикл ( 0 ). цикл ( сумма )  ->  получение  { приращение ,  счетчик }  ->  цикл ( сумма + счет );  { counter ,  Pid }  ->  Pid  !  { счетчик ,  сумма },  цикл ( сумма );  code_switch  ->  ? МОДУЛЬ : кодовый переключатель ( Сумма )  % Принудительное использование «кодового переключателя / 1» с  конца последней версии МОДУЛЯ . кодовый переключатель ( Сумма )  ->  цикл ( Сумма ).

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

 %% Вторая версия  - модуль ( счетчик ).  - экспорт ([ start / 0 ,  codewitch / 1 ]). start ()  ->  цикл ( 0 ). цикл ( сумма )  ->  получение  { приращение ,  счетчик }  ->  цикл ( сумма + счет );  сброс  ->  цикл ( 0 );  { counter ,  Pid }  ->  Pid  !  { счетчик ,  сумма },  цикл ( сумма );  code_switch  ->  ? МОДУЛЬ : кодовый переключатель ( Сумма )  конец . кодовый переключатель ( Сумма )  ->  цикл ( Сумма ).

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

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

Распространение [ править ]

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

После выпуска с открытым исходным кодом Erlang использовался несколькими фирмами по всему миру, включая Nortel и T-Mobile . ^[32] Хотя Erlang был разработан, чтобы заполнить нишу и оставался малоизвестным языком на протяжении большей части своего существования, его популярность растет из-за спроса на параллельные сервисы. ^{[33] [34]} Erlang нашел применение в развертывании серверов массовых многопользовательских ролевых онлайн-игр (MMORPG). ^[35]

См. Также [ править ]

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

Ссылки [ править ]

Дальнейшее чтение [ править ]

Внешние ссылки [ править ]

Викискладе есть медиафайлы, связанные с Erlang (языком программирования) .

В Викиучебнике есть книга по теме: Программирование на Erlang.

• Официальный веб-сайт