Erlang is a functional programming language designed for building scalable and fault-tolerant systems, particularly in the domain of concurrent, distributed applications. It was originally developed by Ericsson in the late 1980s to create robust telecom systems. Erlang's unique features include its support for lightweight processes, message-passing concurrency, hot code swapping, and a strong emphasis on reliability. Today, it is widely used in industries that require high availability and distributed systems, such as telecommunications, messaging applications, and database systems.
Erlang was created in the late 1980s by Joe Armstrong, Robert Virding, and Mike Williams at Ericsson, primarily to address the needs of the telecom industry. The language was developed to facilitate the construction of large-scale, fault-tolerant systems that could manage multiple calls and connections simultaneously.
In the early 1990s, Ericsson recognized the potential of Erlang beyond telecommunications. By 1998, Erlang was released as open source, which allowed a wider community of developers to contribute to its growth. The open-source movement led to the development of the BEAM virtual machine, which executes Erlang code and has since evolved to support other languages.
Erlang is currently maintained by the Erlang/OTP team and has a dedicated community. The release cycle of Erlang has become more consistent, with regular updates and improvements focused on performance, new features, and enhanced documentation. The language has also inspired the development of Elixir, a modern programming language that runs on the Erlang VM and incorporates many of its principles while providing additional features.
Erlang is primarily a functional language, meaning functions are first-class citizens and can be passed around like variables.
double(X) -> X * 2.
Erlang’s lightweight processes enable the creation of thousands of concurrent processes without significant overhead.
spawn(fun() -> io:format("Hello from a process!~n") end).
Processes in Erlang communicate using message passing, which allows for safe communication without shared state.
Pid = spawn(fun() -> receive
{msg, Content} -> io:format("Received: ~s~n", [Content])
end end),
Pid ! {msg, "Hello!"}.
Erlang uses pattern matching, a powerful feature that allows for clear and concise code.
match(X) when X > 0 -> io:format("Positive number: ~B~n", [X]);
match(X) -> io:format("Non-positive number: ~B~n", [X]).
Erlang supports fault tolerance through its "let it crash" philosophy, allowing processes to fail and be restarted without affecting the system.
start_process() ->
spawn(fun() -> crash() end).
Erlang allows developers to change code in running systems without stopping them.
%% Old version
-module(example).
-export([hello/0]).
hello() -> io:format("Old Version~n").
%% New version
-module(example).
-export([hello/0]).
hello() -> io:format("New Version~n").
Data in Erlang is immutable, leading to fewer bugs and easier reasoning about code.
List = [1, 2, 3],
NewList = [4 | List].
Erlang has features that allow for easy distribution of processes across different nodes.
net_adm:start() ->
net_adm:ping('other_node@hostname').
Erlang supports record types for creating structured data types.
-record(person, {name, age}).
Person = #person{name="Alice", age=30}.
Erlang allows list comprehensions to generate and manipulate lists succinctly.
Squares = [X*X || X <- [1,2,3]].
Erlang is executed on the BEAM virtual machine, which is designed for running concurrent and fault-tolerant applications. BEAM optimizes performance and allows for features like hot code swapping.
There are several development environments for Erlang, with Emacs and IntelliJ IDEA (with the Erlang plugin) being among the most popular. Other noteworthy tools include Erlang-specific editors like Erlide.
To create an Erlang project, one traditionally uses the rebar3
tool, which manages dependencies and builds. For example, to create a new project, you would execute:
rebar3 new app myapp
Then, you can build the project with:
rebar3 compile
Erlang is widely used in telecom, messaging systems, and real-time applications. Notable applications include:
Erlang's primary strengths lie in its concurrency model and fault tolerance, which sets it apart from languages such as:
Translating code to and from Erlang can be complex due to its unique paradigms. Tools like erl2cpp
exist for certain translations, but there is no widespread automated tool for all languages. Manual translation may involve: