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
|
|
Elixir
|
Python
|
|
Numbers
|
4
-2
1_000_000
2.3
1.4e12
|
4
-2
1_000_000
2.3
1.4e12
|
|
Strings
|
“Hello”
“Interpolation: #{var}”
|
‘Hello’f’
Interpolation: {var}’
|
|
Booleans
|
true
false
|
True
False
|
|
Lists
|
[1, 2, 3]
|
[1, 2, 3]
|
|
Tuples
|
{“banana”, 4}
|
(‘banana’, 4)
|
|
Maps
|
%{“key” => “value”}
|
{‘key’: ‘value’}
|
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
|
|
Elixir
|
Python
|
|
Arithmetic
|
1 + 2
3.4 - 5.6
7 * 8
9.01 / 2.3
div(8, 3)
rem(8, 3)
|
1 + 2
3.4 - 5.6
7 * 8
9.01 / 2.3
8 // 3
8 % 3
|
|
Logical
|
true and false
false or true
not true
|
True and False
False or True
not True
|
|
Comparison
|
9 > 5
1.2 < 2
6 >= 6
1 <= 6.5
“Hello” == “Hello”
“Hello” != “World”
1 == 1.0
1 === 1
1 !== 1.0
|
9 > 5
1.2 < 2
6 >= 6
1 <= 6.5
‘Hello’ == ‘Hello’
‘Hello’ != ‘World’
1 == 1.0
|
|
String concatenation
|
“Hello “ <> “World!”
|
‘Hello ‘ + ‘World!’
|
|
List concatenation
|
[1, 2, 3] ++ [4, 5, 6]
|
[1, 2, 3] + [4, 5, 6]
|
|
Variable assignment
|
var = 42
|
var = 42
|
Control Flow
|
if/else
|
if condition do
“It is true”
else
“It is false”
end
|
if condition:
‘It is true’
else:
‘It is false’
|
|
case/match
|
case status do
200 -> “It is ok”
400 -> “Bad request”
_ -> “Unknown status”
end
|
match status:
case 200:
‘It is ok’
case 400:
‘Bad request’
case _:
‘Unknown status’
|
|
cond/elif
|
cond do
2 + 2 == 5 ->
“False”
2 * 2 == 5 ->
“Also false”
1 + 1 == 2 ->
“This is true”
end
|
if 2 + 2 == 5:
‘False’
elif 2 * 2 == 5:
‘Also false’
elif 1 + 1 == 2:
‘This is true’
|
|
comprehensions
|
for i <- 0..9, do: i * 2
|
[i * 2 for i in range(10)]
|
Functions
|
|
Elixir
|
Python
|
|
defining functions
|
def add(a, b) do
a + b
end
|
def add(a, b):
return a + b
|
|
calling functions
|
add(1, 2)
or
1 |> add(2)
|
add(1, 2)
|
|
anonymous functions
|
add_fn = fn a, b -> a +
b end
add_fn.(1, 2)
|
add_fn = lambda a, b:
a + b
add_fn(1, 2)
|
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.
-
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:
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.
|
Company name
|
Key benefits
|
|
Bleacher Report
|
There is a significant reduction in code complexity, a considerable decrease in development time, and significant cost savings. Additionally, time and resources are freed up to address technical debt, and there is excellent availability of coding expertise after converting the Ruby team into Elixir experts.
|
|
TV4
|
Migrated millions of subscribers from an external service to a user management application with zero downtime.Reduced server consumption and decreased infrastructure costs.
|
|
BET Software
|
Code complexity is significantly reduced, development time decreases, and costs are lower. Time and resources are freed to address technical debt, with strong coding expertise after converting the Ruby team to Elixir.
|
|
International Registries, Inc. (IRI)
|
Run highly parallel processes and eliminate system bottlenecks. A distributed data architecture ensuring system availability even during data center failures. An innovative event ingress system capable of processing up to 300,000 market changes on peak days, enabling real-time event processing and live betting.
|
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:
|
Platform
|
Description
|
Features
|
|
Learn Elixir
|
A dedicated platform for Elixir enthusiasts, offering structured courses to guide learners from basics to advanced topics.
|
Self-paced learning modules.Interactive coding challenges.Community support and forums.
|
|
Exercism
|
A free platform offering coding exercises across various programming languages, including Elixir. It provides practice problems and mentorship to help learners improve their coding skills.
|
Interactive exercises with real-world scenarios.Mentorship from experienced developers.Community discussions for collaborative learning.
|
|
Educative.io
|
An interactive learning platform that offers a course on functional programming using Elixir.
|
In-browser coding environment.Hands-on exercises and quizzes.Text-based lessons with visual aids.
|
If you prefer hands-on experience, then these are local options for learning Elixir:
|
Learning type
|
Description
|
|
Meetups are a great way to get inspired by developers in your area. You can check
meetup.com
if there is a local group of enthusiasts meeting together.
|
Conferences like
ElixirConf
,
ElixirConf EU
,
Code Beam Europe
,
Code Beam America
organise workshops with various difficulty levels.
|
|
Conference talks
|
Meetups are a great way to get inspired by developers in your area. You can check
meetup.com
if there is a local group of enthusiasts meeting together.
|
|
Local meetups
|
Meetups are a great way to get inspired by developers in your area. You can check out on
meetup.com
if there is a local group of enthusiasts meeting together.
|
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:
-
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.
-
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
-
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.
-
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.
The post
Elixir Tutorials
appeared first on
Erlang Solutions
.
chevron_right
