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

Эрланг

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

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

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

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

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

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

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

История

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

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

Майк Уильямс

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

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

Процессы

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

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

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

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

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

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

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

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

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

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

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

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

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

Факториал

Алгоритм факториала , реализованный в 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» или «конец функции») 
 %% Эта функция завершится сбоем, если будет задано что-либо, кроме неотрицательного целого числа. 
  %% Он иллюстрирует философию Эрланга «Пусть рухнет». 

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

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

%% Объявление модуля должно совпадать с именем файла «series.erl» 
 —  модуль  (  series  ). 

  %% Оператор экспорта содержит список всех тех функций, которые формируют 
 %% общедоступный API модуля.   В этом случае этот модуль предоставляет одну 
 функцию %%, называемую fib, которая принимает 1 аргумент (IE имеет арность 1) 
 %% Общий синтаксис для -export представляет собой список, содержащий имя и 
 %% арность каждой общедоступной функции 
 -  экспорт  ([  фиб  /  1  ]). 

  %% -------------------------------------------------- --------------------- 
 %% Публичный API 
 %% ----------------------- --------------------------------------------- 

 %% Обработка случаев в котором fib/1 получает определенные значения 
 %% Порядок объявления этих сигнатур функций является жизненно важной 
 %% частью функциональности этого модуля 

 %% Если fib/1 передается точное целое число 0, то возвращается 0 
 fib  (  0  )   - >   0  ; 

  %% Если fib/1 получает отрицательное число, то вернуть атом err_neg_val 
 %% Обычно такое защитное кодирование не рекомендуется из-за философии Эрланга «Пусть 
 %% произойдет сбой»;   однако в этом случае мы должны явно 
%% предотвращает ситуацию, которая приведет к сбою механизма выполнения Erlang 
 (  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  ). 

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

-  модуль  (  серия  ). 
  -  экспорт  ([  фиб  /  1  ]). 

  фиб  (  0  )   ->   0  ; 
  fib  (  N  ),   когда   N   <   0   ->   err_neg_val  ; 
  fib  (  N  )   когда   N   <   3   ->   1  ; 
  фиб  (  N  )   ->   фиб_int  (  N  ,   0  ,   1  ). 

  fib_int  (  1  ,   _,   B  )   ->   B  ; 
  fib_int  (  N  ,   A  ,   B  )   ->   fib_int  (  N  -  1  ,   B  ,   A  +  B  ). 

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

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

%% qsort:qsort(List) 
 %% Сортировка списка элементов 
 —  модуль  (  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  ,   Назад   >=   Разворот  ]). 

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

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

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

% Это файл listsort.erl (так устроен компилятор) 
 —  модуль  (  listsort  ). 
  % Экспортировать «по_длине» с 1 параметром (тип и имя не важны) 
 —  экспорт  ([  по_длине  /  1  ]). 

  by_length  (  Lists  )   ->   % Используйте 'qsort/2' и предоставляет анонимную функцию в качестве параметра 
    qsort  (  Lists  ,   fun  (  A  ,  B  )   ->   length  (  A  )   <   length  (  B  )   end  ). 

  qsort  ([],   _)  ->   [];    % Если список пуст, вернуть пустой список (игнорировать второй параметр) 
 qsort  ([  Pivot  |  Rest  ],   Smaller  )   -> 
     % Список разделов с элементами «Меньший» перед элементами «Опорный» и не- «Меньший» 
     % после «Pivot» и отсортируйте подсписки. 
      qsort  ([  X   ||   X   <-   Rest  ,   Smaller  (  X  ,  Pivot  )],   Smaller  ) 
     ++   [  Pivot  ]   ++ 
     qsort  ([  Y   ||   Y   <-   Rest  ,   not  (  Smaller  (  Y  ,   Pivot  ))],   Меньше  ). 

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

[  Икс   ||    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 существуют для составления и разложения двоичных файлов, а также для эффективного ввода/вывода двоичных файлов.

Пиды

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

Порты

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

Веселье

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

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

Кортежи

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

Списки

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

Карты

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

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

Струны

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

Рекорды

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

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

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

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

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

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

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

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

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

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

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

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

 % Создайте процесс и вызовите функцию 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». 
   Серверный процесс   !    {  пауза  ,   10  }, 

  % Получать сообщения, отправленные этому процессу, 
  получать 
          a_message   ->   do_something  ; 
           {  данные  ,   DataContent  }   ->   дескриптор  (  DataContent  ); 
           {  hello  ,   Text  }   ->   io  :  format  (  «Получил приветственное сообщение:  ~s  »  ,   [  Text  ]); 
           {  до свидания  ,   текст  }   ->   io  :  format  (  «Получил прощальное сообщение:  ~s  »  ,   [  текст  ]) 
  end  . 

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

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

Реализация

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

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

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

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

  %% Процесс, единственной задачей которого является ведение счетчика. 
    %% Первая версия 
   —  модуль  (  счетчик  ). 
    -  экспорт  ([  start  /  0  ,   codeswitch  /  1  ]). 

    старт  ()   ->   цикл  (  0  ). 

    цикл  (  Сумма  )   -> 
     получение 
        {  приращение  ,   Счетчик  }   -> 
           цикл  (  Сумма  +  Счет  ); 
         {  счетчик  ,   Pid  }   -> 
           Pid   !    {  счетчик  ,   сумма  }, 
           цикл  (  сумма  ); 
         код_переключатель   -> 
           ?   MODULE  :  codeswitch  (  Sum  ) 
           % Принудительно использовать 'codeswitch/1' из последней версии MODULE 
     end  . 

    кодовый переключатель  (  Sum  )   ->   цикл  (  Sum  ). 

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

  %% Вторая версия 
   —  модуль  (  счетчик  ). 
    -  экспорт  ([  start  /  0  ,   codeswitch  /  1  ]). 

    старт  ()   ->   цикл  (  0  ). 

    цикл  (  Сумма  )   -> 
     получение 
        {  приращение  ,   Счетчик  }   -> 
           цикл  (  Сумма  +  Счет  ); 
         сброс   -> 
           цикл  (  0  ); 
         {  счетчик  ,   Pid  }   -> 
           Pid   !    {  счетчик  ,   сумма  }, 
           цикл  (  сумма  ); 
         код_переключатель   -> 
           ?   МОДУЛЬ  :  кодовый переключатель  (  Сумма  ) 
     конец  . 

    кодовый переключатель  (  Sum  )   ->   цикл  (  Sum  ). 

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

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

Распространение

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

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

См. также

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

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

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

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

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