What Is Erlang?
Erlang is a general-purpose, concurrent, functional programming language and runtime system originally built by Ericsson to control telephone switches. It compiles to bytecode that runs on the BEAM virtual machine, and it was designed around three goals: massive concurrency, fault tolerance, and the ability to update running code without stopping the system. Unlike languages that bolt concurrency onto threads and locks, Erlang treats independent, message-passing processes as the fundamental unit of computation.
Cricket analogy: Like a T20 franchise fielding eleven specialists instead of one all-rounder trying to bowl, bat, and keep wicket, Erlang splits work across many small independent processes rather than one thread juggling everything.
Origins and Design Goals
Erlang was created in 1986 by Joe Armstrong, Robert Virding, and Mike Williams inside Ericsson's Computer Science Laboratory, tasked with finding a better way to program telephone exchanges that had to route millions of calls without ever going down. Existing languages couldn't cleanly express thousands of simultaneous, independent call sessions, so the team built a language where every call, connection, and subsystem could be modeled as its own isolated process that could fail and recover on its own.
Cricket analogy: Sachin Tendulkar's coaches didn't redesign cricket itself to fix his technique, they built new training drills around the existing game; Ericsson's engineers likewise built a new language around the existing problem of call routing.
Functional and Immutable
Erlang is a functional language: variables are bound once and never reassigned, data structures like tuples and lists are immutable, and functions are written as sets of clauses matched by pattern rather than branched with if statements. This immutability eliminates an entire category of bugs caused by one process mutating shared state that another process depends on, because in Erlang there is no shared, mutable memory between processes at all.
Cricket analogy: Once the third umpire confirms a run-out decision on review, that ruling is final and cannot be silently changed later, much like an Erlang variable is bound once and never reassigned.
Concurrent by Design
Every Erlang process is a lightweight, independently scheduled unit with its own memory and garbage collector, communicating with other processes exclusively through asynchronous message passing rather than shared variables or locks. A single BEAM node can run millions of these processes because each one costs only a few hundred bytes to spawn, and Erlang's 'let it crash' philosophy pairs this with supervisor processes that detect a crashed worker and restart it automatically.
Cricket analogy: An IPL franchise's fielding coach, batting coach, and bowling coach each manage their own drills independently and only report results to the head coach, similar to Erlang processes reporting via messages to a supervisor.
Where Erlang Is Used Today
Erlang moved well beyond Ericsson's original AXD301 telephone switch, which famously achieved 99.9999999% ('nine nines') uptime in production. WhatsApp ran its backend messaging infrastructure on Erlang to handle over a billion users with a remarkably small engineering team, RabbitMQ is written in Erlang and remains one of the most widely deployed message brokers, and the Elixir language builds an alternate syntax on top of the same BEAM runtime.
Cricket analogy: The way a small, tightly drilled fielding unit like New Zealand's national side can outperform bigger squads through discipline, WhatsApp's small Erlang team handled a billion users through the language's inherent efficiency.
-module(hello).
-export([greet/1]).
greet(Name) ->
io:format("Hello, ~s! Welcome to Erlang.~n", [Name]).
%% In the Erlang shell:
%% 1> c(hello).
%% {ok,hello}
%% 2> hello:greet("World").
%% Hello, World! Welcome to Erlang.
%% okThe Ericsson AXD301 ATM switch, built largely in Erlang, was measured at 99.9999999% uptime in a real deployment — often cited as 'nine nines,' meaning roughly 31 milliseconds of downtime per year. That reliability came directly from Erlang's process isolation and supervisor-based crash recovery, not from avoiding bugs entirely.
Erlang's functional, immutable, message-passing model is a genuine mental shift if you're coming from Python, Java, or JavaScript. Expect the first week of writing recursive functions and pattern-matched clauses instead of loops and mutable variables to feel unfamiliar — that discomfort is normal and fades quickly with practice.
- Erlang is a functional, concurrent language created at Ericsson in 1986 to run telephone switches reliably.
- It runs on the BEAM virtual machine, which compiles Erlang source to portable bytecode.
- Processes are lightweight, isolated, and communicate only via asynchronous message passing — never shared memory.
- The 'let it crash' philosophy pairs process isolation with supervisors that automatically restart failed workers.
- The Ericsson AXD301 switch demonstrated 99.9999999% ('nine nines') uptime using Erlang's fault-tolerance model.
- WhatsApp, RabbitMQ, and Klarna are real-world production systems built on Erlang or the BEAM VM.
- Elixir is a newer language that shares Erlang's BEAM runtime and its concurrency guarantees.
Practice what you learned
1. Who originally created Erlang, and at what company?
2. What is the name of the virtual machine that runs compiled Erlang bytecode?
3. How do Erlang processes primarily communicate with each other?
4. What uptime figure is commonly cited for the Ericsson AXD301 switch built with Erlang?
5. Which of the following is a real production system built on Erlang or the BEAM VM?
Was this page helpful?
You May Also Like
Installing Erlang
How to install Erlang/OTP on macOS, Linux, and Windows, verify the installation, and manage multiple versions.
Atoms and Terms
Understanding Erlang's atom data type and how atoms, numbers, tuples, and lists combine to form Erlang terms.
Pattern Matching in Erlang
How Erlang's = operator, function clauses, and guards use pattern matching to bind variables and control program flow.
Your First Erlang Program
Writing, compiling, and running a real Erlang module, from module declaration and exports through the shell workflow.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics