Erlang, short for Erlang Programming Language, is a concurrent, functional programming language created by Joe Armstrong, Robert Virding, and Mike Williams at Ericsson in 1986. It was designed to build fault-tolerant, distributed, and real-time systems that must run continuously without interruption. Erlang is used in telecommunications infrastructure, messaging systems, distributed databases, and high-availability servers across large-scale systems. Developers can access Erlang by downloading the official distribution from Erlang/OTP, which provides the compiler, runtime system, standard libraries, and documentation for Windows, Linux, and macOS platforms.

Erlang exists to solve a very specific and difficult problem: how to build systems that continue running even when parts of them fail. Its design philosophy treats failure as normal rather than exceptional. Instead of preventing all errors, Erlang isolates faults, supervises processes, and enables fast recovery. Simplicity of individual components, strict process isolation, and message passing form the foundation of its approach, making large distributed systems easier to reason about and maintain.

Erlang: Atoms and Basic Values

Erlang programs are built from simple immutable values such as atoms, numbers, and strings. Atoms represent named constants and are used extensively for signaling and pattern matching across systems.

language = erlang.
version = 1.
io:format("Language: ~p, Version: ~p~n", [language, version]).

Immutability ensures that data cannot be changed unexpectedly, which simplifies reasoning in concurrent environments. This model aligns closely with data-focused formats such as JSON, where values are passed rather than mutated.

Erlang: Tuples and Lists

Erlang represents structured data using tuples and lists. Tuples group fixed-size data, while lists represent ordered collections.

user = {user, "alice", 42}.
numbers = [1, 2, 3, 4, 5].

io:format("User: ~p~n", [user]).

These structures are lightweight and deeply integrated with pattern matching. Their simplicity allows efficient data exchange between processes without shared memory, a sharp contrast to mutable data structures in languages like C++.

Erlang: Pattern Matching

Erlang relies heavily on pattern matching to control program flow and destructure data. Patterns appear in assignments, function clauses, and message handling.

{user, Name, Age} = {user, "bob", 30}.
io:format("Name: ~p, Age: ~p~n", [Name, Age]).

Pattern matching replaces conditional logic with declarative structure. This approach reduces branching complexity and encourages explicit handling of all expected cases.

Erlang: Processes and Message Passing

Erlang uses lightweight processes that communicate exclusively through message passing. Each process has its own memory and cannot directly interfere with others.

Pid = spawn(fun() ->
    receive
        {hello, From} ->
            From ! {reply, world}
    end
end),

Pid ! {hello, self()},
receive
{reply, Msg} ->
io:format("Received: ~p~n", [Msg])
end.

This model eliminates shared-state concurrency bugs and enables massive parallelism. It influenced later systems such as actor-based frameworks and languages including Elixir and distributed runtimes built on the BEAM virtual machine.

Erlang: Supervision and Fault Tolerance

Erlang applications are structured using supervision trees, where supervisors monitor worker processes and restart them when failures occur.

{ok, Pid} = supervisor:start_link(my_supervisor, []).

This explicit fault-handling strategy embodies the principle of letting processes fail and recover cleanly. It allows long-running systems to remain operational for years without downtime.

Erlang is used in telecom switches, messaging platforms, distributed databases, and real-time systems that demand extreme reliability. Its influence extends beyond its own ecosystem, shaping modern concurrency models and inspiring languages such as Elixir, Scala, and fault-tolerant design patterns across distributed computing. By prioritizing isolation, supervision, and message passing, Erlang offers a distinctive and proven approach to building systems that stay alive even when everything around them goes wrong.

Compiler
Actor
VM