Erlang

1986 року в Ericsson Computer Science Laboratory Джо Армстронг, Роберт Вірдінг і Майк Вільямс досліджували мови та інструменти для побудови програмного забезпечення телефонних комутаторів. Перші прототипи Erlang реалізували засобами Prolog: це дозволяло швидко експериментувати із синтаксисом, зіставленням зі взірцем і взаємодією процесів. До кінця 1980-х років основні рішення щодо мови сформувалися.^[7][6]

Назва Erlang одночасно відсилає до Агнера Крарупа Ерланга, основоположника теорії масового обслуговування, та до гри слів ERicsson LANGuage. Учасники розробки підтверджували цю подвійність походження назви. Мову не слід плутати з ерлангом — одиницею телекомунікаційного навантаження.^[8][2]

Для практичної експлуатації початкова реалізація на Prolog була надто повільною. 1989 року з'явилася абстрактна машина JAM (англ. Joe's Abstract Machine), реалізована переважно мовою C. Пізніше експериментували з TEAM — трансляцією Erlang у C — та створили віртуальну машину BEAM, призначену для виконання компактного скомпільованого коду. Ранні варіанти BEAM суттєво змінювалися, перш ніж стало можливим стабілізувати формат її модулів.^[9]

Важливими джерелами ідей для Erlang були логічне програмування Prolog, обмін повідомленнями незалежних процесів та практики розробки систем, які повинні працювати під час оновлення окремих компонентів. Із середини 1990-х років Erlang дедалі більше використовували в реальних продуктах Ericsson, зокрема завдяки інструментам OTP, покликаним стандартизувати запуск, контроль і оновлення багатокомпонентних систем.^[7][6]

У 1996 році вийшов перший випуск OTP R1B. Платформа поєднувала середовище виконання та прикладні бібліотеки й поступово перетворила Erlang з окремої мови на основу для розроблення великих систем. 1998 року Ericsson оприлюднила вихідний код Erlang/OTP. Поширення за межами компанії підтримали незалежні розробники, навчальні матеріали, дослідницькі групи та компанії, які використовували Erlang у власних продуктах.^[9][7][1]

Спочатку відкриті випуски використовували Erlang Public License, створену на основі Mozilla Public License. Починаючи з OTP 18.0 (2015), вихідний код поширюють за Apache License 2.0.^[10]

Один із довготривалих напрямів розвитку Erlang/OTP — масштабування на багатоядерних комп'ютерах: від підтримки SMP у 2006 році до перероблення планувальників і системи пам'яті. Інший — удосконалення компілятора: від введення Core Erlang до проміжного представлення SSA та JIT-компілятора BeamAsm, описаних докладніше у статті про BEAM. Наукові дослідження показували, що зі зростанням числа процесорних ядер і вузлів розподіленої системи з'являються нові вузькі місця, які потребують архітектурних змін.^[11][9]

Випуски Erlang/OTP відображають зміни не лише синтаксису Erlang, а й віртуальної машини BEAM, системи виконання ERTS, стандартних бібліотек та інструментів розробки. У старій схемі назви мали вигляд R11B чи R16B, а починаючи з OTP 17.0 (2014) використовують цифрові версії на зразок 28.1.2. Їхні основні частини позначають головні зміни, функціональні оновлення та виправлення; додаткові числові частини можливі в окремих гілках супроводу. Кожний застосунок OTP, наприклад kernel або stdlib, має також власну версію.^[12]

Наведено основні історичні випуски від початку платформи до OTP 29, без переліку кожного виправлення. Для розуміння того, які зміни стосувалися саме синтаксису Erlang, а які — ERTS чи OTP, подальші етапи потрібно читати з урахуванням усіх компонентів. Для раннього періоду збережена документація неоднакова за повнотою: там, де точна дата або окреме нововведення недостатньо підтверджені, подано лише загальний період і документовану тенденцію, а не припущення.

Зміни Erlang/OTP мають різну природу. Наприклад, maps та maybe розширили виражальні засоби самої мови, тоді як SMP, багаточергове планування і BeamAsm змінили переважно спосіб виконання програм. Тому номер випуску платформи не слід сприймати як номер редакції лише синтаксису Erlang.^[12][11]

Після основного випуску виходять проміжні оновлення з виправленнями та вдосконаленнями. Станом на 21 жовтня 2026 року найновіший опублікований випуск — Erlang/OTP 29.1.2 від 14 жовтня 2026 року; його зміни відображені в офіційних примітках до випуску.^[39] Для всіх проміжних оновлень існує офіційний покажчик версій.

Серед технічних нововведень зручно відрізняти мовні конструкції, які стають доступні програмісту, від змін у компіляторі та системі виконання. Наприклад, у серії R7B удосконалили запис двійкових послідовностей, тоді як запровадження підтримки SMP у R11B насамперед змінювало спосіб виконання вже написаних програм.^[13][18]

У OTP 17 мова отримала експериментальні карти (maps), а в OTP 18 виконання операцій над великими картами оптимізували завдяки внутрішньому представленню HAMT. У OTP 19 з'явилася поведінка gen_statem, але вона належить до бібліотек OTP, а не до нового синтаксису Erlang. OTP 20 розширила допустимі символи Unicode в іменах атомів і можливості роботи з картами.^{[24][25][26][27]}

У OTP 21 з'явилися макрос ?OTP_RELEASE та препроцесорні директиви -if і -elif, що спростило умовну компіляцію для різних випусків. OTP 23 дозволила підкреслення в числових літералах, зокрема 1_000_000, та ширше використання охоронних виразів під час зіставлення з двійковими даними й картами. У OTP 25 запровадили механізм вибіркового увімкнення нових мовних можливостей і експериментальний вираз maybe, який за замовчуванням став доступним із OTP 27.^{[28][40][34][36]}

У OTP 26 з'явилися генератори карт, а OTP 27 додала багаторядкові рядкові літерали та сигіли. OTP 28 розширила синтаксис генераторів суворими й паралельними формами, підтримала літерали дійсних чисел у різних системах числення й дала змогу використовувати іменовані типи в засобах статичного аналізу. OTP 29 доповнила мову експериментальними нативними записами, генераторами з кількома результатами, охоронною функцією is_integer/3 і лівоасоціативним викликом функцій. Оскільки частина цих можливостей спочатку експериментальна, їхня доступність залежить від випуску й параметрів компіляції.^{[35][36][37][38][41]}

Комплексну історію версій і змін у стандартних бібліотеках наведено у статті про OTP, історію компілятора та JIT — у статті про BEAM, розвиток планувальників, пам'яті й процесів — у статті про ERTS.

Основною одиницею виконання в Erlang є процес Erlang — легка сутність, якою керує середовище ERTS. Він має власний контекст виконання, поштову скриньку та простір пам'яті для звичайних термів. Процеси створюють функції spawn і spawn_link, а посилаються на них за ідентифікаторами типу pid. Їхня кількість може бути значно більшою, ніж число потоків операційної системи.^[42][43]

Обмін даними між процесами зазвичай відбувається через асинхронні повідомлення: оператор ! надсилає повідомлення, а конструкція receive вибирає з поштової скриньки повідомлення, що відповідає одному з описаних взірців. Надсилання повідомлення не означає ані завершення обробки, ані гарантії доставки на віддалений вузол. За потреби застосунок реалізує підтвердження, контроль часу очікування і повторні спроби.^[42]

Процеси Erlang ізольовані, але формулювання «Erlang взагалі не має спільної пам'яті» було б неточним. Віртуальна машина надає, зокрема, таблиці ETS, якими можуть користуватися різні процеси; також доступна інтеграція з кодом інших мов. Модель Erlang близька до моделі акторів, проте її конкретні правила доставки, обробки повідомлень і контролю помилок визначає сама платформа.^[44][42]

Конкурентність означає організацію декількох незалежних потоків роботи, тоді як паралельність — їхнє фактичне виконання одночасно на декількох ядрах. Програма Erlang може бути конкурентною і на одноядерній машині; для паралельного виконання ERTS використовує декілька планувальників.^[18]

Erlang дозволяє створювати зв'язки (links) та монітори (monitors) між процесами. Зв'язок передає сигнал про завершення пов'язаного процесу й, залежно від типу завершення та налаштувань, може призвести до припинення іншого процесу. Монітор дає змогу спостерігачеві отримати повідомлення 'DOWN' про завершення підконтрольного процесу, не пов'язуючи їхні життєві цикли безпосередньо.^[42]

Підхід, який часто описують словами «let it crash» («нехай зазнає збою»), передбачає, що неочікувану внутрішню помилку окремого робочого процесу можна опрацювати на рівні системи нагляду: завершити несправну одиницю роботи, а тоді відновити її або пов'язану групу процесів у визначеному порядку. Він не є закликом ігнорувати перевірку введених даних, помилки прикладної логіки чи цілісність даних.^[5][6]

