Elixir: A dynamic and functional language

By Code Journey Sep 15, 2025 0

Elixir is a dynamic, functional, and concurrent programming language that runs on the Erlang Virtual Machine (BEAM). It was created by José Valim in 2011, with the goal of combining the reliability and scalability of Erlang with a modern, approachable syntax. Elixir is particularly well-suited for building fault-tolerant, distributed, and real-time applications, making it popular in industries such as telecommunications, fintech, messaging platforms, and web development.

One of the defining characteristics of Elixir is its use of the actor model for concurrency. Programs can spawn thousands or even millions of lightweight processes, each isolated from one another. If one process fails, it does not crash the entire system — instead, supervisor processes monitor and restart it. This design leads to highly reliable systems that can run for years without downtime.

Elixir is also a functional language, which means:

Data is immutable.
Functions are treated as first-class citizens.
Programs are expressed through recursion and pattern matching rather than loops and mutable state.

Alongside these functional foundations, Elixir offers metaprogramming via macros, which allow developers to extend the language itself. This feature has led to the creation of powerful frameworks such as Phoenix for web applications and Nerves for embedded systems.

Getting Started: A First Taste of Elixir

You can run Elixir programs in two main ways:

Using the Interactive Elixir Shell (iex), a REPL for testing and experimenting.
Running scripts with the elixir command.

Hello World Example

hello.exs

IO.puts("Hello, Elixir!")

Run it in your terminal:

elixir hello.exs

Or use the interactive shell:

iex
iex> IO.puts("Hello, Elixir!")

Quick CLI Commands

Here are some of the most common Elixir command-line tools:

# Start the interactive shell
iex

# Run a script file
elixir file.exs

# Create a new project with Mix (Elixir’s build tool)
mix new my_app

# Compile and run tests
mix compile
mix test

# Fetch dependencies
mix deps.get

# Format your code
mix format

# Build a release for production
mix release

History and Timeline of Elixir

Elixir’s story begins in the early 2010s, when José Valim, a Brazilian software engineer and member of the Ruby on Rails core team, was searching for a language that could solve the concurrency and scalability limitations of traditional web frameworks. Although Ruby was loved for its elegant syntax, it struggled with high-performance, concurrent systems. Valim found inspiration in Erlang, a language created in the 1980s by Ericsson for building fault-tolerant telecom systems. Erlang’s runtime (BEAM) was extremely powerful, but its syntax was considered unusual and difficult for many developers.

Valim set out to create a new language that would run on the Erlang VM, offering all of Erlang’s strengths — concurrency, fault tolerance, distribution — but with a modern, extensible, and developer-friendly syntax. This project became Elixir.

Key Milestones in Elixir’s Development

2011 — The Beginning

In January 2011, José Valim started work on Elixir.
Early goals:
- Improve developer productivity with clear, modern syntax.
- Provide tooling for building scalable applications.
- Remain fully compatible with existing Erlang libraries and ecosystem.
The first public commit appeared on GitHub in early 2011.

2012 — Early Versions

By 2012, Elixir had gained enough features to be usable for experimentation.
Developers were drawn to its Ruby-like syntax, functional programming style, and integration with Erlang libraries.
This year also saw the beginnings of the Mix build tool, which quickly became essential for managing Elixir projects.

2013 — Growing Interest

Elixir’s ecosystem slowly grew as early adopters started experimenting with real projects.
Its ability to leverage Erlang’s concurrency without requiring developers to write verbose Erlang code attracted attention.
The community began forming around ElixirConf and online forums.

2014 — Elixir 1.0 Released

On September 18, 2014, Elixir v1.0 was officially released.
This was a major milestone: Elixir was declared stable and ready for production.
Companies began considering Elixir for serious applications, particularly web services and messaging systems.

2015 — The Phoenix Framework

The Phoenix web framework, built with Elixir, released its first versions in 2015.
Phoenix provided an alternative to frameworks like Ruby on Rails and Django, but with the added advantage of real-time capabilities and incredible concurrency.
With features like channels for WebSockets and LiveView for real-time UI updates, Phoenix became a major driver of Elixir’s popularity.

