Skip to main content

Erlang Hello World

Erlang is a general-purpose programming language that was designed for building scalable and fault-tolerant systems. It was developed by Ericsson in the late 1980s and is known for its concurrency model, which allows for the creation of lightweight processes that can communicate with each other through message passing.

Erlang is primarily used in the telecommunications industry, where the need for high availability and fault tolerance is critical. However, it has gained popularity in other domains as well, such as web development and distributed systems.

History​

Erlang was originally designed by Joe Armstrong, Robert Virding, and Mike Williams at Ericsson in the late 1980s. It was created to address the challenges of building reliable and fault-tolerant telecom systems. The language was named after the Danish mathematician and engineer, Agner Krarup Erlang, who worked on the theory of telecommunications.

Erlang was first released as an open-source language in 1998. Since then, it has been continuously developed and improved by the open-source community. The language gained significant attention after the release of the book "Programming Erlang" by Joe Armstrong, which introduced Erlang to a wider audience.

Features​

Erlang provides several features that make it suitable for building highly concurrent and fault-tolerant systems:

  1. Concurrency: Erlang uses lightweight processes, also known as "actors," to achieve concurrency. These processes are isolated from each other and communicate through message passing. This approach allows for the creation of highly concurrent systems without the need for locks or shared memory.

  2. Fault Tolerance: Erlang has built-in mechanisms for handling errors and failures. Processes can be supervised by other processes, which monitor their state and restart them if they crash. This fault-tolerant design makes Erlang well-suited for building systems that require high availability.

  3. Hot Code Upgrades: Erlang supports hot code upgrades, which means that you can upgrade a running system without stopping it. This feature is particularly useful in systems that need to be continuously available, as it allows for seamless upgrades without any downtime.

  4. Pattern Matching: Erlang has powerful pattern matching capabilities, which make it easy to work with complex data structures. Pattern matching is used extensively in Erlang for tasks such as message handling and recursive algorithms.

Hello World Example​

Let's dive into a Hello World example in Erlang. First, make sure you have Erlang installed on your system. You can download it from the official website: erlang.org.

Once you have Erlang installed, open a terminal and start the Erlang shell by running the command erl.

To print "Hello, World!" to the console, enter the following commands in the Erlang shell:

% Define a function called hello_world that takes no arguments
hello_world() ->
    % Print the string "Hello, World!"
    io:format("Hello, World!~n").

To compile the function, run the following command:

% Compile the hello_world function
c(hello_world).

After the compilation is successful, you can call the function by running:

% Call the hello_world function
hello_world:hello_world().

You should see the output Hello, World! printed to the console.

More Examples​

Erlang Examples.

Example 1: Hello World​

-module(hello_world).
-export([hello/0]).

hello() ->
    io:format("Hello, World!~n").

Expected Output:

Hello, World!

Explanation:

  • We define a module called hello_world using the -module directive.
  • The export directive specifies the functions that can be accessed from outside the module. In this case, we export the hello/0 function.
  • The hello/0 function uses the io:format/1 function to print the message "Hello, World!" to the console.

Example 2: Basic Arithmetic​

-module(basic_arithmetic).
-export([add/2, subtract/2, multiply/2, divide/2]).

add(X, Y) ->
    X + Y.

subtract(X, Y) ->
    X - Y.

multiply(X, Y) ->
    X * Y.

divide(X, Y) when Y /= 0 ->
    X / Y;
divide(_, _) ->
    undefined.

Expected Output:

5 + 3 = 8
7 - 2 = 5
4 * 6 = 24
10 / 2 = 5.0
10 / 0 = undefined

Explanation:

  • We define a module called basic_arithmetic and export four functions: add/2, subtract/2, multiply/2, and divide/2.
  • The add/2, subtract/2, and multiply/2 functions perform basic arithmetic operations.
  • The divide/2 function checks if the divisor is not zero (Y /= 0). If it is not zero, it performs the division; otherwise, it returns undefined.

Example 3: Pattern Matching​

-module(pattern_matching).
-export([check_value/1]).

check_value(0) ->
    io:format("The value is zero.~n");
check_value(1) ->
    io:format("The value is one.~n");
check_value(_) ->
    io:format("The value is neither zero nor one.~n").

Expected Output:

The value is zero.
The value is one.
The value is neither zero nor one.

Explanation:

  • We define a module called pattern_matching and export the check_value/1 function.
  • The check_value/1 function uses pattern matching to check the value of the argument.
  • If the value is 0, it prints "The value is zero."
  • If the value is 1, it prints "The value is one."
  • If the value doesn't match either pattern, it prints "The value is neither zero nor one."

Example 4: Lists​

-module(lists_example).
-export([head_tail/1, append_lists/2, reverse_list/1]).

head_tail([H | T]) ->
    io:format("Head: ~p, Tail: ~p~n", [H, T]).

append_lists(List1, List2) ->
    List1 ++ List2.

reverse_list(List) ->
    lists:reverse(List).

Expected Output:

Head: 1, Tail: [2,3,4]
[1,2,3] ++ [4,5] = [1,2,3,4,5]
Reverse of [1,2,3,4,5] = [5,4,3,2,1]

Explanation:

  • We define a module called lists_example and export three functions: head_tail/1, append_lists/2, and reverse_list/1.
  • The head_tail/1 function uses pattern matching to separate the head and tail of a list and prints them.
  • The append_lists/2 function concatenates two lists using the ++ operator.
  • The reverse_list/1 function uses the lists:reverse/1 function to reverse a list.

Example 5: Recursion​

-module(recursion_example).
-export([factorial/1, fibonacci/1]).

factorial(0) ->
    1;
factorial(N) ->
    N * factorial(N - 1).

fibonacci(0) ->
    0;
fibonacci(1) ->
    1;
fibonacci(N) ->
    fibonacci(N - 1) + fibonacci(N - 2).

Expected Output:

Factorial of 5 = 120
Fibonacci of 6 = 8

Explanation:

  • We define a module called recursion_example and export two functions: factorial/1 and fibonacci/1.
  • The factorial/1 function calculates the factorial of a number using recursion.
  • The fibonacci/1 function calculates the Fibonacci sequence using recursion.

These are just a few simple examples to get you started with Erlang. Feel free to explore the language further and experiment with more complex programs!

Comparison with Alternatives​

Erlang is often compared to other programming languages that provide similar features for concurrency and fault tolerance, such as:

  • Go: Go is a programming language developed by Google. It also emphasizes concurrency and provides lightweight threads, called goroutines, for concurrent programming. However, Erlang's actor model and built-in fault tolerance mechanisms make it more suitable for building highly reliable and fault-tolerant systems.

  • Akka: Akka is a framework for building concurrent and distributed applications in Java or Scala. It shares some similarities with Erlang's actor model and message passing, but Erlang's design focuses more on fault tolerance and hot code upgrades, which are not as prominent in Akka.

  • Node.js: Node.js is a JavaScript runtime that uses an event-driven, non-blocking I/O model for building scalable network applications. While Node.js is popular for building high-performance web servers, it lacks the built-in fault tolerance and distributed computing capabilities of Erlang.

Conclusion​

In this tutorial, we introduced Erlang, discussed its history, highlighted its features, and provided a simple Hello World example. Erlang's unique concurrency model, fault tolerance mechanisms, and hot code upgrades make it a powerful language for building highly scalable and reliable systems.

To learn more about Erlang, you can visit the official website: erlang.org.