Erlang створювали для систем, чутливих до затримок, тому віртуальна машина використовує планування з витісненням і прагне не допускати, щоб довге обчислення одного процесу нескінченно затримувало інших. Це робить Erlang придатним для багатьох завдань м'якого реального часу, проте не встановлює гарантованої верхньої межі затримки для кожної операції, як у системах жорсткого реального часу.^[1][42]

Процеси Erlang можуть виконуватися на різних вузлах (nodes), які спілкуються через механізми розподіленого Erlang. У межах мережі процеси можуть обмінюватися повідомленнями, створювати монітори й зв'язки та використовувати віддалені виклики. Це спрощує побудову сервісів, розміщених на кількох комп'ютерах, але не усуває мережевих затримок, втрат з'єднання або проблеми узгодження стану після розділення мережі.^[45][11]

Система Erlang підтримує оновлення завантажених модулів під час роботи, або гарячу заміну коду. Вона може певний час зберігати стару й нову версії одного модуля, дозволяючи керовано переводити процеси на новий код. Це не означає, що будь-яке оновлення відбувається автоматично або без ризику: зміни формату стану, взаємодії модулів та порядку оновлення потрібно передбачати в застосунку. OTP надає для цього додаткові механізми версій застосунків і сценаріїв оновлення.^[3][46]

Erlang — функційна мова з строгим порядком обчислення (eager evaluation), динамічною типізацією та одноразовим зв'язуванням змінних: змінну в межах одного звичайного контексту не можна повторно призначити іншому значенню. Обчислення будуються з виразів, а рішення часто приймаються за допомогою зіставлення зі взірцем замість послідовної зміни стану.^[47][48]

Назви змінних починаються з великої літери або підкреслення, наприклад Result чи _Unused. Назви атомів зазвичай починаються з малої літери (ok, error), а атоми зі спеціальними символами записуються в одинарних лапках ('Some name'). Крапка завершує визначення функції або іншу завершену форму, а крапка з комою розділяє альтернативні частини однієї функції.^[48]

%% Обчислення факторіала зі зіставленням зі взірцем.
factorial(0) -> 1;
factorial(N) when is_integer(N), N > 0 ->
    N * factorial(N - 1).

У прикладі функція визначена двома частинами: випадок для нуля та випадок для додатного цілого числа. Умова when — це охорона (guard), що обмежує допустимі значення. Якщо жодна частина функції не підходить, виникає виняток.^[48]

Значення Erlang мають типи, однак тип змінної визначається під час виконання. Стандартна система не вимагає оголошувати тип кожного виразу. Водночас розробник може описувати очікувані типи через атрибути -type, -opaque та -spec, а інструмент Dialyzer аналізує можливі розбіжності й недосяжні варіанти викликів. Такий аналіз не перетворює Erlang на традиційну статично типізовану мову.^[49]

У нових випусках система опису типів розвивалася: зокрема, з'явилися тип dynamic() для інструментів аналізу та підтримка nominal types. Слід розрізняти синтаксис специфікацій типів, можливості аналізатора та перевірки, які справді здійснюються під час виконання.^[35][37]

До основних типів Erlang належать цілі числа довільної точності, числа з рухомою комою, атоми, кортежі, списки, бінарні дані, карти (maps), а також ідентифікатори процесів, посилання, порти й функціональні об'єкти. Логічні значення true і false представлені атомами, але використовуються як булеві значення в логічних операціях.^[47]

Атом — іменоване незмінне символьне значення, наприклад ok, timeout або 'DOWN'. На відміну від рядка, атом зазвичай використовують для позначення стану, команди чи ключової категорії. Створювати атоми з довільного неперевіреного введення небезпечно, оскільки їхня кількість у віртуальній машині обмежена.^[47]

Ідентифікатор процесу (pid) вказує на процес Erlang, посилання (reference) застосовують як унікальні маркери запитів чи подій, а порт (port) представляє канал взаємодії із зовнішніми програмами або драйверами.^[47][42]

Список — рекурсивна послідовність із голови та хвоста; її можна розкласти зіставленням [Head | Tail]. Кортеж — структура з визначеною кількістю елементів, записаних у фігурних дужках, наприклад {ok, 42}. Обидва типи можуть містити різнорідні терми. Змінна не може послідовно отримувати інші значення, тому нові версії структур створюються як нові значення.^[47]

