PROVIDER Β· the original language of telecom-grade high availability

Erlang

Erlang was designed for telecom switches where OTP standardises supervision, fault isolation, and hot upgrades, with WhatsApp and RabbitMQ proving its extreme reliability as the classic high-availability paradigm.

Programming Languages & Frameworks Sweden 2026.11.16
Programming Languages & Frameworks Sweden the original language of telecom-grade high availability
4.1pts

Pros

4 items
Telecom-grade fault tolerance with process isolation containing failures
Hot code upgrades replace logic without downtime
Native distribution with straightforward multi-node cooperation
OTP standardises supervision, restarts, and deployment patterns

Cons

4 items
Dated syntax with punctuation terminators and single assignment
Ecosystem centres on telecom, finance, and infrastructure with Elixir for web
Narrow hiring with scene-dependent learning payback
CPU-heavy work needs external services

Product Information

erlang
Category Programming Languages & Frameworks
Company Erlang
Service Region Sweden
Official Website https://www.erlang.org/
Recommendation Score 4.1 pts
Published 2026-11-16

Detailed Notes

Overview

Erlang was released by Ericsson in 1986 and open sourced in 1998 for telecom switches targeting fault tolerance, concurrency, and hot upgrades, with the OTP framework standardising process supervision, recovery, and distribution as the classic high-availability paradigm.

For Programming Languages & Frameworks work the value is extreme reliability, since WhatsApp served hundreds of millions on few servers and RabbitMQ powers message queues with it, process isolation stops failures spreading, and hot code upgrades replace logic without downtime.

Note the barrier, because dated syntax with comma and full stop terminators and single assignment is unfriendly to newcomers, functional and OTP thinking needs time, the ecosystem centres on telecom, finance, and infrastructure with web work moving to Elixir, and narrow hiring means payback only in high-reliability contexts.

Core Strengths

  • Telecom-grade fault tolerance with process isolation containing failures
  • Hot code upgrades replace logic without downtime
  • Native distribution with straightforward multi-node cooperation
  • OTP standardises supervision, restarts, and deployment patterns

Product Ecosystem

Language core

Pattern matching, single assignment, immutable data, and lightweight processes.

OTP framework

gen_server, supervisors, applications, and distributed node management.

Toolchain

rebar3 builds, Observer monitoring, and Common Test with EUnit.

Drawbacks

  • Dated syntax with punctuation terminators and single assignment
  • Ecosystem centres on telecom, finance, and infrastructure with Elixir for web
  • Narrow hiring with scene-dependent learning payback
  • CPU-heavy work needs external services

Use Cases

  • Message queues and gateways (β˜…β˜…β˜…β˜…β˜…) - Foundational like RabbitMQ
  • Telecom and finance reliability (β˜…β˜…β˜…β˜…β˜…) - Historical strength
  • Distributed fault-tolerant services (β˜…β˜…β˜…β˜…β˜…) - Mature OTP patterns
  • Web application development (β˜…β˜…) - Prefer Elixir and Phoenix

Pricing

Plan Price Scope
Erlang and OTP $0 Apache 2.0, free
Tools such as rebar3 $0 Open source and free
Commercial support Contracts Erlang Solutions and others

The language and OTP are free with cost in talent and learning, where reliability gains far exceed investment for never-down systems while ordinary business systems see little return.

FAQ

  • Can Erlang still be used directly? Yes, with infrastructure like RabbitMQ, CouchDB, and Ejabberd still built on it, while application work moves to Elixir.

  • Why is it so reliable? Isolated lightweight processes, supervision-driven restarts, and single assignment avoiding shared mutable state contain failures narrowly.

  • Erlang or Go? Erlang or Elixir for soft-realtime long-running systems with hot upgrades, and Go for general backends and cloud-native tooling.

Code Examples

Module with list comprehension

-module(idc).
-export([affordable/2]).

affordable(Plans, Max) ->
    [Name || #{name := Name, price := Price} <- Plans, Price =< Max].

Compile and run with erlc idc.erl then call it from the erl shell.

Processes and message passing

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

Lightweight processes and mailboxes underpin Erlang's fault tolerance with OTP supervising on top.

Community & Resources

Communities and official channels

Learning resources and tools

Visit Erlang Website β†’ https://www.erlang.org/
Visit Website β†—