Coder Legion - Recent posts tagged erlang

Getting Started with Elixir: Understanding Erlang, BEAM, and Your First Mix Project

Thu, 22 Jan 2026 23:35:11 +0000

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!

Elixir Setup Guide: Installing Erlang, Elixir, and Livebook with ASDF

Mon, 12 Jan 2026 20:42:17 +0000

Introduction

This article is part of a beginner series where I document my personal journey learning Elixir and taking my first real steps in its ecosystem.

I recently came from Node.js, where setting up a development environment is usually very simple: install Node, get npm, add some VS Code extensions, and you're ready to go.

With Elixir, the process is not hard, but I had a tough time finding a clear step-by-step guide. I ended up skipping important steps, which later caused a lot of unnecessary problems to fix.

So in this guide, I’ll walk you through how to set up your Elixir environment from scratch using ASDF.

Note: I’m using Linux Mint, but the same process applies to most Linux distributions with small adjustments.

What Is ASDF and Why Use It?

The first thing we’ll install is a small but very powerful tool called ASDF.

[ASDF][1] is a version manager that allows you to install and manage multiple versions of languages and runtimes — including Erlang and Elixir — on the same machine.

That means:

You can easily switch between versions
Projects can define their own required versions
Your global system stays clean

Grab some coffee ☕ and let’s start.

Step 1: Installing ASDF

First, go to the official website:
https://asdf-vm.com/

Click on Get Started and check the installation method for your operating system.

On Linux Mint (and Ubuntu-based distros), make sure you have curl and git installed:

sudo apt install curl git

Now clone the ASDF repository:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.9.0

Shell Integration (Very Important)

This step is critical so your terminal can recognize the asdf command.

If you use Oh My Zsh

Follow the plugin instructions from:
https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/asdf

Basically, add this line to your ~/.zshrc file:

plugins=(git asdf)

Then close and reopen your terminal.

If you use Bash

Add these two lines to your ~/.bashrc file:

. $HOME/.asdf/asdf.sh
. $HOME/.asdf/completions/asdf.bash

Restart the terminal.

Verify Installation

Run:

asdf --version

You should see something similar to:

v0.9.0-9ee24a3

Step 2: Installing the Erlang Plugin

With ASDF installed, we can now install plugins. Let’s start with Erlang.

asdf plugin-add erlang

Installing System Dependencies

Before compiling Erlang, we must install some required packages.

For Linux Mint / Ubuntu 20-based systems:

sudo apt-get -y install build-essential autoconf m4 libncurses5-dev libwxgtk3.0-gtk3-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev openjdk-11-jdk

These dependencies are listed in the official ASDF Erlang plugin repository:
https://github.com/asdf-vm/asdf-erlang

Step 3: Installing Erlang

List all available Erlang versions:

asdf list-all erlang

Install the latest stable version at the time of writing:

asdf install erlang 24.2.1

Tip: This step takes time and may look frozen. That’s normal. Be patient.

Set Erlang as Global Version

asdf global erlang 24.2.1

Test Erlang

erl

If you see the Erlang shell, everything is working.
Exit with Ctrl + C twice.

Step 4: Installing Elixir with ASDF

Now let’s install the Elixir plugin:

asdf plugin-add elixir

List available versions:

asdf list-all elixir

Since we installed Erlang OTP 24, we must install an Elixir version built for OTP 24.

At the time of writing:

asdf install elixir 1.13.3-otp-24

Set it globally:

asdf global elixir 1.13.3-otp-24

Test Elixir

Start IEx:

iex

You should see the Elixir interactive shell.

Hello World

Inside IEx:

IO.puts("Hello World")

Welcome to Elixir

Step 5: Using Livebook for Experiments and Notes

Livebook is similar to Jupyter Notebook for Python.

It allows you to:

Write executable Elixir code
Document your learning
Save notebooks as Markdown

Installing Livebook

Go to the official repository:
https://github.com/livebook-dev/livebook

Since Elixir is already installed globally, run:

mix escript.install hex livebook

Confirm installation when prompted.

Because we’re using ASDF, we must refresh shims:

asdf reshim

Start Livebook:

livebook server

Now open your browser and go to:

http://localhost:8080

Conclusion

In this article, we covered how to:

Install ASDF
Install Erlang
Install Elixir
Set up Livebook locally

This setup gives you a solid and flexible environment to start learning and building with Elixir.

In the next articles of this series, we’ll finally start writing real Elixir code.

See you in the next post ⚡