First = [10, 20, 30],
[Head | Tail] = First,     % Head = 10, Tail = [20,30]
Response = {ok, Head}.

Історично рядки в Erlang представляли списками цілих чисел — кодових точок символів; сучасні програми також широко використовують бінарні рядки UTF-8. У коді потрібно враховувати відмінність між списком символів, двійковою послідовністю байтів та їхніми способами кодування. Запис "abc" традиційно створює список кодових точок, а <<"abc">> — бінарну послідовність байтів.^[47]

Бінарні дані записують між << та >>. Синтаксис дозволяє задавати розмір полів, знаковість та кодування, тому придатний для роботи з мережевими протоколами та файловими форматами. Bitstrings можуть мати довжину, не кратну восьми бітам, тоді як звичайний binary складається з цілої кількості байтів.^[50]

Packet = <<5:8, 1024:16/big-unsigned-integer>>,
<<Version:8, Length:16/big-unsigned-integer>> = Packet.

Вирази для зіставлення з взірцем використовують під час виклику функцій, у конструкціях case і receive, а також для розбору кортежів, списків, карт і бінарних даних. Якщо взірець не підходить, відповідна гілка не вибирається; у звичайному операторі зіставлення невідповідність породжує виняток.^[48]

Карти (maps) — асоціативні структури, що зіставляють ключі зі значеннями. Вони з'явилися у випуску OTP 17, а пізніше мова отримала додаткові засоби роботи з ними, включно з генераторами. Приклад створення та оновлення карти:^[24][35]

Person = #{name => <<"Olena">>, age => 30},
Older = Person#{age := 31},
#{age := Age} = Older.

Записи (records) — традиційний засіб оголошувати іменовані поля, який компілятор реалізує переважно через кортежі. Поля оголошують директивою -record, а доступ до них позначають символом #. Із OTP 29 експериментально запроваджено native records, які мають окрему реалізацію та інші властивості порівняно зі звичайними записами.^[38][47]

Мова підтримує арифметичні, побітові, логічні оператори та оператори порівняння. Для перевірки структурної рівності застосовують ==, а для точної рівності без автоматичного прирівнювання чисел різних видів — =:=; оператори /= та =/= означають нерівність. Порядок термів у порівняннях визначений правилами мови й не тотожний лексикографічному порядку текстових представлень.^[48]

Функції в Erlang визначаються ім'ям та кількістю аргументів (arity): send/2 і send/3 — різні функції. Підтримуються рекурсія, функції вищого порядку й анонімні функції fun. Важливим способом ефективного повторення обчислень є хвостова рекурсія; для прикладного коду вона часто замінює цикли, властиві імперативним мовам.^[48]

sum(List) -> sum(List, 0).
sum([], Acc) -> Acc;
sum([X | Rest], Acc) -> sum(Rest, Acc + X).

Умовний вибір реалізують через case, if і частини функцій з охоронами; для обробки винятків існує try. Включення списків утворюють нові колекції з результатів перебору, а конструкція maybe дозволяє послідовно перевіряти умовні зіставлення без багаторівневого вкладення case. У сучасних версіях існують також генератори карт, строгі генератори та zip-генератори.^[48][37]

Програма зазвичай складається з модулів у файлах .erl. Атрибут -module задає назву модуля, -export визначає видимі з інших модулів функції, а -spec описує їхні типи. Після компіляції за допомогою erlc чи модуля compile створюється файл .beam, що завантажується в ERTS і виконується BEAM.^[3]

-module(greeting).
-export([hello/1]).
-spec hello(string()) -> string().

hello(Name) ->
    "Привіт, " ++ Name ++ "!".

Дистрибутив Erlang/OTP включає компілятор, систему виконання ERTS й прикладні бібліотеки. Під час розвитку платформи використовувалися різні проміжні представлення коду, зокрема Core Erlang та SSA; з OTP 24 спеціалізований JIT-компілятор BeamAsm створює машинні інструкції для підтримуваних архітектур під час завантаження BEAM-коду.^[9][32]

Код Erlang можна виконувати кількома способами. У звичайних програмах модулі спочатку компілюють у байткод BEAM. До Erlang/OTP 24 його зазвичай виконував інтерпретатор інструкцій віртуальної машини; у сучасних збірках для x86-64 та AArch64 JIT-компілятор BeamAsm перетворює ці інструкції на машинний код під час завантаження модуля. В обох випадках виконується вже скомпільований код.^[9][51]

Erlang також уміє інтерпретувати окремі вирази без створення байткоду для них. Для цього в стандартній бібліотеці є модуль erl_eval. Він обчислює вирази за їхнім абстрактним синтаксичним деревом, яке створює аналізатор erl_parse. Наприклад, інтерактивна оболонка може обчислити введений вираз 1 + 2., не створюючи окремого .beam-файлу. Сам erl_eval написаний мовою Erlang і працює всередині ERTS; якщо з оболонки викликати функцію вже скомпільованого модуля, вона виконається через BEAM.^[52][53]

Ще одне значення слова «інтерпретація» використовується у налагоджувачі Erlang: він дозволяє виконувати вибрані модулі покроково та встановлювати точки зупину. Для цього потрібен скомпільований модуль із налагоджувальною інформацією, тому такий режим не тотожний виконанню довільного вихідного файлу без компіляції. Інтерпретацію виразів і механізми виконання байткоду доцільно розглядати окремо.^[54]

Препроцесор epp підтримує приєднання заголовкових файлів .hrl через -include або -include_lib, текстові макроси -define та умовні директиви -ifdef, -ifndef й -endif. На відміну від функцій, макроси розгортаються до компіляції.^[55]

-define(DEFAULT_TIMEOUT, 5000).

wait_for_message() ->
    receive
        Msg -> {ok, Msg}
    after ?DEFAULT_TIMEOUT ->
        timeout
    end.

Функція spawn(Fun) створює новий процес, який виконує анонімну функцію без аргументів. Кожний процес має власну поштову скриньку, а receive забезпечує вибіркове отримання повідомлень. Повідомлення, що не підходять до наявних взірців, залишаються в скриньці для подальшої обробки. Для обмеження очікування існує частина after.^[42]

Parent = self(),
Pid = spawn(fun() ->
    receive
        {ping, From} -> From ! pong
    end
end),
Pid ! {ping, Parent},
receive
    pong -> ok
end.

Вибіркове отримання дозволяє реалізовувати прикладні протоколи, але надмірне накопичення повідомлень збільшує витрати пам'яті та може ускладнювати пошук потрібного повідомлення. Тому робочі процеси слід проєктувати з урахуванням обмеження навантаження та часу очікування. У OTP 28 додано механізм пріоритетних повідомлень для спеціальних сценаріїв, проте він не замінює загального керування навантаженням.^[42][37]

Операція link(Pid) установлює двосторонній зв'язок завершення, тоді як erlang:monitor(process, Pid) дозволяє спостерігати за процесом без спільної долі завершення. Якщо процес отримує сигнал завершення від зв'язаної сутності, його реакцію можна змінювати, зокрема налаштуванням process_flag(trap_exit, true). У прикладних системах ці низькорівневі механізми зазвичай використовуються всередині стандартних поведінок OTP.^[42][5]

Звичайне введення-виведення забезпечують модулі io, file та інші частини стандартної бібліотеки. Для роботи з мережами використовують, зокрема, gen_tcp, gen_udp і ssl. Порти призначені для взаємодії з зовнішніми виконуваними програмами й драйверами. Команди введення-виведення можуть виконуватися асинхронно щодо інших процесів Erlang завдяки організації середовища виконання.^[4][42]

Open Telecom Platform (OTP) — сукупність бібліотек, стандартних програмних абстракцій та правил проєктування, які застосовують разом із мовою Erlang. Попри історичну назву, OTP використовують не тільки в телекомунікаційних застосунках. Її компоненти охоплюють життєвий цикл застосунків, мережеві протоколи, криптографію, сховища даних, журналювання, тестування й інструменти діагностики.^[56]

Основними складовими платформи є ERTS (середовище виконання, включно з BEAM), kernel і stdlib (базові служби та бібліотеки), sasl (підтримка експлуатації й звітності), crypto й ssl (криптографічні функції й захищені з'єднання), а також численні додаткові застосунки. Версія Erlang/OTP описує набір компонентів, які розробники платформи тестували разом.^[12]

Поведінки (behaviours) — стандартні шаблони побудови процесів із визначеними зворотними викликами. Наприклад, gen_server організовує процес із внутрішнім станом та обробкою синхронних викликів, асинхронних повідомлень й інших подій; gen_statem — процес як скінченний автомат. Поведінки не замінюють бізнес-логіку, а надають узгоджений спосіб реалізації її життєвого циклу.^[56][57]

Супервізор (supervisor) керує запуском, зупиненням та перезапуском дочірніх процесів за визначеною стратегією. Супервізори можуть утворювати ієрархію — дерево нагляду. За різних стратегій збій одного процесу спричиняє перезапуск тільки його самого або групи взаємозалежних процесів. Слід обирати межі відновлення так, щоб перезапуски не приховували систематичних помилок і не призводили до неконтрольованих циклів.^[5]

ETS (Erlang Term Storage) — таблиці термів у пам'яті, до яких можуть звертатися кілька процесів одного вузла. ETS корисна для кешів, лічильників і тимчасових даних, але зазвичай не замінює зовнішню систему довготривалого зберігання. DETS зберігає таблиці термів у файлах; Mnesia — система керування даними зі схемою таблиць, транзакціями та засобами розподіленого зберігання. Вибір між ними залежить від вимог до надійності, продуктивності й узгодженості даних.^[44][58][59]

Термін реліз в OTP може означати не лише випуск самої платформи, а й комплект застосунків, зібраний для запуску окремого програмного продукту. Інструменти OTP визначають склад такої системи, порядок запуску, конфігурацію та оновлення компонентів. Сценарії оновлення можуть використовувати гарячу заміну коду, але складні зміни внутрішнього стану або схеми даних потребують окремої міграції.^[46][56]

Інтерактивна оболонка erl дозволяє вводити та одразу обчислювати вирази, компілювати модулі й взаємодіяти з процесами запущеного вузла. Як описано вище, окремі вирази вона обчислює через erl_eval, без створення для них BEAM-файлів. Модуль debugger та системні засоби трасування допомагають знаходити помилки. У сучасних випусках оболонка має автодоповнення та засоби роботи із записами, картами й специфікаціями типів.^[35][52][53]

Програма Observer дає графічне уявлення про процеси, використання пам'яті й параметри вузла. Трасування подій дає змогу аналізувати виклики функцій та обмін повідомленнями, однак детальне спостереження за високонавантаженою системою саме по собі може створювати додаткове навантаження.^[22]

Erlang/OTP містить засоби генерації документації, зокрема edoc, а сучасні випуски підтримують нові способи додавати документацію безпосередньо до модулів. Інструмент Dialyzer виконує статичний аналіз за принципом поступового виявлення підозрілих типових невідповідностей. Common Test забезпечує сценарії інтеграційного та системного тестування, а EUnit — модульні тести. Для профілювання використовують інструменти eprof, fprof та інші компоненти ERTS.^[49][36][22]

Крім основної документації, розвиток Erlang обговорюють через Erlang Enhancement Proposals (EEP) — пропозиції змін мови й платформи. Вони документують обговорювані рішення, проте сама наявність EEP не означає, що відповідну можливість уже реалізовано у стабільному випуску.^[60]

Erlang створювали для обладнання та серверних служб телекомунікацій, де необхідно обробляти багато незалежних запитів і відновлювати окремі частини системи без повної зупинки. Історично технологію використовували в Ericsson, а згодом її застосування розширилося на різні види мережевих служб. Для таких систем особливо важливі ізоляція процесів, диспетчеризація повідомлень і механізми нагляду OTP.^[7][6]

Erlang використовують у програмному забезпеченні з великою кількістю одночасних з'єднань. Серед відомих прикладів — RabbitMQ, брокер повідомлень із реалізацією на Erlang, та Apache CouchDB, документоорієнтована система керування базами даних. Ці продукти демонструють застосування BEAM і OTP поза телекомунікаційною галуззю; водночас конкретні властивості масштабованості й доступності залежать від їхніх власних архітектур та налаштувань.^[62][63]

Ізоляція процесів, асинхронні повідомлення, нагляд за збоями та розподілене виконання роблять Erlang зручною для певного класу триваложивучих серверних систем. Завдяки функційним засобам можна явно описувати перетворення даних і керувати окремим станом процесів без загальної змінюваної пам'яті на рівні прикладного коду.^[1][6]

Серед обмежень — необхідність уважно проєктувати протоколи повідомлень, контролювати довжину поштових скриньок та враховувати особливості збирання сміття, динамічної типізації й мережевих відмов. Не всі обчислення виграють від великої кількості ізольованих процесів: частина чисельних задач або тісно пов'язаних обчислень може потребувати спеціалізованих бібліотек чи нативного коду. Дослідження масштабованості Erlang вказують також на компроміси у великих розподілених системах та на витрати підтримання спільного стану.^[11][43][61]