2016–2018 — Wider Adoption

Several well-known companies adopted Elixir during this period:
- Discord (for handling millions of concurrent connections in their chat platform).
- PepsiCo, Moz, and others used Elixir for real-time data processing.
The Elixir community grew stronger, with annual ElixirConf gatherings becoming important hubs for sharing knowledge and advancing the ecosystem.

2019 — Nx and Numerical Computing

Work began on Nx (Numerical Elixir), a library for numerical computing and machine learning.
Nx brought GPU acceleration and scientific computing capabilities to the Elixir world, expanding its use beyond web and telecom systems.

2020 — LiveView Takes Off

Phoenix LiveView allowed developers to build interactive, real-time web applications without writing JavaScript for most tasks.
This was a breakthrough for developer productivity, and it showcased Elixir’s strength in handling stateful, concurrent processes efficiently.

2021–2023 — Maturity and Growth

Elixir celebrated its 10th anniversary in 2021.
The language and ecosystem continued to mature, with stable releases every year.
Nx gained momentum, and the community expanded into new domains like data pipelines, IoT (via the Nerves framework), and AI experiments.

Today (2024–2025)

Elixir is considered a mature, production-ready language.
Its strengths in concurrency, distribution, and reliability make it a top choice for real-time systems, messaging platforms, fintech applications, and IoT devices.
The community is still relatively small compared to giants like Python or JavaScript, but it is highly active and passionate.

Summary Timeline

2011 — Project started by José Valim.
2012 — Early public releases.
2014 — Elixir 1.0 released (stable).
2015 — Phoenix framework introduced.
2016–2018 — Real-world adoption by major companies.
2019 — Nx project announced.
2020 — Phoenix LiveView revolutionized web development.
2021–2023 — 10th anniversary, maturity, wider use cases.
2024–2025 — Stable, production-ready language used globally in mission-critical systems.

Why Choose Elixir?

Main Advantages:

Scalability: Can handle millions of concurrent users.
Fault-Tolerance: If one process crashes, the system keeps running.
Functional Programming: Immutability and high reliability.
Interoperability: Full access to Erlang libraries.
Great for Web: Phoenix framework is fast and lightweight.

Real-World Use Cases:

Discord: Uses Elixir for handling millions of real-time connections.
PepsiCo, Pinterest, Bleacher Report: Use Elixir for backend systems.
WhatsApp (via Erlang base): Proof of Elixir/Erlang’s scalability.

Installing Elixir

On Linux (Ubuntu/Debian):

sudo apt-get update
sudo apt-get install -y elixir

On macOS (Homebrew):

brew install elixir

On Windows:

Download installer from: https://elixir-lang.org
Or use Chocolatey:

choco install elixir

Verify Installation:

elixir -v

First Program in Elixir

Let’s write a simple Hello World program.

IO.puts "Hello, World!"

Run it:

elixir hello.exs

Output:

Hello, World!

Interactive Elixir (IEx)

Elixir comes with IEx, an interactive shell.

Start it:

iex

Examples:

iex> 1 + 2
3

iex> String.upcase("elixir")
"ELIXIR"

iex> Enum.map([1,2,3], fn x -> x * 2 end)
[2, 4, 6]

Elixir Data Types

Elixir provides a variety of built-in data types that are the foundation of the language. Let’s go through them one by one with examples and commands.

Numbers

Elixir supports:

Integers (whole numbers)
Floats (decimal numbers)

Examples in IEx:

iex> 42
42

iex> 3.14
3.14

Elixir also supports very large integers:

iex> 9999999999999999999999999999999
9999999999999999999999999999999

Math operations:

iex> 10 + 5
15

iex> 10 - 3
7

iex> 10 * 2
20

iex> 10 / 2
5.0    # Division always returns a float

Use div and rem for integer division:

iex> div(10, 2)
5

iex> rem(10, 3)
1

Atoms

Atoms are constants where the name is the value.

iex> :ok
:ok

iex> :error
:error

They are often used to represent status codes or identifiers.

Booleans

Booleans in Elixir are just atoms:

iex> true
true

iex> false
false

Strings

Strings are UTF-8 encoded and enclosed in double quotes.

iex> "Hello"
"Hello"

iex> "Hello" <> " " <> "World"
"Hello World"

Interpolation:

iex> name = "Elixir"
iex> "Welcome to #{name}"
"Welcome to Elixir"

Lists

Lists are collections of values.

iex> [1, 2, 3]
[1, 2, 3]

Operations:

iex> [1, 2, 3] ++ [4, 5]
[1, 2, 3, 4, 5]

iex> [1, 2, 3] -- [2]
[1, 3]

Head and Tail:

iex> [head | tail] = [1, 2, 3]
iex> head
1
iex> tail
[2, 3]

Tuples

Tuples are fixed-size collections.

iex> {1, 2, 3}
{1, 2, 3}

Access element:

iex> elem({1, 2, 3}, 1)
2

Update element:

iex> put_elem({1, 2, 3}, 0, 10)
{10, 2, 3}

Maps

Maps are key-value stores.

iex> user = %{name: "Alice", age: 25}
%{age: 25, name: "Alice"}

Access values:

iex> user.name
"Alice"

iex> Map.get(user, :age)
25

Update values:

iex> %{user | age: 26}
%{age: 26, name: "Alice"}

Keywords

Keyword lists are special lists of tuples.

iex> [name: "Bob", age: 30]

[name: “Bob”, age: 30]

They are often used in function options.

Pattern Matching in Elixir

Pattern matching is not just variable assignment in Elixir, it’s a way to deconstruct data and write more expressive, concise, and powerful code.

Basic Pattern Matching

In most languages:

x = 1

means “assign value 1 to x.”
But in Elixir, = is a match operator.

iex> x = 1
1

iex> 1 = x
1

iex> 2 = x
** (MatchError) no match of right hand side value: 1

👉 Explanation: The last line fails because x = 1, but 2 = x is asking Elixir to check if 2 equals 1.

Matching with Tuples

iex> {a, b} = {1, 2}
{1, 2}

iex> a
1

iex> b
2

If the structure does not match:

iex> {a, b} = {1, 2, 3}
** (MatchError) no match of right hand side value: {1, 2, 3}

Matching with Lists

iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]

iex> head
1

iex> tail
[2, 3, 4]

This is how recursive list processing works in Elixir.

Pin Operator (^)

Sometimes, you don’t want a variable to be reassigned.
Use the pin operator (^) to force Elixir to use the existing value.

iex> x = 10
10

iex> ^x = 10
10

iex> ^x = 20
** (MatchError) no match of right hand side value: 20

Matching in Function Definitions

Pattern matching makes functions very powerful.

defmodule Math do
  def sum({a, b}) do
    a + b
  end
end

iex> Math.sum({3, 4})
7

Here the function only accepts a tuple with two values.

Matching with Case

case {1, 2, 3} do
  {1, x, 3} -> "Matched! x = #{x}"
  _ -> "No match"
end

Output:

"Matched! x = 2"

Matching with Function Clauses

defmodule Greeting do
  def hello(:morning), do: "Good Morning!"
  def hello(:evening), do: "Good Evening!"
  def hello(_), do: "Hello!"
end

iex> Greeting.hello(:morning)
"Good Morning!"

iex> Greeting.hello(:night)
"Hello!"

With Pattern Matching, Elixir eliminates complex if-else structures and makes code cleaner.

Functions in Elixir

Functions are the building blocks of Elixir programs. They are used for organizing code, reusability, and expressing logic in a functional style.

Anonymous Functions

Anonymous functions are defined using fn and end.

iex> add = fn a, b -> a + b end
#Function<...>

iex> add.(2, 3)
5

Notice that you call them with a dot (.) before parentheses.

Multiple clauses in anonymous functions:

iex> compare = fn
...>   x, y when x > y -> "#{x} is greater than #{y}"
...>   x, y when x < y -> "#{x} is less than #{y}"
...>   x, y -> "#{x} is equal to #{y}"
...> end

iex> compare.(5, 3)
"5 is greater than 3"

Named Functions (inside Modules)

Named functions are defined within modules using def.

defmodule Math do
  def square(x) do
    x * x
  end
end

iex> Math.square(4)
16

Default Arguments

Elixir supports default values for function parameters.

defmodule Greeter do
  def hello(name, lang \\ "en") do
    case lang do
      "en" -> "Hello, #{name}"
      "es" -> "Hola, #{name}"
    end
  end
end

iex> Greeter.hello("Alice")
"Hello, Alice"

iex> Greeter.hello("Alice", "es")
"Hola, Alice"

Guards in Functions

Guards add extra conditions to pattern matching.

defmodule Number do
  def check(x) when x > 0, do: "Positive"
  def check(x) when x < 0, do: "Negative"
  def check(0), do: "Zero"
end

iex> Number.check(10)
"Positive"

iex> Number.check(-5)
"Negative"

Higher-Order Functions

In Elixir, functions are first-class citizens. They can be passed as arguments.

iex> apply_fun = fn fun, val -> fun.(val) end
iex> apply_fun.(&Math.square/1, 5)
25

Pipe Operator (|>)

One of the most loved features in Elixir is the pipe operator, used for chaining functions.

Without pipe:

iex> String.downcase(String.trim("   ELIXIR   "))
"elixir"

With pipe:

iex> "   ELIXIR   "
...> |> String.trim()
...> |> String.downcase()
"elixir"

Recursion in Functions

Since Elixir is a functional language, loops are done with recursion.

defmodule Factorial do
  def calc(0), do: 1
  def calc(n), do: n * calc(n - 1)
end

iex> Factorial.calc(5)
120

Advantages of Elixir

Scalability – Built on Erlang’s BEAM VM, Elixir can handle millions of concurrent users easily.
Fault Tolerance – If a process crashes, it doesn’t affect the rest of the system. Perfect for telecom and distributed apps.
Functional Programming – Immutability and pure functions lead to more reliable, testable code.
Great Syntax – Inspired by Ruby, Elixir has clean and expressive syntax.
Rich Ecosystem – With Phoenix framework, building web apps is fast and efficient.
Concurrency Made Easy – Elixir simplifies concurrent programming using lightweight processes.
Interoperability – Can directly use Erlang libraries, giving access to decades of stable, production-tested code.
Growing Community – Backed by a strong open-source community and used by companies like Discord, Pinterest, and PepsiCo.

Disadvantages of Elixir

Smaller Community Compared to Mainstream Languages – Still much smaller than Java, Python, or JavaScript ecosystems.
Learning Curve – Functional programming and pattern matching may feel strange to developers from OOP backgrounds.
Limited Libraries for Niche Use-Cases – While the core ecosystem is strong, some specialized domains lack ready-made packages.
Hiring Challenges – Fewer Elixir developers available in the job market compared to mainstream languages.
Performance vs. Native Languages – While concurrency is excellent, raw number-crunching may be slower than C/C++ or Rust.

Conclusion

Elixir is a modern, functional, concurrent language that combines the power of Erlang with a clean, developer-friendly syntax. It excels at building highly scalable, fault-tolerant systems — the kind needed by apps like Discord or WhatsApp.

For developers looking to:

Work on real-time applications
Build distributed, resilient backends
Explore functional programming in production

Elixir is one of the best languages to learn in 2025.

It might not replace Java, Python, or JavaScript everywhere, but in the world of concurrent systems, messaging platforms, and web frameworks, Elixir truly shines.

If you want scalability + reliability + elegance, then Elixir is definitely worth your time. 🚀

Tags: