Introduction
In the previous article, we covered how to set up the development environment to start working with Elixir.
Now it’s time to talk about the language itself and write our first real code.
If you are coming from languages like JavaScript, Ruby, or Python, some concepts may feel unfamiliar at first — and that’s totally normal.
Let’s start by understanding why we had to install both Elixir and Erlang.
Elixir vs Erlang
Erlang is a programming language created decades ago to solve problems related to telecommunication systems, such as reliability, concurrency, and fault tolerance.
It is extremely powerful, but its syntax is considered quite complex for many developers.
This is where Elixir comes in.
Elixir provides a modern and friendly syntax, while still running on top of the same runtime as Erlang.
In practice, your Elixir code is compiled to Erlang bytecode and executed by the same virtual machine.
What is BEAM?
BEAM stands for Bogdan/Björn’s Erlang Abstract Machine, named after its original creators.
It is the virtual machine responsible for running Erlang and Elixir code, similar to how the JVM runs Java and Kotlin.
BEAM is famous for:
- Lightweight processes
- Massive concurrency
- Fault-tolerant design
This is one of the main reasons Elixir is used in systems that require high availability.
Creating Your First Project with Mix
The best way to learn a programming language is by building something.
Reading documentation and watching tutorials helps, but real learning happens when you actually write code.
In Elixir, we use Mix, the built-in build tool and project manager.
Mix is responsible for:
- Creating projects
- Compiling code
- Managing dependencies
- Running tasks and tests
Let’s create a new project.
In your terminal, run:
mix new basics
You should see an output similar to:
* creating README.md
* creating .formatter.exs
* creating .gitignore
* creating mix.exs
* creating lib
* creating lib/basics.ex
* creating test
* creating test/test_helper.exs
* creating test/basics_test.exs
Now enter the project directory:
cd basics
Modules and Functions
Inside the lib directory, you will find the file basics.ex with the following content:
defmodule Basics do
end
In Elixir, almost all code lives inside modules.
A module is simply a collection of functions.
Let’s add our first function:
defmodule Basics do
def create_list do
[1, 2, 3, "little indians"]
end
end
We use def to define a function inside the Basics module.
Running the Project with IEx
To run and test our code, we use IEx (Interactive Elixir Shell).
It works like Python’s REPL or Ruby’s IRB, allowing you to run Elixir code interactively.
From the project directory, run:
iex -S mix
Now test the function:
Basics.create_list()
You should get:
[1, 2, 3, "little indians"]
Notice that the last expression is automatically returned.
This is called implicit return, which is common in functional programming.
Object-Oriented vs Functional Programming
In object-oriented languages, you usually create objects and call methods on them.
In functional programming, functions return values directly without relying on object instances.
In Elixir:
- There are no classes
- Modules are not objects
- Functions return data
A module is just a namespace for functions, nothing more.
Understanding Arity
In Elixir, functions are identified not only by their name, but also by the number of arguments they receive.
This is called arity.
Let’s create a new function:
def shuffle(list) do
end
Now recompile inside IEx:
recompile
And try calling:
Basics.shuffle()
You will see an error similar to:
function Basics.shuffle/0 is undefined. Did you mean shuffle/1?
That means the function expects one argument.
Example:
defmodule Basics do
def hello(), do: "Hello World" # hello/0
def hello(name), do: "Hello, #{name}" # hello/1
def hello(a, b), do: "#{a} and #{b}" # hello/2
end
These are considered different functions because of their arity.
Arity is written as:
function_name/number_of_arguments
It becomes very important later when working with pattern matching and function clauses.
More about functions and arity:
https://elixirschool.com/en/lessons/basics/functions/
Conclusion
In this article we covered:
- The relationship between Elixir and Erlang
- What BEAM is and why it matters
- How to create projects with Mix
- How modules and functions work
- What function arity means
In the next article, we’ll continue improving this project and exploring more Elixir features.
See you soon!
