Elixir Tutorials

Elixir is a functional language that combines modern syntax, broad metaprogramming capabilities and the power of BEAM – Erlang Virtual Machine. It has a vast community which is constantly growing due to its resilient concurrency model and programmer-friendly approach. Our tutorials are focused on showcasing language capabilities and helping any newcomer gain enough knowledge to start actively utilising Elixir in their projects.

The basics of Elixir language

In this section, we’ll have a quick look at the core properties of the language: syntax, language conventions and principles. This should allow any programmer to have an overview of what kind of language Elixir is.

Syntax and conventions

The tables below show the most essential syntax in comparison to Python:

Data Types

Note: Elixir has a data type “atom” that does not have a direct equivalent in most of the programming languages. Atoms are constants whose values are also their names. They are denoted with a colon at the beginning, e.g. an_atom.

Operators

Control Flow

Functions

Functional programming principles

Functional programming is a paradigm that has a different set of core principles and rules than imperative programming or object-oriented programming. These are some of the principles that are the most relevant in Elixir:

• First-Class Functions – Functions are treated as values, i.e. they can be assigned to variables, passed as an argument or returned from another function. In Elixir this is done by the capture operator & with the following syntax: &<function_name>/<function_arity>, e.g. &add/2
• Immutability – Existing data is never modified; instead, each data transformation results in creating a new structure.
• Higher-Level Abstractions – Operations on collections are done with higher-order functions like map, filter, reduce instead of explicitly looping over them. Elixir’s pipe operator |> allows to write elegant code in this manner, e.g.: list_of_ints |> Enum.filter(&is_even/1) |> Enum.map(fn a -> a * 2 end) |> Enum.sum()
• Recursion and comprehension – There are no loops in Elixir, only recursion and comprehension. Using tail recursion can be optimized by the compiler to avoid generating big call stacks.
• Pattern matching – Match operator = is more powerful than a simple assignment. It allows to match data with the same shape to get smaller parts of a complex data structure or choose a case clause/function head to match the argument, e. g. {id, “label”, value} = {123, “label”, 4.2}.

Elixir’s ecosystem and tools

Any programming language wouldn’t be useful in developing software without a comprehensive set of build tools, runtime tools, libraries and frameworks. Elixir has a rich ecosystem both created by the community and derived from Erlang Virtual Machine.

Erlang VM called BEAM, is a powerful runtime environment that has been battle-tested for years and provides many essential foundations for developing software systems, such as a robust concurrency model, fault-tolerance mechanism, scalability and distribution, shell for development and debugging. Elang also has a set of basic abstractions for programmers called OTP to encapsulate runtime properties of a system like process creation and supervision.

Elixir also has a vast choice of libraries to choose for creating your project:

• Phoenix and Phoenix LiveView – web development
• Ecto – data mapping and language integrated queries
• Broadway – multi-stage data processing engine
• Nx, Axon, Bumblebee – tensor calculations and ML
• Livebook – interactive and collaborative notebooks

You can learn more about Elixir’s ecosystem by reading our What is Elixir? post.

Elixir language tutorial for beginners

In this section, we’ll show how to install Elixir on your machine and write your first program.

Installation guides across platforms

• MacOS – run brew install elixir
• Linux
  • Arch Linux – run pacman -S elixir
  • Debian/Ubuntu – run sudo add-apt-repository ppa:rabbitmq/rabbitmq-erlang && sudo apt update && sudo apt install elixir erlang-dev erlang-xmerl
  • Fedora – run sudo dnf --disablerepo=’*’ --enablerepo=rawhide install elixir elixir-doc erlang erlang-doc
• Windows
  • Download and run the Erlang installer.
  • Download and run the Elixir installer compatible with your Erlang version from the previous step. The installer is available in the “Assets” list for each Elixir release, e.g.. elixir-otp-27.exe.

Alternatively, you can use the asdf version manager to install both Erlang and Elixir. To check if you’ve installed Elixir successfully, run elixir --version in your terminal.

Step-by-step development process

For your first program, we’re going to use an Elixir script. The difference between a standard Elixir program and a script is that the latter is compiled in memory and executed right away in a single command. This is useful for learning and experimenting, and if you need a program to do a task and exit.

1. Create a file hello_world.exs and open it in a text editor.

2. Write this line in the file: IO.puts(“Hello World!”).

a. IO is a module from a standard library that handles IO operations.

b. puts is a function from this module that prints a string on standard output.

3. Save your file.

4. Open the terminal and go to the directory with the hello_world.exs file.

5. Run your script with the following command: elixir hello_world.exs.

Advanced Elixir programming tutorial

In this section, we’ll showcase in a nutshell two more advanced topics that make Elixir stand out among other popular programming languages: the concurrency model based on message passing and how scalable and fault-tolerant systems are built in Elixir.

Processes and message passing

There are two main approaches to concurrent computing: shared memory and message passing. The first one processes exchange information by writing data into the same memory block. To keep order in this, synchronization mechanisms such as mutexes and semaphores are used. With message passing, each process is isolated, i.e. has its memory, and the communication between processes is handled by exchanging messages. The formal mathematical model for this approach is called the Actor Model.

In Elixir, each process has its Process Identifier (referred to as PID). If you want to send a message to another process, you need to have its PID and call a send function:

send(pid, "The message")

The first argument is the receiver’s PID, and the second one is the message, which can be of any Elixir data type, even complex data structure. However, getting a message does not interrupt any task that a process is doing. Instead, there is a mailbox which stores all the messages that a process receives, and then it can explicitly fetch a single one with the receive instruction:

receive do
 msg -> IO.puts("I've received: #{msg}")
end

This code sample fetches the first message in the message queue (i.e. the one that came the earliest) and prints it on standard input. The whole operation can be visualized with the following diagram:

But how do you get a process’s PID in the first place? To create a new process, you need to call the spawn function with the function that this process will execute, and the return value is its PID. You can also call a self function to get the PID of a current process. The following example showcases how bidirectional communication can be achieved:

# Function to be executed by the new process
def multiply_by_two() do
 receive do
   {reply_to, val} -> send(reply_to, val * 2)
 end
end


# Getting PID of process A
pid_a = self()
# Creating process B
pid_b = spawn(&multiply_by_two/0)


# Sending a message to process B
send(pid_b, {pid_a, 2})
# Receiving a message from process B
receive do
 val -> IO.puts("Result: #{val}")
end

There are many topics beyond the scope of this article regarding concurrency in Elixir: monitoring other processes, linking processes, registering a process under a global name and abstractions for building processes in OTP. However, this example should give a glimpse of what the core foundation for concurrency in Elixir is.

Fault tolerance and scalability

The concurrency model presented above with lightweight processes and mechanisms to communicate and monitor each other gives the developers tools to build fault-tolerant and scalable distributed systems.

In OTP, there are also common abstractions to create so-called “supervision trees”. This allows you to decompose your system into a tree structure where errors in one part of the system do not propagate to the other part but are handled by the supervisor process of a particular branch. Most of the time, a process that generated the error is restarted with its state restored and this is transparent to other parts of the system.

Case studies: Successful Elixir projects

These are the highlights of successful Elixir projects achieved by various companies in collaboration with Erlang Solutions. Each detailed story is available in the case study in the corresponding link.

Enhancing team skills with Elixir tutorials

As the Elixir community is growing, so is the availability of learning materials. Besides our blogs and tutorials, there are online platforms for learning programming and local workshops.

Here are some of the popular platforms for learning Elixir:

If you prefer hands-on experience, then these are local options for learning Elixir:

Future-proofing your company with Elixir

Elixir is not only a language with modern syntax but also a language that keeps up with emerging trends in software development, making it an interesting choice for a tech stack. Here’s a list of a few current trends where Elixir fits:

1. Artificial Intelligence and Machine Learning Integration – The Current boom in Large Language Models (LLMs) is continuing, and the Numerical Elixir (Nx) project provides all the tooling to incorporate ML models into your systems written in Elixir.
2. Functional Programming Paradigm – Elixir is a functional language and has all the features that many imperative languages have been adopting over the past years, such as immutable data structures, pattern matching, higher-order functions, streams
3. Internet of Things – Elixir’s ability to manage thousands of concurrent processes makes it an excellent choice for IoT applications that require real-time data processing and high availability. Also, there are tools like Nerves that help to build IoT platforms in Elixir.
4. Developer Productivity – According to Stack Overflow Survey 2024, Elixir is the second most admired programming language, and the Phoenix framework is the most admired web framework. This is no surprise as they provide a smooth Developer Experience and allow programmers to focus on the most essential parts of their tasks

To conclude

Elixir is a great choice whether you’re a beginner looking for a language to learn programming, a senior developer wanting to change your tech stack to be more productive or a tech lead searching for a solution to scale up your product. With our Elixir Tutorial, we’ll bring you materials and inspiration to proceed on this journey.

If you’d like to use Elixir in your product and would like the help of our experts to introduce it into your tech stack, read more about our Elixir consulting offer.