DEV Community: Muzhawir Amri

Variable, Immutability, And Garbage Collection

Muzhawir Amri — Wed, 23 Jul 2025 18:00:00 +0000

Binding - Creating Variables
- In Imperative Languages: A Refillable Box
- In Elixir: A Sealed Box
- Type Inference
Naming Variables
- Trailing Question Mark and Exclamation Mark
Rebinding - Updating Variable Values
Memory Management in Elixir
References

Binding - Creating Variables

In Elixir, we can give a name to a value just like in most programming languages. The syntax may look familiar, but under the surface, the idea of a “variable” works quite differently from how it does in languages like Python or JavaScript.

First, let’s take a quick look at how variable assignment works in an imperative language like Python.

In Imperative Languages: A Refillable Box

Here is a typical Python example:

>>> monthly_salary = 1000

>>> monthly_salary = 1500

You can imagine monthly_salary as a box with a label. First, the box holds 1000. Then, we open the box and replace its contents with 1500.

The box itself stays the same, but the value inside it changes. This is called mutability, which means a value can be updated after it has been created. This is common in imperative languages, where programs are written as a series of steps that change the state of the system over time.

In Elixir: A Sealed Box

Now let’s see how Elixir handles the same idea:

iex> monthly_salary = 1000

This might look like the Python example at first glance, but under the hood, it behaves very differently.

Let’s use the box analogy again. In Elixir, we are creating the value 1000, putting it into a box, sealing the box shut, and attaching the label monthly_salary to it. Once the box is sealed, its contents cannot be changed.

This concept is called immutability. A value, once created, cannot be modified.

Here are a few simple expressions:

iex> monthly_salary = 1000
1000

iex> monthly_salary
1000

iex> monthly_salary * 12
12000

So far, everything is working as expected. But what if we try to “change” the value?

iex> monthly_salary = 1500

At first glance, this looks like we’re changing the value of monthly_salary. But actually, we are not.

We are not opening the original sealed box and changing what's inside. Instead, Elixir creates a new sealed box containing 1500. Then, it detaches the label monthly_salary from the old box and attaches it to the new one.

The label stays the same, but it now points to a different box. The old box still exists, but since it no longer has a label attached to it, it's considered unused.

This is a fundamental idea in functional programming: values never change. If we need a different value, we create a new one and rebind the name.

When an old value is no longer referenced by any name, Elixir will automatically clean it up. We will talk more about that in the memory management section.

Type Inference

Since Elixir is a dynamically typed language, it figures out the type of a value automatically based on what we assign to it. We do not need to specify the type manually:

name = "Alice"   # string
age = 30         # integer
height = 1.72    # float

Even though we don't write the types, Elixir keeps track of them internally and uses them correctly at runtime.

Naming Variables

In Elixir, variable names must start with a lowercase letter (a to z) or an underscore (_). After the first character, the name can contain letters, digits (0 to 9), or additional underscores. Underscores are commonly used to separate words for readability.

# Valid variable names:
valid_variable_name
also_valid_1
validButNotRecommended

Variable names that start with uppercase letters are not allowed:

# Invalid:
VariableName  # error: capital letter at the beginning

Trailing Question Mark and Exclamation Mark

Elixir allows variable names to end with a question mark (?) or an exclamation mark (!). These characters do not affect how the code runs. They are just conventions that give extra meaning to the name.

A question mark usually means the variable holds a boolean value or the result of a logical check. FOr examples: valid?, empty?, active?

An exclamation mark often means the value is guaranteed to exist, or that it came from a function that may raise an error if something goes wrong. For example, we might name a variable data! to show that it comes from File.read!/1, which will crash if the file cannot be read:

user_valid? = true
processed_data! = File.read!("config.exs")

We are not required to use these suffixes, but following these conventions makes our code easier to understand. This is especially helpful when working on large projects or with a team.

Rebinding - Updating Variable Values

As we have seen, Elixir values are immutable. This means we cannot change them once they are created. But we can rebind the same name to a new value.

iex> monthly_salary = 1000

iex> monthly_salary = 1500

We are not modifying the existing value. We are creating a new one, and then binding the name monthly_salary to this new value.

Rebinding simply updates the association between the name and a different value. The original value still exists in memory, but it is no longer connected to that name.

Here’s a full example:

iex> monthly_salary = 1000   ❶
1000

iex> monthly_salary               ❷
1000

iex> monthly_salary = 1234   ❸
1234

iex> monthly_salary               ❹
1234

Explanation:

❶ The name monthly_salary is first bound to 1000.
❷ When we check its value, it still points to 1000.
❸ We rebind the same name to 1234.
❹ Now, monthly_salary refers to the new value.

The old value (1000) is no longer in use. Elixir will eventually remove it from memory when it is no longer needed.

Memory Management in Elixir

Elixir includes a garbage collector (GC), which is part of the runtime system. Its job is to find data that is no longer being used and free the memory it occupies.

Let’s take another look at rebinding:

iex> monthly_salary = 1234

iex> monthly_salary = 2000

After the second line, the name monthly_salary now refers to 2000. The earlier value 1234 is no longer referenced by any name. At this point, Elixir considers it unused and will automatically clean it up.

This entire process happens behind the scenes. You do not need to manually allocate or release memory. The runtime handles it for you, so you can focus on writing the logic of your program without worrying about memory leaks.

References

Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.

Variabel, Imutabilitas, dan Garbage Collection

Muzhawir Amri — Wed, 16 Jul 2025 03:00:00 +0000

Daftar Isi

Binding - Membuat Variabel
- Di Bahasa Imperatif - Kotak yang Dapat Diisi Ulang
- Di Elixir - Kotak Tersegel
- Tipe Data Ditentukan Otomatis
Penamaan Variabel
- Akhiran Tanda Tanya dan Tanda Seru
Rebinding - Memperbarui Nilai Variabel
Manajemen Memori di Elixir
Referensi

Di Elixir, data bersifat tetap, setelah dibuat nilainya tidak bisa diubah. Jika kita menulis ulang sebuah variabel, Elixir tidak mengganti nilai lama, tetapi membuat nilai baru dan mengaitkan nama yang sama ke nilai tersebut. Cara kerja ini disebut immutability. Dalam pelajaran ini kita akan mempelajari bagaimana immutability diterapkan melalui binding, cara menamai variabel dengan benar, konsep rebinding, serta bagaimana garbage collector di BEAM mengelola memori agar program tetap efisien dan berjalan lancar.

Binding - Membuat Variabel

Membuat variable di Elixir sekilas tampak mirip dengan bahasa pemrograman imperatif seperti Ruby atau Python, tetapi cara Elixir memperlakukan nilai berbeda secara mendasar.

Di Bahasa Imperatif - Kotak yang Dapat Diisi Ulang

Dalam bahasa seperti Ruby, variable bersifat mutable (dapat diubah):

irb(main):001:0> monthly_salary = 5_000_000
=> 5000000

irb(main):002:0> monthly_salary = 6_000_000
=> 6000000

Kita dapat membayangkan variable monthly_salary sebagai kotak bernama.

Pertama, kotak itu diisi dengan nilai 5_000_000. Ketika nilainya diperbarui menjadi 6_000_000, isi kotak yang sama diganti. Kotaknya tetap sama, tetapi isinya berubah.

Sifat ini disebut mutable, artinya data dapat dimodifikasi setelah dibuat.

Secara teknis, variable dalam bahasa imperatif menunjuk ke lokasi memori tetap, dan nilai di lokasi tersebut dapat diganti kapan saja. Perubahan ini dianggap sebagai “pembaruan nilai”.

Di Elixir - Kotak Tersegel

Sekilas, sintaks pembuatan variable di Elixir terlihat serupa:

iex> monthly_salary = 5_000_000
5000000

Namun konsep di baliknya sangat berbeda.

Kita dapat membayangkan nilai 5_000_000 ditempatkan di dalam kotak tersegel, lalu diberi label monthly_salary. Karena kotaknya tersegel, isinya tidak dapat diubah. Sifat ini disebut immutable.

Jika kita menulis ulang monthly_salary dengan nilai baru:

iex> monthly_salary = 6_000_000
6000000

Elixir tidak membuka kotak lama dan mengganti isinya. Ia membuat kotak baru yang berisi 6_000_000, lalu memindahkan label nama monthly_salary ke kotak baru tersebut. Kotak lama tetap ada hingga sistem garbage collector menghapusnya ketika sudah tidak digunakan.

Binding di Elixir bukan hubungan antara nama dan lokasi memori yang bisa dimodifikasi, melainkan antara nama dan nilai. Nama hanyalah label yang menunjuk pada suatu nilai, bukan wadah yang menyimpannya.

Kita dapat mengamati perilaku ini langsung di IEx:

iex> monthly_salary = 5_000_000
5000000

iex> monthly_salary
5000000

iex> monthly_salary * 12
60000000

Nilai aslinya tetap sama. Ketika kita melakukan binding baru untuk monthly_salary, Elixir tidak mengubah nilai lama, melainkan membentuk asosiasi baru antara nama dan nilai yang baru.

Tipe Data Ditentukan Otomatis

Elixir adalah bahasa dinamis, artinya tipe data ditentukan otomatis berdasarkan nilai yang diberikan:

name = "Alice"   # string
age = 30         # integer
height = 1.72    # float

Kita tidak perlu menentukan tipe data secara eksplisit karena runtime Elixir mengenali tipe setiap nilai secara otomatis. Pendekatan ini membuat kode lebih ringkas dan fleksibel tanpa mengorbankan kejelasan logika.

Penamaan Variabel

Penamaan variable di Elixir mengikuti aturan sederhana namun penting untuk menjaga kejelasan kode. Nama harus diawali dengan huruf kecil (a-z) atau garis bawah (_). Setelah karakter pertama, kita dapat menambahkan huruf, angka (0-9), atau garis bawah tambahan. Garis bawah biasanya digunakan untuk memisahkan kata dalam nama variable sebagai pengganti spasi.

# Contoh nama variable valid
valid_variable_name
also_valid_1

validButNotRecommended

Huruf kapital di awal tidak diperbolehkan untuk nama variable:

# Contoh tidak valid
VariableName  # error: huruf kapital di awal

Dalam Elixir, huruf kapital di awal nama digunakan secara khusus untuk module (misalnya String, Map, List).

Perbedaan gaya ini memudahkan kita membedakan apakah suatu nama merujuk pada module atau variable hanya dengan melihatnya sekilas.

Akhiran Tanda Tanya dan Tanda Seru

Elixir mengizinkan penggunaan tanda tanya (?) dan tanda seru (!) di akhir nama variable.

Kedua tanda ini tidak memengaruhi perilaku kode secara teknis, tetapi merupakan konvensi idiomatik yang membantu pembaca memahami maksud kode dengan cepat.

Tanda tanya (?) menunjukkan bahwa nilai bersifat logis atau menghasilkan boolean. Nama seperti valid?, empty?, atau active? biasanya menandakan pertanyaan yang dapat dijawab "ya" atau "tidak".
Tanda seru (!) menandai nilai atau operasi penting, tegas, atau berpotensi berisiko. Dalam konteks variable, tanda ini sering digunakan untuk menandakan bahwa nilai tersebut sudah diverifikasi atau dijamin ada. Contohnya, important_data! dapat berarti “nilai ini pasti tersedia dan aman digunakan”.

Contoh penggunaannya:

user_valid? = true
important_data! = "Nilai ini dijamin tersedia"

Meskipun konvensi ini tidak wajib, penamaan yang konsisten membuat kode jauh lebih mudah dibaca dan dipahami, baik oleh diri sendiri maupun orang lain di masa depan.

Rebinding - Memperbarui Nilai Variabel

Semua data di Elixir bersifat immutable, artinya nilai yang sudah dibuat tidak dapat diubah. Jadi, ketika kita menulis ulang sebuah variable seperti ini:

monthly_salary = 6_000_000

yang terjadi bukan penggantian isi nilai lama, melainkan pembuatan nilai baru dan pengaitan ulang nama monthly_salary ke nilai tersebut.

Proses ini disebut rebinding.

Secara konseptual, rebinding adalah cara Elixir mempertahankan fleksibilitas tanpa melanggar prinsip immutability.

Kita tetap dapat "memperbarui" variable, tetapi yang berubah hanyalah hubungan antara nama dan nilai, bukan isi nilai itu sendiri. Nilai lama tetap ada di memori hingga garbage collector menghapusnya secara otomatis.

Contoh rebinding di IEx:

iex> monthly_salary = 5_000_000  ❶
5000000

iex> monthly_salary  ❷
5000000

iex> monthly_salary = 5_123_000  ❸
5123000

iex> monthly_salary  ❹
5123000

Penjelasannya:

❶ Nama monthly_salary pertama kali di-bind ke nilai 5_000_000.
❷ Saat diperiksa, nama tersebut mengacu pada nilai 5000000.
❸ Nama monthly_salary kemudian di-rebind ke nilai baru 5_123_000.
❹ Kini monthly_salary mengacu pada nilai baru 5123000.

Setiap kali kita melakukan rebinding, BEAM (mesin virtual yang menjalankan Elixir) tidak mengubah nilai lama di memori. Ia membuat alokasi baru untuk nilai baru dan memperbarui referensi nama ke sana. Jika tidak ada referensi yang tersisa ke nilai lama, BEAM akan menghapusnya melalui mekanisme garbage collection.

Manajemen Memori di Elixir

Elixir menggunakan garbage collector (GC) yang terintegrasi di dalam runtime BEAM untuk mengelola memori secara otomatis.

Tugas utama GC adalah mendeteksi data yang sudah tidak lagi digunakan dan membebaskan ruang memori yang ditempati data tersebut.

Kita dapat melihat peran GC ketika melakukan rebinding:

iex> monthly_salary = 5_000_000
5000000

iex> monthly_salary = 6_000_000
6000000

Setelah baris kedua dijalankan, nama monthly_salary tidak lagi mengacu pada nilai 5_000_000, melainkan pada nilai baru 6_000_000. Karena tidak ada referensi lain yang menunjuk ke nilai lama, BEAM menandainya sebagai data yang tidak dibutuhkan lagi. Garbage collector kemudian membebaskan memori yang digunakan nilai tersebut agar dapat dipakai ulang oleh sistem.

Yang membuat BEAM istimewa adalah cara kerjanya yang berbasis proses.
Setiap proses Elixir memiliki ruang memori sendiri (heap) dan garbage collector-nya sendiri. Dengan demikian, setiap proses menjalankan manajemen memorinya secara independen. Ketika satu proses melakukan garbage collection, proses lain tetap berjalan tanpa terhenti, sehingga sistem secara keseluruhan tetap responsif.

Pendekatan ini memberikan dua keuntungan utama:

Efisiensi dan prediktabilitas: setiap proses hanya mengelola memorinya sendiri, sehingga siklus garbage collection berlangsung cepat dan terukur.
Stabilitas sistem: masalah pada satu proses tidak memengaruhi proses lain, membuat sistem tetap berjalan bahkan di bawah beban tinggi.

Semua ini berlangsung otomatis di belakang layar, kita tidak perlu mengatur alokasi atau pembebasan memori secara manual seperti pada bahasa C atau C++.

Elixir dan BEAM menangani seluruh siklus hidup data secara mandiri, memungkinkan kita fokus pada logika program tanpa khawatir terhadap kebocoran memori atau pengelolaan sumber daya yang rumit.

Arsitektur per-process garbage collection inilah yang membuat sistem berbasis Elixir dapat berjalan terus-menerus selama bertahun-tahun tanpa perlu dimatikan atau restart.

Referensi

Jurić, S. (2024). Elixir in Action (3rd ed.). Manning Publications.

IEx: Elixir's Interactive Shell

Muzhawir Amri — Wed, 09 Jul 2025 18:00:00 +0000

Starting and Writing Expressions in IEx
- Starting an IEx Session and Evaluating Expressions
- Multi-line Expressions
Reading Documentation in IEx
How We Debug in IEx
Exiting the IEx Session or Viewing Other Options
References

Starting and Writing Expressions in IEx

Starting an IEx Session and Evaluating Expressions

IEx (Interactive Elixir) is Elixir’s built-in interactive shell or REPL (read–eval–print loop) that allows us to run code directly in the terminal. Through IEx, we can explore language features, read documentation, perform debugging, and more. Since it’s part of Elixir by default, we don’t need to install anything to get started.

To start a session, we simply run the iex command in the terminal:

$ iex
Erlang/OTP 26 [erts-14.0] [source] [64-bit] [smp:20:20] [ds:20:20:10]

Interactive Elixir (1.15.0) - press Ctrl+C to exit (type h() ENTER for help)

iex(1)> # This is where we type Elixir expressions.

When IEx starts, it displays the current Erlang and Elixir runtime versions. After that, the iex(1)> prompt appears, where we can enter expressions. The number in parentheses shows the evaluation count.

Let’s try our first expression:

iex(1)> 1 + 1  ❶
2            ❷

Explanation:

❶ We type the expression 1 + 1.
❷ IEx evaluates it and automatically prints the result: 2.

In Elixir, almost everything is an expression that returns a value. This includes function calls, if, case, and many more.

Multi-line Expressions

IEx also supports writing expressions across multiple lines:

iex(1)> 2 * (    ❶
...(1)>   3 + 1  ❷
...(1)> ) / 4    ❸
2.0              ❹

Explanation:

❶ We begin an expression, but it’s not yet complete due to the open parenthesis.
❷ The ...(1)> prompt appears because IEx is still waiting for us to finish the expression.
❸ Once the expression is complete, we press Enter again to evaluate it.
❹ IEx returns the result: 2.0.

As long as an expression is incomplete, IEx will continue waiting for more input. This feature is useful when we want to write longer expressions in a more readable and structured way.

Reading Documentation in IEx

IEx includes a built-in help feature that lets us read documentation directly from the shell. To start, we just type h:

iex(2)> h

                                  IEx.Helpers

Welcome to Interactive Elixir. You are currently seeing the documentation for
the module IEx.Helpers which provides many helpers to make Elixir's shell more
joyful to work with.

This message was triggered by invoking the helper h(), usually referred to as
h/0 (since it expects 0 arguments).

...... (and so on)

This displays the documentation for the IEx.Helpers module, which provides various helpers to make working with IEx easier.

If we want to view documentation for a specific function, such as IO.puts, we can use h followed by the module and function name:

iex(3)> h IO.puts

                        def puts(device \\ :stdio, item)

  @spec puts(device(), chardata() | String.Chars.t()) :: :ok

Writes item to the given device, similar to write/2, but adds a newline at the
end.

By default, the device is the standard output. It returns :ok if it succeeds.

## Examples

    IO.puts("Hello World!")
    #=> Hello World!

...... (and so on)

From this output, we can see the type spec (the data types accepted by the arguments and the return value), a brief explanation of the IO.puts function, the return value, and example usage.

How We Debug in IEx

One way we can debug in IEx is by using the dbg/1 function. This function prints the expression being evaluated along with its result, shown to the right of the #=> symbol. It helps us trace how data flows through each step.

Here’s a simple example:

iex(14)> dbg(200 + 20.22)
[iex:14: (file)]
200 + 20.22 #=> 220.22

220.22

Here, dbg prints both the expression 200 + 20.22 and its result: 220.22. The final result is still returned as usual.

Since Elixir is a functional language, we often build complex logic by chaining multiple functions together. In this context, dbg becomes especially helpful. This is particularly true when we are working with pipelines. A pipeline is Elixir’s idiomatic way to pass data through a sequence of functions using the pipe operator |>.

We will cover pipelines in more detail in a separate section. For now, we just need to understand that dbg allows us to trace the value at each stage of execution:

iex(16)> -100 |> div(4) |> abs() |> to_string() |> dbg() ❶
[iex:16: (file)]          ❷
-100 #=> -100             ❷
|> div(4) #=> -25         ❷
|> abs() #=> 25           ❷
|> to_string() #=> "25"   ❷

"25"                      ❸

Explanation:

❶ We create a simple pipeline. The initial value -100 is passed through each function in order:
- div(4) returns -25
- abs() returns 25
- to_string() returns "25"
- dbg/1 prints each stage
❷ This is the output from dbg, showing how the value is transformed at each stage in the pipeline.
❸ The final result of the expression is still returned. In this case, it is "25".

With dbg, we can inspect the execution flow in detail, without needing to insert IO.puts at every step.

Exiting the IEx Session or Viewing Other Options

The fastest way to exit an IEx session is by pressing CTRL+C twice. If we press it only once, IEx will enter BREAK mode and display a menu like the following:

$ iex
Erlang/OTP 27 [erts-15.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads
:1] [jit:ns]

Interactive Elixir (1.17.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>
BREAK: (a)bort (A)bort with dump (c)ontinue (p)roc info (i)nfo
       (l)oaded (v)ersion (k)ill (D)b-tables (d)istribution

When in BREAK mode, IEx will wait for our command. Some commonly used options include:

(a)bort: Exit the IEx session.
(A)bort with dump: Exit while generating a dump for debugging.
(c)ontinue: Resume the paused session.

To exit IEx completely, we can either:

Press CTRL+C twice in a row, or
Press a while in BREAK mode.

Since IEx is a tool we use frequently during development, understanding how to manage sessions early on helps keep our workflow smooth.

References

Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.
Elixir. (2024, December 11). IEx [Documentation]. https://hexdocs.pm/iex/IEx.html

IEx: Shell Interaktif Elixir

Muzhawir Amri — Wed, 02 Jul 2025 03:00:00 +0000

Daftar Isi

Memulai dan Menulis Ekspresi di IEx
Membaca Dokumentasi di IEx
- Melihat Dokumentasi Module
- Melihat Dokumentasi Function
Cara Debugging di IEx
- Menggunakan dbg/1 di Dalam Pipeline
Keluar dari Sesi IEx atau Menampilkan Opsi Lainnya
Referensi

Sebelum menulis program yang kompleks, kita perlu memahami cara berinteraksi langsung dengan Elixir melalui Interactive Elixir Shell atau IEx. Lingkungan ini memungkinkan kita menjalankan ekspresi, mengeksplorasi modules dan functions, membaca dokumentasi, serta melakukan debugging secara interaktif. Dengan IEx, kita dapat bereksperimen dan mengamati hasil secara langsung tanpa perlu membuat file atau proyek baru. Pada pelajaran ini, kita akan mempelajari dasar cara menggunakan IEx, mulai dari menulis ekspresi sederhana hingga memanfaatkan fitur bawaan seperti documentation lookup, pipeline inspection, dan runtime debugging.

Memulai dan Menulis Ekspresi di IEx

IEx (Interactive Elixir) adalah shell interaktif bawaan Elixir, berfungsi sebagai REPL (read-eval-print loop) yang memungkinkan kita menjalankan kode langsung dari terminal. Dengan IEx, kita dapat mengeksplorasi fitur bahasa, membaca dokumentasi, melakukan debugging, serta mencoba eksperimen kecil. Karena IEx sudah termasuk dalam distribusi Elixir, kita tidak perlu menginstal apa pun tambahan.

Untuk memulai sesi, jalankan perintah berikut di terminal:

$ iex
Erlang/OTP 26 [erts-14.0] [source] [64-bit] [smp:20:20] [ds:20:20:10]

Interactive Elixir (1.15.0) - press Ctrl+C to exit (type h() ENTER for help)

iex(1)> # Di sinilah kita mengetikkan ekspresi Elixir

Saat IEx dijalankan, ia menampilkan versi runtime Erlang dan Elixir yang digunakan. Setelah itu muncul prompt iex(1)> sebagai tempat mengetikkan ekspresi. Angka dalam tanda kurung menunjukkan urutan evaluasi ekspresi.

Contoh ekspresi sederhana:

iex(1)> 1 + 1  ❶
2  ❷

iex(2)> IO.puts("Hello World!")  ❸
Hello World!  ❹
:ok  ❺

Penjelasannya:

❶ Kita mengetikkan ekspresi 1 + 1.
❷ IEx mengevaluasinya dan menampilkan hasil 2.
❸ Kita menjalankan function IO.puts/1 untuk mencetak teks ke layar.
❹ Nilai "Hello World!" muncul di terminal sebagai hasil cetakan.
❺ Setelah menampilkan teks, IO.puts/1 mengembalikan nilai :ok, menandakan bahwa operasi berhasil tanpa kesalahan.

function IO.puts/1 adalah cara paling dasar untuk menampilkan informasi di terminal. Dalam konteks Elixir, setiap function selalu mengembalikan nilai, bahkan function yang hanya memiliki efek samping seperti mencetak teks. Hal ini memperlihatkan bahwa Elixir tetap menjaga konsistensi paradigma fungsional, yaitu setiap pernyataan adalah ekspresi yang dapat menghasilkan nilai.

Dalam Elixir, hampir semua hal adalah ekspresi (expression), artinya setiap perintah selalu menghasilkan nilai. Memanggil function, menulis if, atau menggunakan case bukan sekadar menjalankan instruksi, melainkan juga menghasilkan sesuatu yang dapat disimpan atau digunakan di bagian lain program.

IEx juga mendukung penulisan ekspresi yang terdiri dari beberapa baris, misalnya:

iex(1)> 2 * (    ❶
...(1)>   3 + 1  ❷
...(1)> ) / 4    ❸
2.0              ❹

Penjelasannya:

❶ Kita mulai menulis ekspresi, tetapi tanda kurung belum ditutup.
❷ Prompt berubah menjadi ...(1)>, menandakan bahwa ekspresi masih berlanjut.
❸ Setelah ekspresi lengkap, tekan Enter untuk mengeksekusinya.
❹ IEx mengevaluasi ekspresi dan menampilkan hasil 2.0.

Selama ekspresi belum lengkap, IEx akan tetap menunggu input tambahan. Fitur ini memudahkan kita menulis ekspresi panjang agar lebih rapi dan mudah dibaca.

Membaca Dokumentasi di IEx

IEx memiliki fitur bawaan untuk membaca dokumentasi langsung dari shell. Dengan perintah h, kita dapat menampilkan dokumentasi dari sebuah module atau function tanpa harus keluar dari terminal.

Dalam Elixir, sebuah module berfungsi sebagai wadah yang mengelompokkan sejumlah function yang memiliki keterkaitan logis. Sementara function adalah unit kode yang menerima input, memprosesnya, lalu menghasilkan output. Pembahasan lebih mendalam tentang keduanya akan kita temui di bagian selanjutnya. Untuk saat ini, cukup kita pahami bahwa perintah h dapat digunakan untuk membaca dokumentasi keduanya.

Melihat Dokumentasi Module

Untuk menampilkan dokumentasi sebuah module, gunakan h diikuti nama module-nya. Contohnya, untuk melihat dokumentasi bawaan IEx.Helpers:

iex(2)> h IEx.Helpers

                                  IEx.Helpers

Welcome to Interactive Elixir. You are currently seeing the documentation for
the module IEx.Helpers which provides many helpers to make Elixir's shell more
joyful to work with.

This message was triggered by invoking the helper h(), usually referred to as
h/0 (since it expects 0 arguments).

...... (dan seterusnya)

Hasil tersebut menampilkan dokumentasi lengkap untuk module IEx.Helpers, yang berisi kumpulan helper functions yang dapat digunakan di dalam sesi IEx. Module ini menyediakan berbagai utilitas yang memudahkan kita mengeksplorasi dan memahami fitur-fitur Elixir secara interaktif.

Melihat Dokumentasi Function

Untuk membaca dokumentasi sebuah function, tuliskan h diikuti nama module dan function-nya. Misalnya, untuk melihat dokumentasi IO.puts:

iex(3)> h IO.puts

                        def puts(device \\ :stdio, item)

  @spec puts(device(), chardata() | String.Chars.t()) :: :ok  ❶

Writes item to the given device, similar to write/2, but adds a newline at the
end.  ❷

By default, the device is the standard output. It returns :ok if it succeeds.  ❸

## Examples  ❹

    IO.puts("Hello World!")
    #=> Hello World!

...... (dan seterusnya)

Dari hasil tersebut, kita dapat mempelajari beberapa hal penting:

❶ Type spec (@spec) menjelaskan tipe data dari argumen dan nilai kembalian. Dalam contoh ini, function menerima device (seperti :stdio) dan string atau chardata.
❷ Deskripsi function menjelaskan bahwa IO.puts menulis teks ke perangkat keluaran dan menambahkan baris baru di akhir.
❸ Nilai kembalian berupa :ok menunjukkan eksekusi berhasil tanpa kesalahan.
❹ Contoh penggunaan dapat langsung dijalankan di IEx untuk memastikan perilaku function sesuai deskripsi.

Fitur h menjadikan IEx bukan sekadar alat eksperimen, tetapi juga documentation browser yang cepat dan praktis. Membaca dokumentasi langsung di IEx membantu kita memahami perilaku function dan module tanpa berpindah konteks, yang merupakan kebiasaan penting dalam ekosistem Elixir.

Cara Debugging di IEx

Salah satu cara paling efisien untuk melakukan debugging di IEx adalah dengan menggunakan function dbg/1. Function ini menampilkan ekspresi yang dievaluasi beserta hasilnya di sebelah kanan simbol #=>. Fitur ini sangat berguna untuk melacak perubahan data pada setiap tahap eksekusi, terutama ketika kita ingin memahami bagaimana suatu nilai berubah dari satu langkah ke langkah berikutnya.

Contoh sederhana:

iex(14)> dbg(200 + 20.22)
[iex:14: (file)]
200 + 20.22 #=> 220.22

220.22

Penjelasannya:

dbg/1 menampilkan ekspresi 200 + 20.22 dan hasil evaluasinya, yaitu 220.22.
Nilai akhir tetap dikembalikan, sehingga tidak mengubah alur eksekusi program.

Karena Elixir merupakan bahasa pemrograman fungsional, logika program biasanya dibangun dengan merangkai banyak function yang mengalirkan data dari satu tahap ke tahap berikutnya. Dalam konteks ini, dbg/1 menjadi function yang sangat membantu untuk memeriksa data di tengah aliran eksekusi.

Menggunakan `dbg/1` di Dalam Pipeline

Pipeline adalah mekanisme khas Elixir untuk mengalirkan data melalui serangkaian function menggunakan pipe operator |>. Pembahasan mendalam tentang pipeline akan kita temui di bagian tersendiri, tetapi untuk saat ini cukup kita pahami bahwa dbg/1 memungkinkan kita memantau nilai di setiap tahap proses tanpa menghentikan aliran data.

Contohnya, kita akan mengubah string " hello world " yang memiliki spasi di awal dan akhir menjadi bentuk yang rapi, huruf kapital semua, lalu menghitung panjangnya:

iex> "  hello world  " |> String.trim() |> String.upcase() |> String.length() |> dbg()
[iex:1: (file)]
"  hello world  " #=> "  hello world  "
|> String.trim() #=> "hello world"
|> String.upcase() #=> "HELLO WORLD"
|> String.length() #=> 11

11

Penjelasan langkah-langkahnya:

Nilai awal " hello world " dialirkan melalui beberapa function:
- String.trim() menghapus spasi di awal dan akhir.
- String.upcase() mengubah seluruh huruf menjadi kapital.
- String.length() menghitung jumlah karakter dalam string.
- dbg/1 menampilkan hasil di setiap tahap pipeline.
Output dbg/1 memperlihatkan bagaimana data berubah dari string mentah menjadi nilai numerik.
Nilai akhir 11 tetap dikembalikan sebagai hasil evaluasi ekspresi.

Dengan dbg/1, kita dapat melakukan debugging secara langsung di dalam pipeline tanpa harus memecah ekspresi menjadi beberapa baris kode terpisah. Pendekatan ini sangat sesuai dengan gaya eksplorasi interaktif yang menjadi ciri khas IEx dan filosofi Elixir yang menekankan keterbacaan serta transparansi dalam aliran data.

Keluar dari Sesi IEx atau Menampilkan Opsi Lainnya

Cara paling cepat untuk keluar dari sesi IEx adalah dengan menekan CTRL+C dua kali. Jika hanya ditekan sekali, IEx akan memasuki kondisi BREAK dan menampilkan menu opsi seperti berikut:

$ iex
Erlang/OTP 27 [erts-15.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns]

Interactive Elixir (1.17.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>
BREAK: (a)bort (A)bort with dump (c)ontinue (p)roc info (i)nfo
       (l)oaded (v)ersion (k)ill (D)b-tables (d)istribution

Ketika IEx berada dalam kondisi BREAK, sistem akan menunggu perintah dari pengguna. Kondisi ini memberi kita kendali untuk melanjutkan sesi, memeriksa status sistem, atau keluar sepenuhnya dari lingkungan interaktif.

Beberapa opsi yang paling umum digunakan antara lain:

(a)bort: Mengakhiri sesi IEx sepenuhnya.
(A)bort with dump: Mengakhiri sesi dan membuat dump file untuk keperluan debugging.
(c)ontinue: Melanjutkan sesi IEx yang sebelumnya dihentikan sementara.

Untuk benar-benar keluar dari IEx, kita dapat menggunakan salah satu dari dua cara berikut:

Menekan CTRL+C dua kali secara cepat.
Menekan a saat berada dalam kondisi BREAK.

Kedua cara tersebut akan menutup proses Interactive Elixir Shell dan mengembalikan kontrol ke terminal sistem operasi. Dalam praktik sehari-hari, menekan CTRL+C dua kali adalah cara yang paling umum digunakan karena lebih cepat dan tidak memerlukan interaksi tambahan.

Referensi

Jurić, S. (2024). Elixir in Action (3rd ed.). Manning Publications.
Elixir. (2024, December 11). IEx. [Documentation]. Retrieved from https://hexdocs.pm/iex/IEx.html

Preparing the Elixir Development Environment

Muzhawir Amri — Wed, 25 Jun 2025 18:00:00 +0000

📜 You can read the Indonesian version here!

What is the asdf version manager?
- Why Choose asdf?
Installing asdf
- Using a Package Manager
- Downloading the Precompiled Binary
- Verifying the Binary Location
- Verifying the asdf Installation
Installing Plugins in asdf
- Erlang Plugin
- Elixir Plugin
- Node.js Plugin (Optional)
Installing Runtimes in asdf
- Checking Elixir and Erlang Compatibility
- Checking Available Versions
- Installing Erlang
- Installing Elixir
- Installing Node.js (Optional)
Managing Runtime Versions in asdf
- Setting Global Versions
- Setting Local Versions
ElixirLS - Editor Extension for Elixir Development
- Key Features of ElixirLS
- Installing ElixirLS in VS Code

What is the `asdf` version manager?

Erlang and Elixir can be installed directly using the guides on the Erlang/OTP download page and the official Elixir site. However, this approach has limitations in a development context: the system can only handle one runtime version at a time. If we want to use another version, a conflict will likely occur or the system will ask us to overwrite the version that is already installed.

To overcome this, we can use a version manager, a tool that lets us install and manage multiple runtime versions side by side on a single system. This approach allows us to support various projects with different runtime versions and switch between versions as needed.

A version manager also helps maintain consistency in a development team environment, because all members can use the same version and avoid compatibility issues.

In this article, we will use a version manager called asdf‑vm, or simply asdf.

Why Choose `asdf`?

In modern software projects, we often need more than one runtime, which also means we need several version managers to handle them. For example, to develop an Elixir‑based web application, we might use kerl for Erlang, kiex for Elixir, and nvm for Node.js. If each runtime is managed with a different tool, environment management becomes complicated and adds cognitive load.

asdf simplifies this by providing a single unified interface to manage various runtimes through a plugin system. With asdf, we can install and switch between versions of Erlang, Elixir, Node.js, and dozens of other runtimes using just one tool and a consistent command pattern.

Some key advantages of asdf:

Uniform interface, We don't need to learn different workflows for each version manager.
Extensive plugin support, including official plugins for Erlang and Elixir.
Cross‑project and team consistency, via the .tool-versions file that explicitly declares the version of each runtime.

There are currently nearly 100 plugins developed by the community. Because the plugins for Erlang and Elixir are developed officially, asdf is a highly recommended choice for Elixir project development.

Installing `asdf`

To install asdf, there are two main methods: first, using a package manager, and second, by downloading the precompiled binary from GitHub. Other methods like go install or building from source are also available, but we won’t cover those here. If you want to explore other approaches, you can refer to the official documentation on this page.

Let's start with the first method.

Using a Package Manager

This is the method recommended by the asdf maintainers. Currently, three package managers are officially supported: Homebrew (macOS), Zypper (openSUSE Linux), and Pacman (Arch Linux). Here are the installation commands:

# For Homebrew (macOS)
$ brew install asdf

# For Zypper (openSUSE Linux)
$ zypper install asdf

# For Pacman (Arch Linux via AUR)
$ git clone https://aur.archlinux.org/asdf-vm.git && cd asdf-vm && makepkg -si

⚠️ The sudo command might be required depending on your system configuration.

If your operating system isn’t listed above, use the alternative method below.

Downloading the Precompiled Binary

This method requires git, so let's make sure it’s installed by running:

$ git --version

If the version appears, git is already installed. If not, we’ll need to install it using our system's package manager:

# APT (Ubuntu Linux)
$ apt install git

# DNF (Fedora Linux)
$ dnf install git

# Pacman (Arch Linux)
$ pacman -S git

# Zypper (openSUSE Linux)
$ zypper install git

# Homebrew (macOS)
$ brew install coreutils git

⚠️ The sudo command might be required depending on your system configuration.

Once git is ready, visit the asdf release page on GitHub and download the .tar.gz archive that matches our system’s architecture.

We should extract the archive into one of the directories listed in the $PATH environment variable. To see what directories are currently in $PATH, we can run:

$ echo $PATH
/home/your_username/.local/bin:/usr/local/bin:/usr/bin:/bin

This output shows the directories separated by colons (:). We can choose one of these as the extraction target:

/home/your_username/.local/bin - a user-owned directory, great for non-root installations.
/usr/local/bin - commonly used for user-installed software.
/usr/bin and /bin - best avoided, as they’re part of the system core.

The most recommended directory is /home/your_username/.local/bin because it’s safe and doesn’t require administrative privileges.

Verifying the Binary Location

After extracting, let’s make sure our shell can detect asdf by running:

$ type -a asdf
asdf is /home/your_username/.local/bin/asdf

If the command returns the binary path, then asdf is properly recognized. If not, the directory we extracted to is probably not in our $PATH.

Verifying the `asdf` Installation

Finally, let’s run:

$ asdf

If the installation is successful, this will display the version and list of asdf subcommands.

Now asdf is ready for use. Next, we’ll install plugins for Erlang, Elixir, and Node.js.

Installing Plugins in `asdf`

asdf uses a plugin system to manage various runtimes. Before installing any runtime, we need to first add the corresponding plugin.

In this guide, we’ll add three plugins:

Erlang - Since Elixir runs on the BEAM VM, Erlang is required for Elixir to work.
Elixir - The main programming language we’ll be learning throughout this series.
Node.js (optional) - Useful when managing frontend assets with the Phoenix Framework, such as JavaScript and CSS.

Erlang Plugin

The first step is to add the Erlang plugin.

But before doing that, we need to make sure that all necessary system dependencies are installed. The exact list depends on the operating system we’re using:

# APT (Ubuntu Linux 24.04)
$ apt install build-essential autoconf m4 libwxgtk3.2-dev libwxgtk-webview3.2-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev unzip

# DNF (Fedora Linux)
$ dnf install gcc g++ automake autoconf ncurses-devel wxGTK-devel wxBase openssl-devel libxslt fop unzip

# Pacman (Arch Linux)
$ pacman -S --needed base-devel ncurses glu mesa wxwidgets-gtk3 libpng libssh unixodbc libxslt fop unzip

# Zypper (openSUSE Linux)
$ zypper install make automake autoconf gcc-c++ ncurses-devel libssh-devel libopenssl-devel wxGTK3-3_2-devel fop libxml2-tools libxslt-tools unzip

# Homebrew (macOS)
$ brew install autoconf openssl@3 wxwidgets libxslt fop unzip

⚠️ The sudo command may be required depending on your system configuration.

Once all dependencies are in place, we can add the Erlang plugin by running:

$ asdf plugin add erlang

Then verify that the plugin was added successfully:

$ asdf plugin list
erlang

If erlang appears in the list, the plugin has been added successfully.

Elixir Plugin

After adding the Erlang plugin, we can proceed to add the Elixir plugin:

$ asdf plugin add elixir

Let’s verify the list of registered plugins again:

$ asdf plugin list
elixir
erlang

Now both elixir and erlang are ready to use.

Node.js Plugin (Optional)

The Node.js plugin is optional, but very useful when developing Phoenix-based web applications, especially when dealing with frontend assets.

Just like Erlang, this plugin requires a few system dependencies to be installed beforehand:

# APT (Ubuntu/Debian)
$ apt install dirmngr gnupg curl gawk

# DNF (Fedora/CentOS/RHEL)
$ dnf install dirmngr gnupg2 curl gawk

# Pacman (Arch Linux)
$ pacman -S dirmngr gnupg curl gawk

# Zypper (openSUSE)
$ zypper install dirmngr gpg2 curl gawk

# Homebrew (macOS)
$ brew install dirmngr gpg curl gawk

⚠️ The sudo command may be required depending on your system configuration.

Once the dependencies are installed, let’s add the Node.js plugin:

$ asdf plugin add nodejs

Then verify:

$ asdf plugin list
elixir
erlang
nodejs

Now all the essential plugins have been installed. In the next section, we’ll install the actual runtimes through asdf.

Installing Runtimes in `asdf`

In this section, we’ll install the runtimes required for Elixir development:

Erlang - version 27.3
Elixir - version 1.18.3-otp-27
Node.js - the latest version (at the time of writing: 23.10.0)

Since Elixir runs on the BEAM VM, we must ensure that the Elixir and Erlang versions we use are compatible.

Checking Elixir and Erlang Compatibility

Before we proceed, let’s confirm that the selected Elixir version is compatible with the Erlang version. This information can be found in the official Elixir documentation under the Compatibility and Deprecations section.

Here’s a snippet of the compatibility table:

Elixir version	Supported Erlang/OTP versions
1.18	25 – 27
1.17	25 – 27
1.16	24 – 26

Since we’re using Elixir 1.18.3, Erlang 27.3 is a compatible and currently stable choice.

Checking Available Versions

Before installing, we can list available versions using:

$ asdf list all erlang

$ asdf list all elixir

Make sure that:

Erlang 27.3 is listed in the first output.
Elixir 1.18.3-otp-27 is listed in the second.

For Node.js, we don’t need to choose a version manually since we’ll be installing the latest version.

Installing Erlang

Install Erlang 27.3:

$ asdf install erlang 27.3

This process will download the source code and compile it locally. The installation time depends on the speed of our machine.

Set Erlang as the global default:

$ asdf set --home erlang 27.3

This command writes erlang 27.3 to the .tool-versions file in our home directory, making it the default version system-wide.

Verify the installation by launching the Erlang shell:

$ erl

If successful, we should see something like this:

Installing Elixir

Install Elixir 1.18.3-otp-27:

$ asdf install elixir 1.18.3-otp-27

Since Elixir is distributed as a precompiled binary, the installation process is relatively quick.

Set Elixir as the global default:

$ asdf set --home elixir 1.18.3-otp-27

Verify the installation by launching the Elixir Interactive Shell (IEx):

$ iex

If successful, we should see something like this:

Installing Node.js (Optional)

Install the latest version of Node.js:

$ asdf install nodejs latest

Set it as the global default (replace 23.10.0 with the version that was installed):

$ asdf set --home nodejs 23.10.0

Verify the installation:

$ node

If successful, the Node.js REPL should appear, like this:

At this point, all core runtimes have been successfully installed and configured. In the next section, we’ll explore how to manage global and local versions of each runtime as needed per project.

Managing Runtime Versions in `asdf`

After installing Erlang, Elixir, and Node.js, the next step is configuring which runtime versions to use. asdf supports two configuration scopes:

Global versions - Applied system-wide
Local versions - Applied to a specific project directory

Both approaches use the .tool-versions file to store version information.

Setting Global Versions

Global versions act as the default across the entire system unless overridden by a local configuration.

In fact, when we previously ran the asdf set --home commands, we already set the global versions. But if we ever want to update or reset them, here’s how:

$ asdf set --home erlang 27.3

$ asdf set --home elixir 1.18.3-otp-27

$ asdf set --home nodejs 23.10.0

These commands will write entries into the .tool-versions file in the $HOME directory, making these runtimes globally available. The global versions are used when running commands like erl, iex, or node from any directory, unless that directory has its own local version configuration.

Setting Local Versions

Local versions are typically defined per project and stored in a .tool-versions file inside the project directory. While working within that directory (or any of its subdirectories), asdf will prioritize the local versions over the global ones.

To see how this works, let’s create a simple example project using mix:

$ mix new hello_world

$ cd hello_world

We’ll configure this hello_world project to use different Erlang and Elixir versions than our global defaults:

$ asdf set erlang 26.0

$ asdf set elixir 1.17.0-otp-26

These commands generate a .tool-versions file inside the project directory with contents like:

To install all runtime versions listed in the local .tool-versions file, run:

$ asdf install

This command downloads and installs any versions not yet available on the system:

Once the installation is complete, we can verify that the local versions are active by running:

$ erl
Erlang/OTP 26 [erts-14.0] ...

$ iex
iex(1)> System.version()
"1.17.0"

Erlang displays its version directly when the shell launches, while Elixir's version can be checked with the System.version() function inside iex.

The table below shows the difference between the global and local versions used in the hello_world project:

Global Version	Local Version (Project `hello_world`)
Erlang: 27.3	Erlang: 26.0
Elixir: 1.18.3-otp-27	Elixir: 1.17.0-otp-26

This approach allows us to manage multiple projects with different runtime requirements in a clean and isolated way.

ElixirLS - Editor Extension for Elixir Development

🤩 Official Elixir Language Server

The Elixir team is currently working on an official Elixir Language Server. You can read more in this announcement blog post.

While waiting for a stable release, we’ll use ElixirLS, a community-driven project maintained by elixir-lsp.

ElixirLS is a Language Server Protocol (LSP)-based extension that significantly improves the Elixir development experience. It provides features such as code completion, module navigation, and interactive debugging, which make development more efficient and reduce the chance of errors. This is particularly useful because Elixir is a dynamically typed language, meaning type-related issues often only appear at runtime. ElixirLS adds helpful tooling like static analysis and type annotations that can help catch potential bugs early.

Key Features of ElixirLS

Here are the main features provided by ElixirLS:

Debugger - Supports step-through debugging. You can run your program line by line, inspect variable values, and trace the logic directly from the editor. This is especially useful when trying to debug issues that aren’t obvious with just IO.inspect/1.
Dialyzer Analysis - Dialyzer is a built-in static analysis tool from Erlang that detects type mismatches and possible bugs without running the code. ElixirLS runs Dialyzer incrementally in the background, so you get faster feedback while coding without needing to trigger the full analysis manually.
@spec Suggestions - Based on Dialyzer's type inference, ElixirLS suggests type annotations (@spec) for your functions. These annotations help improve documentation and make your code easier to understand.
Inline Errors & Warnings - Compilation errors and warnings, such as unused variables or incorrect argument counts, are shown directly in the editor. This removes the need to switch back and forth with the terminal.
Hover Docs - Hovering over a function or module name displays its documentation in a tooltip, allowing you to read docs without leaving the code.
Go-to-Definition & Find References - You can right-click a function or module name and choose Go to Definition to jump to where it is defined. The Find References feature shows all places where the function is used in your project.
Code Completion & Formatter - While typing, the editor suggests functions, variables, or module names that match your input. This speeds up development and reduces typos. The built-in formatter automatically formats your code to follow the official Elixir style guide.
Symbol Lookup - Lets you search for symbols such as functions, modules, or variables within the current file, across the project workspace, or in standard Elixir and Erlang libraries.

These features make ElixirLS an essential tool for improving code quality and developer productivity, especially when working on long-term or complex Elixir projects.

Installing ElixirLS in VS Code

If you're using Visual Studio Code, follow these steps to install ElixirLS. For other editors, see the IDE Plugins section in the ElixirLS README.

Press Ctrl+Shift+X to open the Extensions sidebar.
Search for “ElixirLS”.
Select the extension called ElixirLS: Elixir support and debugger and click Install.

After installation, ElixirLS will automatically build the PLT cache the first time it runs. PLT (Persistent Lookup Table) is a database used by Dialyzer to store type information from the standard library and project dependencies. This process might take a few minutes depending on your machine, but it only needs to be done once.

At this point, we have fully set up our Elixir development environment. We’ve installed asdf, configured the appropriate runtime versions, and integrated our editor with ElixirLS.

Mempersiapkan Lingkungan Pengembangan Elixir

Muzhawir Amri — Wed, 18 Jun 2025 03:00:00 +0000

📜 You can read the English version here!

Daftar Isi

Apa itu asdf version manager?
- Mengapa Memilih asdf?
Instalasi asdf
- Menggunakan Package Manager
- Mengunduh Precompiled Binary
- Verifikasi Lokasi Binary
- Verifikasi Instalasi asdf
Instalasi Plugin di asdf
- Plugin Erlang
- Plugin Elixir
- Plugin Node.js (Opsional)
Instalasi Runtime di asdf
- Memeriksa Kompatibilitas Elixir dan Erlang
- Memeriksa Versi yang Tersedia
- Instalasi Erlang
- Instalasi Elixir
- Instalasi Node.js (Opsional)
Mengatur Versi Runtime di asdf
- Mengatur Versi Global
- Mengatur Versi Lokal
ElixirLS - Ekstensi Editor untuk Pengembangan Elixir
- Fitur Unggulan ElixirLS
- Instalasi ElixirLS di VS Code

Apa itu `asdf` version manager?

Erlang dan Elixir bisa diinstal langsung lewat panduan pada halaman unduh Erlang/OTP dan situs resmi Elixir. Namun, pendekatan ini memiliki keterbatasan dalam konteks pengembangan: sistem hanya bisa menangani satu versi runtime dalam satu waktu. Jika kita ingin menggunakan versi lain, besar kemungkinan akan terjadi konflik atau sistem meminta kita menimpa versi yang sudah terinstal.

Untuk mengatasi hal ini, kita bisa menggunakan version manager, yaitu alat yang memungkinkan kita menginstal dan mengelola banyak versi runtime secara berdampingan dalam satu sistem. Pendekatan ini memungkinkan kita mendukung berbagai proyek dengan versi runtime berbeda dan berpindah antarversi sesuai kebutuhan.

Version manager juga membantu menjaga konsistensi lingkungan pengembangan dalam satu tim, karena seluruh anggota bisa menggunakan versi yang sama dan terhindar dari masalah kompatibilitas.

Dalam tulisan ini, kita akan menggunakan version manager bernama asdf-vm, atau cukup disebut asdf.

Mengapa Memilih `asdf`?

Dalam proyek perangkat lunak modern, kita sering membutuhkan lebih dari satu runtime, yang berarti juga membutuhkan beberapa version manager untuk mengelolanya. Misalnya, untuk mengembangkan aplikasi web berbasis Elixir, kita mungkin menggunakan kerl untuk Erlang, kiex untuk Elixir, dan nvm untuk Node.js. Jika setiap runtime dikelola dengan alat yang berbeda, pengelolaan lingkungan menjadi rumit dan menambah beban kognitif.

asdf menyederhanakan ini dengan menyediakan satu antarmuka terpadu untuk mengelola berbagai runtime melalui sistem plugin. Dengan asdf, kita bisa menginstal dan beralih antarversi Erlang, Elixir, Node.js, dan puluhan runtime lainnya hanya dengan satu alat dan pola perintah yang konsisten.

Beberapa keunggulan utama asdf:

Antarmuka seragam. Kita tidak perlu mempelajari cara kerja berbeda untuk tiap version manager.
Dukungan plugin yang luas, termasuk plugin resmi (first-party) untuk Erlang dan Elixir.
Konsistensi lintas proyek dan tim, melalui file .tool-versions yang mendeklarasikan versi setiap runtime secara eksplisit.

Saat ini tersedia hampir 100 plugin yang dikembangkan oleh komunitas. Karena plugin untuk Erlang dan Elixir dikembangkan secara resmi, asdf menjadi pilihan yang sangat direkomendasikan untuk pengembangan proyek Elixir.

Instalasi `asdf`

Untuk menginstal asdf, tersedia dua metode utama: pertama, melalui package manager, dan kedua, dengan mengunduh precompiled binary dari GitHub. Metode lain seperti go install atau membangun langsung dari source code juga tersedia, tetapi tidak akan dibahas di sini. Jika ingin mengeksplorasi metode lain, silakan merujuk ke dokumentasi resmi di halaman ini.

Kita mulai dari metode pertama.

Menggunakan Package Manager

Ini adalah metode yang direkomendasikan oleh pengembang asdf. Saat ini terdapat tiga package manager yang didukung secara langsung: Homebrew (macOS), Zypper (openSUSE Linux), dan Pacman (Arch Linux). Berikut adalah perintah instalasinya:

# Untuk Homebrew (macOS)
$ brew install asdf

# Untuk Zypper (openSUSE Linux)
$ zypper install asdf

# Untuk Pacman (Arch Linux via AUR)
$ git clone https://aur.archlinux.org/asdf-vm.git && cd asdf-vm && makepkg -si

⚠️ Perintah sudo mungkin diperlukan tergantung pada konfigurasi sistem.

Jika sistem operasi yang digunakan tidak termasuk dalam daftar di atas, metode berikut bisa digunakan sebagai alternatif.

Mengunduh Precompiled Binary

Metode ini memerlukan git, jadi pastikan git sudah terinstal dengan menjalankan:

$ git --version

Jika versi git ditampilkan, artinya sudah terinstal. Jika belum, instal terlebih dahulu sesuai sistem operasi yang digunakan:

# APT (Ubuntu Linux)
$ apt install git

# DNF (Fedora Linux)
$ dnf install git

# Pacman (Arch Linux)
$ pacman -S git

# Zypper (openSUSE Linux)
$ zypper install git

# Homebrew (macOS)
$ brew install coreutils git

⚠️ Perintah sudo mungkin diperlukan tergantung pada konfigurasi sistem.

Setelah git tersedia, buka halaman rilis asdf di GitHub dan unduh arsip .tar.gz yang sesuai dengan arsitektur sistem.

Ekstrak arsip tersebut ke dalam salah satu direktori yang tercantum di dalam environment variable $PATH. Untuk melihat daftar direktori dalam $PATH, jalankan:

$ echo $PATH
/home/nama_user_kamu/.local/bin:/usr/local/bin:/usr/bin:/bin

Output di atas berisi direktori yang dipisahkan dengan tanda titik dua :. Pilih salah satu direktori berikut sebagai target ekstraksi:

/home/nama_user_kamu/.local/bin - direktori milik pengguna, cocok untuk instalasi tanpa akses root.
/usr/local/bin - umum digunakan untuk perangkat lunak tambahan.
/usr/bin dan /bin - sebaiknya dihindari karena merupakan bagian dari sistem inti.

Direktori yang paling direkomendasikan adalah /home/nama_user_kamu/.local/bin karena aman dan tidak memerlukan hak akses administratif.

Verifikasi Lokasi Binary

Setelah mengekstrak, pastikan asdf dikenali oleh shell dengan menjalankan:

$ type -a asdf
asdf is /home/nama_user_kamu/.local/bin/asdf

Jika perintah di atas menampilkan lokasi binary asdf, berarti sudah terdeteksi dengan benar. Jika tidak, kemungkinan besar direktori tempat ekstraksi belum terdaftar dalam $PATH.

Verifikasi Instalasi `asdf`

Terakhir, jalankan:

$ asdf

Jika instalasi berhasil, perintah ini akan menampilkan informasi versi dan daftar subperintah asdf.

Sekarang asdf sudah siap digunakan. Selanjutnya, kita akan menginstal plugin untuk Erlang, Elixir, dan Node.js.

Instalasi Plugin di `asdf`

asdf menggunakan sistem plugin untuk mengelola berbagai runtime. Sebelum menginstal runtime, kita perlu menambahkan plugin yang sesuai terlebih dahulu.

Dalam tulisan ini, kita akan menambahkan tiga plugin utama:

Erlang – Karena Elixir berjalan di atas BEAM VM, maka Erlang dibutuhkan agar Elixir bisa berfungsi.
Elixir – Bahasa pemrograman utama yang akan kita pelajari dalam seri ini.
Node.js (opsional) – Diperlukan saat kita mengelola aset frontend dengan Phoenix Framework, seperti JavaScript dan CSS.

Plugin Erlang

Langkah pertama adalah menambahkan plugin untuk Erlang.

Namun sebelum itu, kita perlu memastikan seluruh dependensi sistem sudah terinstal. Daftar berikut menyesuaikan dengan sistem operasi yang digunakan:

# APT (Ubuntu Linux 24.04)
$ apt install build-essential autoconf m4 libwxgtk3.2-dev libwxgtk-webview3.2-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev unzip

# DNF (Fedora Linux)
$ dnf install gcc g++ automake autoconf ncurses-devel wxGTK-devel wxBase openssl-devel libxslt fop unzip

# Pacman (Arch Linux)
$ pacman -S --needed base-devel ncurses glu mesa wxwidgets-gtk3 libpng libssh unixodbc libxslt fop unzip

# Zypper (openSUSE Linux)
$ zypper install make automake autoconf gcc-c++ ncurses-devel libssh-devel libopenssl-devel wxGTK3-3_2-devel fop libxml2-tools libxslt-tools unzip

# Homebrew (macOS)
$ brew install autoconf openssl@3 wxwidgets libxslt fop unzip

⚠️ Perintah sudo mungkin diperlukan tergantung pada konfigurasi sistem.

Setelah semua dependensi terinstal, tambahkan plugin Erlang dengan perintah:

$ asdf plugin add erlang

Lalu verifikasi bahwa plugin berhasil ditambahkan:

$ asdf plugin list
erlang

Jika erlang muncul dalam daftar, berarti plugin telah berhasil ditambahkan.

Plugin Elixir

Setelah plugin Erlang ditambahkan, kita bisa lanjut menambahkan plugin Elixir:

$ asdf plugin add elixir

Verifikasi kembali daftar plugin yang sudah terdaftar:

$ asdf plugin list
elixir
erlang

Dengan begitu, elixir dan erlang kini siap digunakan.

Plugin Node.js (Opsional)

Plugin untuk Node.js bersifat opsional, tetapi sangat berguna dalam pengembangan aplikasi web menggunakan Phoenix, terutama ketika berurusan dengan aset frontend.

Seperti Erlang, plugin ini juga memerlukan beberapa dependensi awal:

# APT (Ubuntu/Debian)
$ apt install dirmngr gnupg curl gawk

# DNF (Fedora/CentOS/RHEL)
$ dnf install dirmngr gnupg2 curl gawk

# Pacman (Arch Linux)
$ pacman -S dirmngr gnupg curl gawk

# Zypper (openSUSE)
$ zypper install dirmngr gpg2 curl gawk

# Homebrew (macOS)
$ brew install dirmngr gpg curl gawk

⚠️ Perintah sudo mungkin diperlukan tergantung pada konfigurasi sistem.

Setelah semua dependensi terinstal, tambahkan plugin Node.js:

$ asdf plugin add nodejs

Lalu verifikasi:

$ asdf plugin list
elixir
erlang
nodejs

Kini semua plugin utama sudah terinstal. Tahap berikutnya adalah menginstal masing-masing runtime melalui asdf.

Instalasi Runtime di `asdf`

Pada bagian ini, kita akan menginstal runtime utama yang dibutuhkan untuk pengembangan dengan Elixir, yaitu:

Erlang - versi 27.3
Elixir - versi 1.18.3-otp-27
Node.js - versi terbaru (saat tulisan ini dibuat: 23.10.0)

Karena Elixir berjalan di atas BEAM VM, kita perlu memastikan versi Elixir dan Erlang yang digunakan saling kompatibel.

Memeriksa Kompatibilitas Elixir dan Erlang

Sebelum memulai instalasi, pastikan versi Elixir yang dipilih kompatibel dengan versi Erlang. Informasi ini tersedia di dokumentasi resmi Elixir pada bagian Compatibility and Deprecations.

Berikut cuplikan tabel kompatibilitasnya:

Elixir version	Supported Erlang/OTP versions
1.18	25 – 27
1.17	25 – 27
1.16	24 – 26

Karena kita akan menggunakan Elixir 1.18.3, maka Erlang 27.3 adalah versi yang kompatibel dan juga merupakan versi stabil terbaru saat ini.

Memeriksa Versi yang Tersedia

Sebelum menginstal, kita bisa memeriksa versi-versi yang tersedia dengan:

$ asdf list all erlang

$ asdf list all elixir

Pastikan:

Erlang 27.3 tersedia di daftar pertama.
Elixir 1.18.3-otp-27 tersedia di daftar kedua.

Untuk Node.js, kita tidak perlu memilih versi secara manual karena akan langsung menginstal versi terbaru.

Instalasi Erlang

Instal Erlang 27.3:

$ asdf install erlang 27.3

Proses ini akan mengunduh source code dan mengkompilasinya secara lokal. Waktu instalasi tergantung pada kecepatan mesin.

Set versi global Erlang:

$ asdf set --home erlang 27.3

Perintah ini akan menulis erlang 27.3 ke dalam file .tool-versions di direktori home, sehingga versi ini digunakan secara default di seluruh sistem.

Verifikasi instalasi dengan membuka Erlang shell:

$ erl

Jika berhasil, akan muncul seperti ini:

Instalasi Elixir

Instal Elixir 1.18.3-otp-27:

$ asdf install elixir 1.18.3-otp-27

Karena Elixir tersedia dalam bentuk precompiled binary, proses instalasinya relatif cepat.

Set versi global Elixir:

$ asdf set --home elixir 1.18.3-otp-27

Verifikasi dengan membuka Elixir Interactive Shell (IEx):

$ iex

Jika berhasil, akan muncul seperti ini:

Instalasi Node.js (Opsional)

Instal versi terbaru dari Node.js:

$ asdf install nodejs latest

Set versi global (gantilah 23.10.0 sesuai versi yang terinstal):

$ asdf set --home nodejs 23.10.0

Verifikasi instalasi:

$ node

Jika berhasil, akan muncul tampilan Node.js REPL seperti berikut:

Dengan langkah ini, semua runtime utama sudah berhasil diinstal dan dikonfigurasi. Di bagian selanjutnya, kita akan membahas bagaimana mengelola versi runtime secara global dan lokal sesuai kebutuhan proyek.

Mengatur Versi Runtime di `asdf`

Setelah menginstal Erlang, Elixir, dan Node.js, langkah selanjutnya adalah mengatur versi runtime yang akan digunakan. asdf mendukung dua skema pengaturan:

Versi global – Berlaku di seluruh sistem.
Versi lokal – Berlaku khusus di dalam direktori proyek.

Kedua pendekatan ini menggunakan file .tool-versions untuk menyimpan informasi versi.

Mengatur Versi Global

Versi global digunakan sebagai default di seluruh sistem, kecuali jika direktori tempat kita berada memiliki konfigurasi lokal.

Sebenarnya, saat sebelumnya kita menjalankan perintah asdf set --home, kita sudah mengatur versi global. Namun, jika ingin mengubah atau mengatur ulangnya, berikut contohnya:

$ asdf set --home erlang 27.3

$ asdf set --home elixir 1.18.3-otp-27

$ asdf set --home nodejs 23.10.0

Perintah-perintah ini akan menuliskan entri ke dalam file .tool-versions di direktori $HOME, sehingga runtime ini berlaku secara global. Versi global ini akan digunakan saat kita menjalankan perintah seperti erl, iex, atau node dari direktori mana pun, kecuali jika direktori tersebut memiliki versi lokalnya sendiri.

Mengatur Versi Lokal

Versi lokal biasanya diterapkan di direktori proyek dan disimpan dalam file .tool-versions. Selama kita berada di dalam direktori proyek (atau subdirektorinya), asdf akan memprioritaskan versi lokal dibanding versi global.

Untuk memahami cara kerjanya, mari kita buat contoh proyek sederhana menggunakan mix:

$ mix new hello_world
$ cd hello_world

Kita ingin agar proyek hello_world menggunakan versi Erlang dan Elixir yang berbeda dari versi global, misalnya:

$ asdf set erlang 26.0
$ asdf set elixir 1.17.0-otp-26

Perintah ini akan menghasilkan file .tool-versions di dalam direktori proyek dengan isi seperti berikut:

Untuk menginstal semua versi runtime yang tercantum dalam file .tool-versions lokal, jalankan perintah berikut:

$ asdf install

Perintah ini akan mengunduh dan menginstal versi-versi yang belum tersedia di sistem:

Setelah instalasi selesai, kita bisa memastikan bahwa versi lokal sudah aktif dengan menjalankan perintah berikut:

$ erl
Erlang/OTP 26 [erts-14.0] ...

$ iex
iex(1)> System.version()
"1.17.0"

Versi Erlang ditampilkan langsung saat shell terbuka, sedangkan versi Elixir dapat dicek dengan memanggil function System.version() di dalam iex.

Tabel berikut menunjukkan perbedaan antara versi global dan versi lokal yang digunakan di proyek hello_world:

Versi Global	Versi Lokal (Proyek `hello_world`)
Erlang: 27.3	Erlang: 26.0
Elixir: 1.18.3-otp-27	Elixir: 1.17.0-otp-26

Dengan cara ini, kita bisa mengelola banyak proyek dengan kebutuhan versi runtime yang berbeda-beda secara bersih dan terisolasi.

ElixirLS - Ekstensi Editor untuk Pengembangan Elixir

🤩 Elixir Language Server Resmi

Tim pengembang Elixir sedang mengembangkan official Elixir Language Server. Detailnya bisa dibaca di pengumuman blog ini.

Sambil menunggu rilis stabilnya, kita akan menggunakan ElixirLS, yaitu proyek komunitas dari elixir-lsp.

ElixirLS adalah ekstensi editor berbasis Language Server Protocol (LSP) yang membantu proses penulisan kode Elixir. Fitur-fitur seperti code completion, navigasi antar module, hingga debugging interaktif membuat proses pengembangan menjadi lebih efisien dan minim kesalahan, terutama karena Elixir adalah bahasa dengan dynamic typing, sehingga kesalahan tipe baru terlihat saat runtime. ElixirLS menambahkan lapisan bantuan seperti analisis statis dan anotasi tipe untuk mengurangi potensi bug sejak dini.

Fitur ElixirLS

Berikut fitur-fitur utama ElixirLS:

Debugger - mendukung step-through debugging, kita bisa menjalankan program baris demi baris, melihat isi variabel, dan menelusuri alur logika secara langsung dari editor. Ini sangat berguna saat mencari bug yang tidak mudah dilihat hanya dengan function IO.inspect/1.
Dialyzer Analysis - Dialyzer adalah alat analisis statis bawaan Erlang yang mendeteksi ketidaksesuaian tipe dan potensi bug tanpa menjalankan kode. ElixirLS menjalankan analisis ini secara otomatis dan bertahap (incremental), sehingga kita mendapat umpan balik cepat saat menulis kode tanpa harus menjalankan seluruh analisis manual.
@spec Suggestions - berdasarkan hasil inferensi dari Dialyzer, ElixirLS akan menyarankan anotasi tipe (@spec) untuk function-function yang kita tulis. Ini membantu dokumentasi dan meningkatkan kejelasan kode.
Inline Errors & Warnings - kesalahan kompilasi dan peringatan seperti variabel tidak terpakai atau argumen salah langsung ditampilkan di dalam editor, tanpa harus bolak-balik ke terminal.
Hover Docs - saat kursor diarahkan ke nama function atau module, dokumentasi singkatnya akan muncul sebagai tooltip.
Go-to-Definition & Find References - klik kanan pada nama function atau module dan pilih Go to Definition untuk langsung melompat ke tempat function tersebut didefinisikan. Sebaliknya, Find References akan menunjukkan di mana saja function tersebut dipanggil di dalam proyek.
Code Completion & Formatter - saat mengetik, editor akan menyarankan nama function, variabel, atau module yang cocok. Ini mempercepat penulisan dan mengurangi typo. Sementara formatter akan memformat kode kita secara otomatis mengikuti gaya penulisan resmi komunitas Elixir.
Symbol Lookup - memungkinkan pencarian simbol seperti function, module, atau variabel di file aktif, seluruh proyek (workspace), maupun pustaka standar Elixir/Erlang.

Dengan semua fitur ini, ElixirLS menjadi alat penting untuk meningkatkan kualitas dan kenyamanan kerja saat menulis kode Elixir, terutama untuk proyek-proyek jangka panjang dan kompleks.

Instalasi ElixirLS di VS Code

Untuk pengguna VS Code, berikut langkah-langkah instalasinya. Jika kamu menggunakan editor lain, lihat daftar plugin yang tersedia di bagian IDE Plugins pada README ElixirLS.

Tekan Ctrl+Shift+X untuk membuka Extensions.
Ketik “ElixirLS” pada kolom pencarian.
Pilih ekstensi dengan nama ElixirLS: Elixir support and debugger, lalu klik Install.

Setelah instalasi selesai, ElixirLS akan secara otomatis membangun PLT cache saat pertama kali digunakan. PLT (Persistent Lookup Table) adalah basis data yang digunakan Dialyzer untuk menyimpan informasi tipe dari pustaka standar dan dependensi proyek. Proses ini bisa memakan waktu beberapa menit tergantung spesifikasi mesin, tapi hanya perlu dilakukan sekali.

Dengan ini, kita telah menyelesaikan seluruh tahapan setup lingkungan pengembangan Elixir: mulai dari instalasi asdf, pengelolaan versi runtime, hingga integrasi editor menggunakan ElixirLS.

Getting to Know Elixir Programming Language

Muzhawir Amri — Wed, 11 Jun 2025 18:00:00 +0000

📜 You can read the Indonesian version here!

Elixir Language
Improvements Brought by Elixir
Elixir’s Drawbacks
- Performance: Not for Raw Speed
- Ecosystem: Still Smaller Than Popular Languages
Learning Resources for Elixir
References

Elixir Language

If Erlang is already very capable, why do we still need to learn Elixir?

The answer lies in the improvements Elixir brings to the developer experience and overall productivity.

Elixir is a functional programming language designed to help us write cleaner, more concise, and more expressive code on the BEAM virtual machine. With its modern syntax and a design focused on developer comfort, Elixir makes it easier for us to read, maintain, and develop applications.

Elixir code is compiled into bytecode that runs on the BEAM virtual machine, just like Erlang. Since it’s built on the same foundation, Elixir is fully compatible with the existing ecosystem. We can use Erlang libraries directly in Elixir projects, and vice versa. This is very helpful when the library we need doesn’t yet exist in Elixir, allowing us to use mature solutions without having to rewrite them from scratch.

But Elixir is not just about compatibility. It simplifies many aspects of writing Erlang code. Elixir reduces repetitive code and offers modern tools such as:

Mix for project management, testing, and compilation
Hex as the official package manager for the Elixir ecosystem
Built-in documentation, automated testing, and debugging utilities that support modern development workflows

With all these advantages, Elixir brings the power and reliability of Erlang in a more developer-friendly form, including for beginners like us who are just getting started with the ecosystem. This makes Elixir an attractive option for anyone who wants to build large-scale, fault-tolerant systems on top of the BEAM.

Just like Erlang, Elixir is an actively developed open-source project. It was created by José Valim, and its source code is available in the elixir-lang/elixir GitHub repository.

Improvements Brought by Elixir

One of Elixir’s biggest strengths is its ability to significantly reduce boilerplate and syntactic noise. Code written in Elixir tends to be simpler, more expressive, and easier to maintain.

In Erlang, boilerplate is often unavoidable due to syntax limitations. Elixir solves this by introducing various forms of syntactic sugar and modern writing styles that make the code more pleasant to read and write.

Even though both Erlang and Elixir are functional languages focused on data transformation through functions, the way we structure program flow in Elixir feels much more natural. One of the most noticeable differences lies in how we chain function calls. In Erlang, data is usually processed in a nested manner from the inside out, a style often called "staircasing." When many functions are used in sequence, the code becomes hard to read, especially for beginners.

Elixir simplifies this pattern by introducing the pipe operator (|>). This operator allows us to write data flow from left to right, or top to bottom, following the actual order of execution. The result is more readable code that flows logically.

Here’s a comparison:

Erlang (staircasing):

Result = process3(process2(process1(Input))).

Elixir (pipe operator):

input
|> process1()
|> process2()
|> process3()

In addition to the pipe operator, Elixir brings many other improvements that enhance the development experience as a whole. Features like built-in documentation, an interactive REPL, and complete development tools are available out of the box.

For example, documentation can be written directly in the source code using @moduledoc and @doc annotations. This documentation is treated as a first-class part of the code. It can be accessed from IEx, converted into HTML or EPUB using ExDoc, and even executed as part of tests using the doctest feature.

For daily development, Elixir provides Mix, a unified tool for managing projects, dependencies, compilation, testing, and other common tasks. Mix integrates directly with Hex (https://hex.pm), the official package manager in the BEAM ecosystem, making it easy to use and share libraries with the community.

In short, Elixir brings the power and reliability of Erlang into a development experience that is more modern and enjoyable. With all these features, Elixir helps us write efficient, well-structured, and well-documented code from day one.

Elixir’s Drawbacks

No technology is perfect, and that includes Elixir and Erlang. It’s important to understand their weaknesses and limitations so we can decide whether Elixir fits the needs of the project we’re building.

Performance: Not for Raw Speed

One of Elixir’s key limitations is execution speed. Since it runs on the BEAM virtual machine, Elixir cannot match the raw performance of languages like C, C++, or Rust that are compiled directly to machine code. If your application is CPU-bound, such as for image processing, machine learning, or video encoding, Elixir may not be the ideal choice.

However, this is not a design flaw. It’s a deliberate architectural decision. BEAM is not built to be the fastest in terms of raw throughput or requests per second like Rust. Its focus is to stay stable under heavy load, provide fault tolerance, and handle massive concurrency efficiently.

If part of your application needs high performance, you can write that part in another language like C or Rust, then integrate it using NIF (Native Implemented Function). This lets you get performance benefits without leaving the BEAM ecosystem entirely.

Ecosystem: Still Smaller Than Popular Languages

The Elixir ecosystem is still relatively small compared to other popular languages. For comparison:

Hex, the official package manager for Elixir and Erlang, offers around 20,000 libraries
Packagist for PHP has over 400,000 libraries
NPM for JavaScript and TypeScript has over 3 million packages

This means that during development, we may encounter situations where the library we need hasn’t been built yet. This can slow us down, especially if we’re used to working in ecosystems that provide packages for almost every use case.

Aside from Elixir libraries, we can also use libraries from Erlang or other BEAM languages like Gleam. All of them are interoperable and complement each other well.

Positive Trend: Community and Interest Keep Growing

Even though Elixir’s ecosystem isn’t as large as JavaScript or Python, interest in Elixir is growing steadily. In the Stack Overflow Developer Survey 2024, Elixir ranked second among the most desired languages after Rust. Phoenix, Elixir’s main web framework, even ranked first in the web frameworks and technologies category.

This shows that more developers are exploring Elixir, and many are likely to contribute to the growth of its ecosystem. The Elixir community is also known for being friendly and welcoming to newcomers, which is a big help when learning or migrating from another language.

Learning Resources for Elixir

The main source for learning Elixir is its official documentation, especially the Getting Started section. There, we can learn the fundamentals of Elixir, from syntax and data structures to core concepts.

In addition to the documentation, the book Elixir in Action (3rd edition) by Saša Jurić is also highly recommended. The book is divided into three main sections: the language fundamentals, concurrent programming on the BEAM, and real-world production use. This makes it a complete guide for anyone looking to understand Elixir deeply.

For those who prefer learning visually, several video-based resources are available. The ElixirCasts series and Elixir Mentor YouTube channel offer short and focused videos that explain Elixir topics clearly and directly. This format is great for quickly strengthening practical understanding.

With all these learning paths, we can choose whichever suits us best, whether that’s documentation, books, or video tutorials.

References

Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.
Stack Overflow. (2024). Stack Overflow Survey 2024: Admired and Desired Technologies. https://survey.stackoverflow.co/2024/technology/#admired-and-desired

Berkenalan Dengan Bahasa Pemrograman Elixir

Muzhawir Amri — Wed, 04 Jun 2025 03:00:00 +0000

📜 You can read the English version here!

Daftar Isi

Bahasa Modern untuk Menulis Kode di BEAM
Peningkatan Fitur yang Dihadirkan oleh Elixir
Kekurangan Elixir
- Performa Bukan untuk Raw Performance
- Ekosistem Masih Lebih Kecil Dibanding Bahasa Populer
Sumber Belajar Elixir
Referensi

Di pelajaran sebelumnya kita telah mengenal Erlang sebagai bahasa yang dijalankan di atas BEAM. Namun, BEAM tidak hanya menjalankan Erlang. Ada juga bahasa lain seperti Elixir dan Gleam yang memanfaatkan platform yang sama. Dalam pelajaran ini, kita akan berkenalan dengan Elixir, bahasa modern untuk menulis kode di BEAM, sekaligus melihat peningkatan fitur yang membuatnya menarik untuk dipelajari.

Bahasa Modern untuk Menulis Kode di BEAM

Elixir adalah bahasa pemrograman fungsional yang berjalan di atas mesin virtual BEAM, mesin yang sama yang digunakan oleh Erlang. Elixir dirancang agar penulisan program lebih ringkas, mudah dibaca, dan mudah dirawat, sekaligus mewarisi keandalan serta kinerja tinggi dari platform Erlang.

Kode Elixir dikompilasi menjadi bytecode yang dijalankan oleh BEAM yang membuatnya sepenuhnya kompatibel dengan pustaka dan ekosistem Erlang. Kita bahkan bisa langsung menggunakan pustaka Erlang di proyek Elixir, dan sebaliknya.

Elixir juga dirancang dengan fokus pada produktivitas. Bahasa ini memiliki sintaks yang sederhana serta dilengkapi alat bantu modern, dukungan pengujian otomatis, dan utilitas debugging yang sesuai dengan kebutuhan pengembangan masa kini.

Dengan dukungan tersebut, pengembang dapat membangun aplikasi dari kecil hingga besar dengan lebih mudah dipahami dan dikelola. Elixir menjembatani keandalan dan daya tahan Erlang dengan kenyamanan serta ekspresivitas bahasa modern.

Elixir adalah proyek open source yang dikembangkan secara aktif oleh komunitas. Bahasa ini diciptakan oleh José Valim, dan source code-nya dapat diakses di repositori GitHub elixir-lang.

Peningkatan Fitur yang Dihadirkan oleh Elixir

Salah satu keunggulan utama Elixir adalah kemampuannya mengurangi boilerplate dan kebisingan sintaks (syntactic noise) yang umum dijumpai di Erlang. Hasilnya, kode menjadi lebih sederhana, ekspresif, dan mudah dipelihara. Bagi developer baru di ekosistem BEAM, sintaks Elixir terasa lebih ramah karena terinspirasi dari Ruby, bahasa yang dikenal bersih dan mudah dibaca. Hal ini menjadikan Elixir titik awal yang nyaman sebelum mempelajari kompleksitas Erlang secara mendalam.

Perhatikan perbandingan sintaks antara Ruby dan Elixir berikut.

Kode Ruby:

def greet(name)
  "Hello, #{name}!"
end

puts greet("Hello Rubyst!")

Kode Elixir:

def greet(name) do
  "Hello, #{name}!"
end

IO.puts greet("Hello Alchemist!")

Struktur def, penggunaan string interpolation (#{name}), dan alur logikanya hampir identik. Perbedaannya terletak pada penggunaan pasangan do ... end di Elixir untuk mendefinisikan function. Kemiripan ini membuat transisi dari Ruby ke Elixir terasa mulus, sementara bagi pemula seperti kita yang langsung belajar Elixir, sintaksnya tetap intuitif dan mudah diikuti.

Setelah melihat kemiripan sintaks antara Ruby dan Elixir, kita bandingkan dua bahasa yang sama-sama berjalan di atas mesin BEAM: Erlang dan Elixir. Meskipun keduanya berorientasi pada paradigma pemrograman fungsional, alur program dalam Elixir terasa lebih alami dan mudah dibaca.

Di Erlang, pemanggilan function sering kali dilakukan secara bersarang (staircasing), di mana setiap function dijalankan dari dalam ke luar. Pola ini cepat menurunkan keterbacaan ketika jumlah function bertambah.

Result = process3(process2(process1(Input))).

Contoh di atas baru menggabungkan tiga function; bayangkan tingkat kompleksitasnya jika ada sepuluh atau lebih.

Elixir menyederhanakan pola tersebut dengan menghadirkan pipe operator (|>), yang menuliskan alur eksekusi dari kiri ke kanan atau atas ke bawah, sehingga logika program lebih mudah diikuti.

# Satu baris
input |> process1() |> process2() |> process3()

# Multi baris
input
|> process1()
|> process2()
|> process3()

Operator ini menjadi ciri khas gaya penulisan Elixir karena memudahkan pembacaan alur data dari awal hingga akhir.

Selain pipe operator, Elixir menambahkan berbagai fitur yang meningkatkan pengalaman pengembangan. Dokumentasi dapat ditulis langsung di dalam kode menggunakan atribut @moduledoc dan @doc, lalu diuji otomatis melalui doctest seperti contoh berikut.

defmodule Math do
  @moduledoc """
  Provides simple mathematical operations.
  """

  @doc """
  Multiply number.

  ## Examples

      iex> Math.multiply(10)
      100
  """
  @spec multiply(number()) :: number()
  def multiply(number) do
    number * number
  end
end

Dokumentasi ini dapat diubah menjadi HTML atau EPUB menggunakan ExDoc. Kamu bisa melihat hasil nyatanya di dokumentasi resmi Elixir, karena dokumentasi yang kamu baca di sana juga dihasilkan langsung oleh ExDoc.

Dengan ExDoc, developer dapat menulis dokumentasi langsung di dalam codebase, dan alat ini secara otomatis menghasilkan dokumentasi yang selalu selaras dengan perubahan kode. Pendekatan ini membantu menjaga keakuratan dan konsistensi antara kode dan penjelasannya.

Untuk kebutuhan sehari-hari, Elixir menyediakan Mix, alat terpadu untuk manajemen proyek, pengujian, kompilasi, serta pengelolaan dependensi.

Mix terhubung langsung dengan Hex, package manager resmi ekosistem BEAM yang memudahkan distribusi dan instalasi pustaka. Keduanya terintegrasi erat, memungkinkan proses membangun, menguji, dan mendistribusikan aplikasi dilakukan sepenuhnya di dalam ekosistem Elixir.

Singkatnya, Elixir menghadirkan kekuatan dan keandalan Erlang dalam pengalaman pengembangan yang lebih modern, efisien, dan menyenangkan. Dengan fitur-fitur tersebut, kita dapat menulis kode yang ringkas, terstruktur, dan terdokumentasi dengan baik sejak awal.

Fitur-fitur yang dibahas di sini hanyalah sebagian kecil dari yang tersedia. Kamu dapat menjelajahi lebih banyak peningkatan dan kemampuan Elixir melalui dokumentasi resminya.

Kekurangan Elixir

Tidak ada teknologi yang sepenuhnya sempurna, termasuk Elixir dan platform yang berjalan di atas BEAM. Memahami kekurangan serta keterbatasannya penting agar kita dapat menilai apakah Elixir sesuai dengan kebutuhan proyek yang sedang dikembangkan. Pada akhirnya, keberhasilan sebuah proyek tidak ditentukan oleh seberapa populer teknologinya, melainkan oleh ketepatan memilih alat yang paling sesuai untuk menyelesaikan masalah yang dihadapi.

Performa Bukan untuk Raw Performance

Salah satu keterbatasan utama Elixir terletak pada performa eksekusinya. Karena berjalan di atas mesin virtual BEAM, Elixir tidak dapat menandingi kecepatan bahasa yang dikompilasi langsung ke kode mesin seperti C, C++, atau Rust. Untuk aplikasi yang sangat bergantung pada pemrosesan intensif CPU, seperti pengolahan gambar, machine learning, atau video encoding, Elixir bukanlah pilihan ideal.

Namun, hal ini bukan merupakan kelemahan desain, melainkan konsekuensi dari keputusan arsitektur yang sengaja dibuat. BEAM memprioritaskan stabilitas di bawah beban tinggi, toleransi terhadap kegagalan, dan kemampuan menjalankan banyak proses (concurrency) dalam skala besar, bukan mengejar raw performance atau jumlah requests per second semata.

Jika sebagian kecil dari aplikasi membutuhkan performa tinggi, bagian tersebut dapat ditulis menggunakan bahasa lain seperti C, lalu diintegrasikan melalui NIF (Native Implemented Function). Pendekatan ini memungkinkan kita memanfaatkan keunggulan BEAM tanpa kehilangan efisiensi di bagian yang benar-benar kritis terhadap performa.

Apabila aplikasi sepenuhnya bergantung pada komputasi intensif CPU, ada baiknya mempertimbangkan teknologi lain yang lebih sesuai dengan kebutuhan tersebut.

Ekosistem Masih Lebih Kecil Dibanding Bahasa Populer

Ekosistem Elixir saat ini masih lebih kecil dibanding bahasa pemrograman yang sudah lebih mapan. Sebagai perbandingan:

Hex, package manager resmi ekosistem BEAM (Erlang, Elixir, Gleam), menyediakan sekitar 20.000 pustaka.
Packagist untuk PHP memiliki lebih dari 400.000 pustaka.
NPM untuk JavaScript dan TypeScript memiliki lebih dari 3 juta pustaka.

Keterbatasan ini berarti beberapa pustaka yang dibutuhkan mungkin belum tersedia. Meski demikian, Elixir memiliki keunggulan interoperabilitas dengan bahasa lain di ekosistem BEAM. Kita dapat menggunakan pustaka Erlang secara langsung, bahkan pustaka dari Gleam, karena seluruh bahasa di BEAM saling kompatibel. Dengan begitu, ruang eksplorasi dan solusi yang tersedia tetap luas.

Meskipun ekosistem Elixir masih berkembang dan belum sebesar bahasa populer seperti JavaScript atau PHP, minat terhadapnya terus meningkat. Berdasarkan Stack Overflow Developer Survey 2025, Elixir menempati posisi ketiga sebagai bahasa yang paling diinginkan, tepat di bawah Gleam di posisi kedua. Phoenix Framework, web framework utama Elixir, bahkan menduduki peringkat pertama dalam kategori web frameworks and technologies yang paling diinginkan sejak 2023.

Tren ini menunjukkan peningkatan minat yang konsisten dari komunitas pengembang. Pertumbuhan tersebut memperkuat ekosistem Elixir dari waktu ke waktu. Komunitasnya juga dikenal ramah dan suportif terhadap pendatang baru, menjadikannya lingkungan yang kondusif untuk belajar, berkontribusi, dan berkembang bersama.

Sumber Belajar Elixir

Jika kamu ingin mulai belajar Elixir, tempat terbaik untuk memulainya adalah dokumentasi resminya, terutama bagian Getting Started. Di sana kamu akan menemukan penjelasan dasar tentang sintaks, struktur data, dan konsep inti yang membentuk cara kerja Elixir.

Selain dokumentasi, buku Elixir in Action edisi ketiga karya Saša Jurić juga sangat direkomendasikan. Buku ini dibagi menjadi tiga bagian besar: dasar bahasa, pemrograman concurrent di BEAM, dan penerapan Elixir di sistem produksi. Penjelasannya runtut, praktis, dan cocok untuk siapa pun yang ingin memahami Elixir secara menyeluruh.

Jika kamu lebih suka belajar lewat video, ada juga sumber visual seperti serial ElixirCasts dan kanal YouTube Elixir Mentor. Keduanya menyajikan video pendek dan langsung ke intinya, jadi pas buat belajar konsep Elixir secara praktis tanpa bertele-tele.

Dan tentu saja, kekuatan Elixir tidak hanya terletak pada teknologinya, tetapi juga pada komunitasnya. Forum Elixir Forum, kanal Discord, serta subreddit r/elixir menjadi tempat yang baik untuk berdiskusi, bertanya, dan berbagi proyek atau ide. Komunitasnya dikenal terbuka dan suportif; kamu dapat bertukar pengalaman dan belajar langsung dari para alchemist 🧙‍♂️ yang lebih berpengalaman.

Referensi

Jurić, S. (2024). Elixir in Action (3rd ed.). Manning Publications.
Stack Overflow. (2024). Stack Overflow survey 2024: Admired and desired technologies. Retrieved from https://survey.stackoverflow.co/2024/technology/#admired-and-desired

Functional Programming and Erlang Platform

Muzhawir Amri — Wed, 28 May 2025 18:00:00 +0000

📜 You can read the Indonesian version here!

Functional Programming Paradigm
- Imperative Programming
- Declarative Programming
- Object-Oriented Programming (OOP)
- Functional Programming (FP)
- Paradigms Used by Erlang and Elixir
Basic Principles of Functional Programming
- Immutability
- Pure Function
- First-Class Function
Erlang Development Platform
- Systems That Stay Available
- Concurrency in Erlang
- A Complete Development Platform
References

Functional Programming Paradigm

Every programming language is built on top of one or more programming paradigms, which are ways of thinking that influence how we write code, manage data, and design solutions. Understanding these paradigms helps us choose the most effective approach to solving a problem.

Let’s see a few commonly used paradigms.

Imperative Programming

The imperative paradigm takes the approach of giving the computer step-by-step instructions on how to accomplish a task. We explicitly and thoroughly control the sequence of actions, from initialization to final execution.

Example in Python:

total = 0

for i in range(1, 6):
    total += i

print("Total:", total)

This code adds numbers from 1 to 5. Every process is explicit: we initialize a variable, run a loop, sum the values, and print the result. Languages like Python, C, and Java are strongly supportive of this paradigm.

Declarative Programming

The declarative paradigm focuses on what should be achieved, not how to achieve it technically. We declare the desired outcome, and the compiler or runtime takes care of the execution details.

Example in SQL:

SELECT * FROM users WHERE is_active = 1;

Here we don't write step-by-step data fetching logic. We simply state the goal: retrieving active users, and SQL handles the implementation details. This paradigm is also seen in HTML and regular expressions, where we describe the end result without dictating the process flow explicitly.

Object-Oriented Programming (OOP)

The object-oriented paradigm structures applications as collections of objects. Each object stores data (state) and behavior (methods) to process that data. These objects interact with each other to form the application logic.

Example in Java:

class Car {
    String brand = "Toyota";

    void moveForward() {
        System.out.println(brand + " is moving forward -->");
    }

    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.moveForward();
    }
}

We define a Car class with a brand attribute and a moveForward() method. Then we create a myCar object and call its method. Languages like Java, Python, and JavaScript support this paradigm and encourage modularity and code reuse.

Functional Programming (FP)

The functional paradigm builds programs from many pure functions, which accept input, produce output, and do not cause side effects. This means a function’s result only depends on the input provided, without relying on or modifying external state. Data is processed through a series of functions that can be composed to form more complex logic.

Example in Elixir:

numbers = [1, 2, 3, 4, 5]

numbers
|> Enum.filter(fn x -> rem(x, 2) == 0 end)
|> Enum.map(fn x -> x * 2 end)

We start with a list of numbers, then use the filter function to select even numbers, and pass the result to the map function to double them. No variables are modified, and all functions can be tested independently. Languages like Erlang and Elixir are designed to support this style.

Paradigms Used by Erlang and Elixir

Erlang and Elixir combine two main paradigms:

Functional - Programs are built from many pure functions that can be composed to create complex logic.
Declarative - We focus on the desired result, not the sequence of instructions. Execution details are handled by the runtime.

This combination leads to code that is concise, modular, and easy to test. It is ideal for building large-scale systems that are fault-tolerant, can run in a distributed manner across multiple machines, and remain continuously available. For these reasons, the paradigm is widely used in telecommunications systems, real-time applications, and backend services that demand high reliability.

Basic Principles of Functional Programming

Functional programming is an approach to writing code that differs from the imperative style. In the imperative approach, we write instructions step by step: do this, then that, change this value, and so on. In functional programming, we focus on how data flows and is transformed through a series of functions.

We build programs by composing small functions. Data is passed into a function, which processes it and produces a new value, which can then be passed to the next function. This approach makes the program’s flow clearer and less surprising.

To make this model work well, functional programming uses several key principles:

Immutability

In functional programming, data is immutable. This means once a value is created, it cannot be changed. If we want to “change” a value, the system actually creates a new modified copy, while the original data remains untouched.

This approach is called data transformation, not modification, because we do not alter the old data but create a new version of it.

Even though we haven’t fully covered Elixir yet, let’s look at a quick example. Each example below includes a brief explanation of what the code does.

list = [1, 2, 3]
new_list = [0 | list]  # Result: [0, 1, 2, 3]

The list variable still holds [1, 2, 3] unchanged in memory. Meanwhile, new_list is a new list created by prepending 0 to it. This value is stored in a different memory location.

Immutability offers several benefits:

Avoids bugs caused by data being changed elsewhere.
Makes data flow easier to track and understand.
Prevents hidden or unpredictable state

Pure Function

A pure function has two main characteristics:

Its output is always the same for the same input. Whenever and wherever it is called, the result is consistent.
It does not cause side effects. It does not print to the screen unexpectedly, write to files, modify external data, or secretly read values from outside.

Example in Elixir:

square = fn x -> x * x end

This is an anonymous function stored in the square variable. If we call square.(4) multiple times, the result will always be 16. This function does not depend on any global state and does nothing beyond the x * x calculation.

Why are pure functions important?

Easy to test: just provide input and check the result. There is no external influence, so results are consistent.
Easy to compose: since they don’t have side effects, we can combine them without worrying about interference between functions.
Easy to understand: we can read the function’s contents without needing to know the global application context.

Of course, not all functions can be pure. Writing to files, accessing databases, or sending HTTP requests all require side effects.

In Elixir and many other modern functional languages, we can still write functions that perform side effects. However, the recommended approach is to separate side effects from the program’s core logic.

This means we try to keep most functions pure, focusing solely on transforming data without relying on or changing the outside world. Meanwhile, functions that deal with side effects are placed in specific parts of the code that are responsible for external interactions, such as controllers in web applications that handle HTTP requests or perform file/database access.

The goal is to keep most of the code clean, testable, and free of unexpected effects. We know exactly which parts of the code can be tested purely and which must be run in a real-world context like internet or file system interactions.

First-Class Function

In the functional paradigm, functions are treated like regular values. This means functions can be stored in variables, passed as arguments to other functions, and returned as results from other functions.

Quick example in Elixir:

double = fn x -> x * 2 end

Enum.map([1, 2, 3], double)

Here, double is an anonymous function stored in a variable. Then, in the Enum.map function, we pass double as an argument that will be applied to each element of the list [1, 2, 3] when Enum.map is called.

Erlang Development Platform

Before we learn Elixir, it's important to understand that it runs on top of Erlang. Without Erlang, Elixir wouldn’t run.

Erlang is a development platform created by the Swedish telecommunications company Ericsson in the mid-1980s. Its original goal was to build telephone network systems that could run continuously, even under extreme conditions such as high call volume, software bugs, or hardware/software upgrades. In short, the system had to remain operational and available despite facing various disruptions.

The name "Erlang" is short for Ericsson Language and was developed by three main figures: Joe Armstrong, Robert Virding, and Mike Williams. Initially, it was used internally at Ericsson. But since its release as open-source software in 1998, Erlang has been widely adopted in industries such as telecommunications, banking, multiplayer gaming, and real-time systems.

Over time, Erlang has proven effective in handling large-scale systems that require high availability and fault tolerance. This is why Elixir chose Erlang as its foundation.

Systems That Stay Available

Joe Armstrong once said in an interview with Rackspace in 2013:

“If Java is write once, run anywhere. Erlang is write once, run forever.”

This statement captures Erlang’s core philosophy: to create systems that keep running even when some components fail.

To support this, Erlang was designed with the following principles:

Fault Tolerance - The system keeps running even if some processes crash. These processes can be replaced or recovered automatically.
Scalability - The system can handle more load without being shut down, whether by adding CPU, RAM, or running additional nodes on other machines.
Distributed System - Erlang allows multiple nodes to connect and work as a single unit. This facilitates data replication, load distribution, and protects against single points of failure that could take down the whole system.
Responsiveness - Erlang systems are designed to handle heavy loads and high demand quickly, even under sudden spikes like traffic surges or mass call events.
Hot Code Swapping - Erlang allows live code updates without stopping the service. This is critical for systems that must remain continuously online.

Concurrency in Erlang

From the beginning, Erlang was designed to handle large-scale concurrency. Systems like phone networks, banking services, and real-time communication platforms must be able to run many units of work simultaneously without interference.

Unlike complex and heavyweight OS threads or processes, Erlang uses lightweight entities called Erlang processes. These are not OS threads or processes, but lightweight units of work scheduled by the Erlang virtual machine called BEAM.

They are extremely small and can be created in huge numbers, even millions, which makes them ideal for massive concurrency. We can run many processes efficiently, with low latency and strong isolation.

Key advantages of Erlang processes:

Full process isolation - Each process has its own memory and execution flow. If one process crashes, others continue unaffected. Because no memory is shared, there are no side effects or interference between processes.
Asynchronous message passing - All processes communicate by sending messages to one another. Since messages are passed by value (not by reference), each process works with its own copy of the data. This removes the need for locks or synchronization like in thread-based systems. There is no contention or waiting, so race conditions are avoided.
Per-process garbage collection - Each process manages its own memory, including garbage collection. This means when one process is freeing unused memory, others continue running uninterrupted. There is no global pause.
Lightweight and efficient - BEAM can run millions of processes efficiently. Erlang processes consume minimal memory and CPU. The BEAM scheduler fairly distributes execution time among all processes.

A Complete Development Platform

Erlang is not just a programming language. It is a full development platform that includes four key components:

Erlang Language - The functional programming language on this platform. Erlang code is compiled into bytecode that runs on the BEAM virtual machine.
BEAM Virtual Machine - The virtual machine that runs all Erlang (and Elixir) processes. BEAM handles process scheduling, memory management, message passing, and process isolation.
OTP (Open Telecom Platform) - A set of libraries and abstractions ready to use for building robust and structured systems. OTP is an inseparable part of Erlang, and together they are often called Erlang/OTP.
Development tools - Erlang provides tools like the interactive shell (erl), debugger, profiler, and more. These tools help us develop, test, and deploy applications on the platform.

Erlang is an actively developed open-source project with regular releases. Its source code is available on GitHub Erlang/OTP, and Ericsson remains directly involved in its development.

References

Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.
IONOS Editorial Team. (2021, May 21). Imperative Programming. https://www.ionos.com/digitalguide/websites/web-development/imperative-programming
Federico Pereiro. (n.d.). Declarative Programming: Is It A Real Thing? Accessed May 23, 2024, from https://www.toptal.com/software/declarative-programming

Pemrograman Fungsional dan Platform Erlang

Muzhawir Amri — Wed, 21 May 2025 03:00:00 +0000

📜 You can read the English version here!

Daftar Isi

Paradigma Pemrograman Fungsional
- Imperative Programming
- Declarative Programming
- Object-Oriented Programming (OOP)
- Functional Programming (FP)
- Paradigma di Erlang dan Elixir
Prinsip Dasar Pemrograman Fungsional
- Immutability
- Pure Function
- First-Class Function
- Recursion
- Lazy Evaluation
Platform Pengembangan Erlang
- Apa Itu Erlang
- Sejarah Singkat Erlang
- Sistem dengan Ketersediaan Tinggi (High Availability System)
- Erlang Process
- Penerapan Nyata dalam Sistem Server-side
- Erlang sebagai Platform Pengembangan
Referensi

Selamat datang di pembelajaran Elixir! Sebelum kita menulis "Hello World!" pertama, ada baiknya kita berkenalan dulu dengan paradigma pemrograman fungsional, cara berpikir yang menjadi dasar dalam bahasa ini. Saya yakin kamu yang membaca ini mungkin berasal dari latar belakang seperti JavaScript, TypeScript, atau Ruby, dan sudah terbiasa dengan gaya pemrograman imperatif serta berorientasi objek. Di Elixir, kita akan melihat pemrograman dari sudut yang sedikit berbeda, di mana kita tidak menggunakan class atau object, melainkan membangun program melalui kumpulan function yang saling bekerja sama.

Paradigma Pemrograman Fungsional

Paradigma pemrograman adalah cara berpikir dalam menulis kode. Paradigma menentukan bagaimana kita memberi instruksi kepada komputer, mengolah data, dan menyelesaikan masalah.

Setiap bahasa pemrograman umumnya mendukung satu atau lebih paradigma. Pemilihan paradigma yang tepat membantu kita menulis kode yang lebih mudah dibuat, dibaca, dan dipelihara.

Dalam praktiknya, terdapat beberapa paradigma yang umum digunakan, seperti imperative, declarative, object-oriented, dan functional. Berikut penjelasannya.

Imperative Programming

Paradigma imperatif merupakan pendekatan tradisional dalam menulis program. Di sini kita menjelaskan secara terperinci bagaimana komputer harus menyelesaikan suatu tugas, langkah demi langkah. Analogi sederhananya seperti mengikuti resep masakan yang dijalankan secara berurutan.

Contoh dalam Ruby:

total = 0

(1..5).each do |i|
  total += i
end

puts "Total: #{total}"

Kode ini menghitung jumlah angka dari 1 hingga 5 dengan menambahkan nilainya ke variabel total secara bertahap. Paradigma ini banyak digunakan di bahasa populer seperti Ruby, JavaScript, Python, dan PHP.

Declarative Programming

Paradigma deklaratif menekankan pada apa yang ingin dicapai, bukan bagaimana cara mencapainya. Kita cukup menyatakan hasil yang diinginkan, sementara komputer atau runtime menentukan langkah-langkah pelaksanaannya.

Contoh dalam SQL:

SELECT * FROM users WHERE is_active = 1;

Kita hanya menyebutkan tujuannya, mengambil semua pengguna aktif tanpa perlu menjelaskan proses pencariannya.

Contoh serupa dalam Elixir:

numbers = [1, 2, 3, 4, 5]
Enum.sum(numbers)

Kita hanya menyatakan bahwa ingin menjumlahkan seluruh elemen numbers, dan function Enum.sum menangani detail prosesnya. Pendekatan deklaratif juga banyak ditemukan di HTML, CSS, dan regular expressions. Dalam Elixir, gaya ini berpadu dengan paradigma fungsional untuk menghasilkan kode yang ringkas dan ekspresif.

Object-Oriented Programming (OOP)

Paradigma berorientasi objek menyusun program dalam bentuk object, yaitu representasi dari entitas nyata atau konsep abstrak. Setiap object memiliki data (state) dan perilaku (method).

Bayangkan robot mainan: setiap robot memiliki status internal seperti energi baterai (state) dan aksi yang bisa dilakukan (behavior). Ketika kita memberi perintah, robot merespons sesuai kondisinya.

Konsep utama dalam OOP meliputi:

Encapsulation: menggabungkan data dan perilaku dalam satu kesatuan.
Inheritance: memungkinkan object mewarisi sifat dan perilaku dari object lain.
Polymorphism: instruksi yang sama dapat dijalankan dengan cara berbeda oleh object yang berbeda.

Contoh dalam Ruby:

class Robot
  attr_accessor :name, :battery

  def initialize(name, battery = 100)
    @name = name
    @battery = battery
  end

  def move_forward
    if @battery > 0
      puts "#{@name} is moving forward"
      @battery -= 10
    else
      puts "#{@name} has no energy left!"
    end
  end
end

r1 = Robot.new("Alpha")
r1.move_forward

Kita membuat class Robot dengan atribut name dan battery, lalu menambahkan perilaku move_forward. Saat objek r1 dipanggil untuk bergerak, ia menyesuaikan perilaku berdasarkan status baterainya.

Functional Programming (FP)

Pemrograman fungsional berfokus pada penyusunan program dari banyak function kecil yang masing-masing menjalankan satu tugas spesifik. Function tersebut kemudian dikombinasikan untuk membentuk alur kerja yang lebih kompleks.

Karakteristik utama FP:

Pure function: selalu menghasilkan keluaran yang sama untuk input yang sama tanpa efek samping (side effect).
Immutability: data bersifat tetap dan tidak diubah setelah dibuat.

Alih-alih memodifikasi data, FP biasanya membuat data baru menggunakan function seperti map atau filter.

Contoh dalam Elixir:

numbers = [1, 2, 3, 4, 5]

numbers
|> Enum.filter(fn x -> rem(x, 2) == 0 end)
|> Enum.map(fn x -> x * 2 end)

Kode ini mengambil angka genap dari numbers, lalu menggandakan nilainya. Variabel numbers tetap tidak berubah karena setiap operasi menghasilkan daftar baru.

Paradigma di Erlang dan Elixir

Erlang dan Elixir menggabungkan paradigma deklaratif dan fungsional. Alih-alih menulis instruksi langkah demi langkah, kita cukup mendeskripsikan tujuan program, sedangkan detail eksekusinya ditangani oleh runtime. Semua data bersifat immutable, dan logika program dibangun dari kumpulan pure functions yang saling berinteraksi.

Pendekatan ini membuat program lebih mudah diuji, lebih aman dari efek samping, dan secara alami mendukung concurrency (menjalankan banyak proses secara paralel). Inilah alasan mengapa Elixir dan Erlang sangat efektif untuk sistem berskala besar dan berdaya tahan tinggi (fault-tolerant systems).

Prinsip Dasar Pemrograman Fungsional

Functional programming adalah paradigma yang berfokus pada penyusunan program dari banyak function kecil, di mana masing-masing function menangani satu tugas spesifik. Function tersebut kemudian digabungkan untuk membentuk alur kerja yang lebih kompleks.

Dalam paradigma ini, program dipandang sebagai rangkaian transformasi data, sebuah function menerima input, mengolahnya, lalu menghasilkan output baru tanpa mengubah data asli.

Pendekatan ini berbeda dengan gaya imperative, di mana program ditulis sebagai urutan instruksi yang mengubah state (keadaan) dari waktu ke waktu. Dalam imperative programming, fokusnya adalah bagaimana langkah-langkah dijalankan, sedangkan dalam functional programming fokusnya ada pada hasil dari transformasi data.

Dengan merangkai function dan mengalirkan hasilnya ke function berikutnya, alur pemrosesan data menjadi lebih jelas, mudah dibaca, serta aman dari efek samping. Pendekatan ini juga mempermudah pemeliharaan dan pengujian kode.

Paradigma ini dibangun di atas beberapa prinsip utama berikut.

Immutability

Dalam pemrograman fungsional, data bersifat immutable, artinya setelah dibuat nilainya tidak dapat diubah. Jika kita ingin "mengubah" data, yang sebenarnya terjadi adalah pembuatan salinan baru dengan nilai berbeda, sementara data asli tetap utuh. Proses ini disebut transformasi data, bukan modifikasi.

Contoh dalam Elixir:

list = [1, 2, 3]

new_list = [0 | list]  # Hasil: [0, 1, 2, 3]

Variabel list tetap berisi [1, 2, 3]. Saat kita menambahkan 0 di depan, Elixir membuat list baru bernama new_list tanpa mengubah data lama.

Sekilas, immutability tampak kurang efisien karena membuat data baru alih-alih mengubah yang sudah ada. Namun, bahasa fungsional modern seperti Elixir menggunakan berbagai optimisasi di balik layar, sehingga hanya bagian data yang benar-benar berubah yang disalin.

Keunggulan immutability antara lain:

Data lebih aman, karena tidak bisa diubah secara tidak sengaja.
Alur program lebih mudah dipahami, sebab nilai tidak berubah di tengah proses.
Risiko bug berkurang, terutama akibat perubahan tak terduga.
Mendukung eksekusi paralel, karena setiap proses bekerja pada salinannya sendiri.

Pure Function

Pure function adalah function yang selalu menghasilkan output yang sama untuk input yang sama dan tidak menimbulkan efek samping. Dua ciri utamanya adalah:

Deterministik: hasilnya selalu sama untuk input yang sama.
Bebas efek samping: tidak mengubah state di luar dirinya dan tidak berinteraksi langsung dengan lingkungan eksternal.

Contoh dalam Elixir:

square = fn x -> x * x end

Kode di atas mendefinisikan anonymous function bernama square yang selalu mengembalikan kuadrat dari inputnya. Jika kita memanggil square.(2), hasilnya pasti 4 tanpa variasi atau pengaruh dari luar.

Keuntungan pure function:

Mudah diuji, cukup beri input dan periksa output.
Mudah dirangkai (function composition), dapat digabung untuk membentuk alur transformasi data.
Mudah dipahami, karena perilakunya dapat diprediksi.

Tentu, tidak semua bagian program bisa sepenuhnya pure. Interaksi dengan file, basis data, atau jaringan pasti menimbulkan efek samping. Prinsip utamanya adalah memisahkan logika pure dari bagian yang berinteraksi dengan dunia luar. Dalam Elixir, efek samping biasanya ditangani di lapisan seperti controller, sedangkan logika inti dijaga tetap murni.

First-Class Function

Dalam paradigma fungsional, function diperlakukan sebagai warga kelas satu (first-class citizen). Artinya, function memiliki kedudukan yang sama dengan data biasa sehingga dapat:

Disimpan dalam variabel.
Diteruskan sebagai argumen ke function lain.
Dikembalikan sebagai hasil dari function lain.

Contoh dalam Elixir:

double = fn x -> x * 2 end

result = Enum.map([1, 2, 3], double)  # result: [2, 4, 6]

Penjelasannya:

double adalah anonymous function yang menggandakan nilai input.
Function double diteruskan sebagai argumen ke Enum.map.
Enum.map memanggil double untuk setiap elemen dalam [1, 2, 3].
Hasilnya adalah list baru [2, 4, 6].

Hal ini menjadi dasar bagi tiga konsep penting dalam pemrograman fungsional yang akan kita pelajari nanti:

Lambda (anonymous function): function tanpa nama yang biasanya singkat dan dipakai langsung.
Closure: function yang membawa konteks lingkungannya sehingga tetap dapat mengakses variabel luar meskipun dijalankan di tempat lain.
Higher-Order Function (HOF): function yang menerima function lain sebagai argumen atau mengembalikannya sebagai hasil.

Recursion

Rekursi adalah teknik di mana sebuah function memanggil dirinya sendiri dengan versi masalah yang lebih kecil hingga mencapai kondisi berhenti.

Dalam pemrograman fungsional, rekursi menggantikan looping. Bahasa seperti Elixir tidak menyediakan for atau while tradisional karena data bersifat immutable, sehingga variabel penghitung tidak bisa diubah di setiap iterasi. Solusinya adalah memanggil kembali function yang sama hingga kondisi berhenti tercapai.

Contoh sederhana mencetak $n$ bilangan asli pertama:

def print(1), do: IO.puts(1)  ❶

def print(n) when n > 1 do  ❷
  print(n - 1)
  IO.puts(n)
end

Penjelasannya:

❶ Kasus dasar n = 1 menjadi titik berhenti rekursi.
❷ Kondisi kedua memanggil print dengan n - 1, lalu mencetak nilai n setelah rekursi selesai.

Jika kita memanggil print(3), hasilnya:

1
2
3

Lazy Evaluation

Lazy evaluation adalah teknik menunda eksekusi perhitungan hingga hasilnya benar-benar dibutuhkan. Program tidak langsung menghitung semua nilai, melainkan menyiapkan "rencana" perhitungan. Nilai baru dihitung hanya saat diperlukan.

Keunggulan lazy evaluation:

Lebih efisien, karena hanya menghitung nilai yang dibutuhkan.
Dapat menangani data besar atau tak terbatas, karena tidak harus membuat seluruh struktur data sekaligus.

Contoh dalam Elixir menggunakan Stream, yang bekerja secara lazy:

stream = Stream.map([1, 2, 3], fn x -> x * 2 end)  ❶

Enum.sum(stream)  ❷

Penjelasannya:

❶ Stream.map tidak langsung menggandakan elemen [1, 2, 3], tetapi menyiapkan rencana perhitungan.
❷ Saat Enum.sum dipanggil, barulah perhitungan dijalankan. Elemen digandakan menjadi [2, 4, 6], lalu dijumlahkan menghasilkan 12.

Platform Pengembangan Erlang

Sebelum mempelajari Elixir, penting untuk memahami platform tempat Elixir berjalan, yaitu Erlang. Elixir dibangun di atas ekosistem Erlang. Memahami lapisan dasarnya membantu kita melihat mengapa Elixir sangat kuat untuk membangun sistem dengan ketersediaan tinggi.

Apa Itu Erlang

Erlang adalah bahasa pemrograman sekaligus platform pengembangan yang dirancang untuk membuat sistem dengan ketersediaan tinggi (high availability). Nama "Erlang" diambil dari Agner Krarup Erlang, matematikawan Denmark yang mengembangkan teori antrian (queueing theory) dalam telekomunikasi. Nama ini juga sering dianggap sebagai singkatan dari Ericsson Language.

Sejarah Singkat Erlang

Erlang dikembangkan pada pertengahan 1980-an oleh Ericsson Computer Science Laboratory di Swedia. Tiga tokoh utamanya adalah Joe Armstrong, Robert Virding, dan Mike Williams. Tujuan mereka sederhana tetapi ambisius, yaitu membangun sistem telekomunikasi yang tidak pernah berhenti berjalan, bahkan saat terjadi lonjakan panggilan, kesalahan perangkat lunak, atau kegagalan perangkat keras.

Sistem jaringan telepon Ericsson harus beroperasi tanpa henti selama 24 jam. Satu kegagalan kecil dapat memutus layanan bagi ribuan pengguna.

Pada tahun 1998, Erlang dirilis sebagai perangkat lunak open source. Sejak itu, Erlang digunakan dalam berbagai sistem besar seperti WhatsApp, Discord, RabbitMQ, sistem finansial, hingga backend gim multiplayer. Selama lebih dari tiga dekade, Erlang terbukti stabil, andal, dan mampu menangani skala besar. Inilah kekuatannya, membangun sistem yang terus hidup (high availability systems).

Sistem dengan Ketersediaan Tinggi (High Availability System)

Joe Armstrong pernah berkata dalam sebuah wawancara pada tahun 2013:

"Kalau Java itu tulis sekali, jalankan di mana saja. Erlang itu tulis sekali, jalankan selamanya."

Ungkapan ini merangkum filosofi Erlang, membangun sistem yang tetap berjalan meskipun terjadi kegagalan. Untuk mencapainya, Erlang memiliki beberapa kemampuan penting:

Fault Tolerance: proses yang gagal tidak menjatuhkan seluruh sistem. Proses rusak dapat dibuat ulang secara otomatis, dan efek kegagalannya dibatasi secara lokal.
Scalability: sistem dapat diperluas tanpa menghentikan layanan, baik dengan menambah sumber daya (vertical scaling) maupun menambah node baru (horizontal scaling).
Distributed System: sistem dapat dijalankan di banyak mesin. Jika satu mesin gagal, mesin lain mengambil alih tanpa menghentikan layanan.
Responsiveness: sistem tetap responsif meskipun beban meningkat. Proses berat tidak memblokir proses lain.
Hot Code Swapping: aplikasi dapat diperbarui tanpa waktu henti, misalnya memperbarui perangkat lunak telepon tanpa memutus panggilan aktif.

Semua kemampuan ini dimungkinkan oleh mesin virtual Erlang dan model konkurensi yang digunakannya.

Erlang Process

Untuk mencapai ketersediaan tinggi, Erlang menggunakan mesin virtual BEAM (Bogdan/Björn’s Erlang Abstract Machine) serta model konkurensi berbasis proses. Erlang process adalah unit eksekusi terkecil di Erlang. Ia berbeda dari thread sistem operasi karena setiap proses sepenuhnya terisolasi, tidak berbagi memori, dan berkomunikasi melalui pengiriman pesan (message passing).

Model ini memungkinkan satu sistem Erlang menjalankan ribuan bahkan jutaan proses secara bersamaan.

Keunggulan model proses Erlang:

Fault Tolerance: kegagalan satu proses tidak memengaruhi proses lain. Supervisor process mengawasi proses lain dan dapat membuat ulang proses yang gagal secara otomatis.
Scalability: komunikasi berbasis pesan menghindari kerumitan sinkronisasi. BEAM menjadwalkan proses ke seluruh inti CPU secara otomatis.
Distribution: proses dapat berkomunikasi dengan proses lain di mesin mana pun dengan cara yang sama tanpa memedulikan lokasi fisiknya.
Responsiveness: BEAM menggunakan preemptive scheduler yang memastikan tidak ada proses yang mendominasi CPU. Pengumpulan sampah (garbage collection) dilakukan per proses sehingga cepat dan tidak mengganggu keseluruhan sistem.

Model inilah yang membuat sistem Erlang tetap hidup meskipun terjadi kegagalan parsial.

Penerapan Nyata dalam Sistem Server-side

Kekuatan Erlang paling terasa pada sistem server-side, yaitu sistem yang berjalan di server untuk melayani banyak pengguna secara terus-menerus. Contoh utamanya adalah aplikasi chat, sistem telekomunikasi, dan backend layanan waktu nyata (real-time backend).

Sistem server-side biasanya terdiri atas beberapa komponen yang tersebar di banyak mesin (node). Erlang memudahkan pembangunan sistem seperti ini dengan menyediakan:

Konkurensi bawaan untuk menangani ribuan hingga jutaan koneksi.
Distribusi lintas mesin dengan komunikasi pesan yang seragam.
Mekanisme failover yang menjaga layanan tetap berjalan ketika sebagian node gagal.

Contoh Kasus Perbandingan Dua Web Server

Dalam salah satu proyeknya, Saša Jurić, penulis buku Elixir in Action yang menjadi rujukan utama seri ini, membandingkan dua pendekatan dalam membangun web server dengan kebutuhan teknis berikut:

Melayani banyak klien.
Menangani permintaan dengan waktu proses panjang (long-running requests).
Mengelola server-wide state.
Menyimpan data persisten.
Menjalankan background jobs.

Hasil perbandingan menunjukkan perbedaan yang mencolok:

Server A membutuhkan tumpukan teknologi beragam seperti NGINX, Ruby on Rails, Redis, MongoDB, cron, dan Bash.
Server B mampu menangani seluruh kebutuhan tersebut langsung di dalam platform Erlang.

Kebutuhan Teknis	Server A	Server B
HTTP Server	NGINX, Phusion Passenger	Erlang
Request Processing	Ruby on Rails	Erlang
Long-running Requests	Go	Erlang
Server-wide State	Redis	Erlang
Persistable Data	Redis, MongoDB	Erlang
Background Jobs	cron, Bash, Ruby	Erlang
Service Crash Recovery	Upstart	Erlang

Perbandingan ini menunjukkan bahwa Erlang menghadirkan solusi yang lebih ringkas. Sebagian besar kebutuhan sistem, mulai dari pengelolaan koneksi, state, hingga pemulihan kegagalan, dapat ditangani langsung oleh platform tanpa integrasi kompleks antar teknologi.

Namun, Erlang tidak dimaksudkan untuk menggantikan seluruh teknologi populer yang sudah ada. Ia lebih tepat dipandang sebagai platform kuat untuk membangun sistem lengkap dengan kompleksitas awal yang rendah, namun tetap memungkinkan integrasi dengan bahasa atau layanan lain bila diperlukan.

Singkatnya, Erlang memberikan fleksibilitas tinggi bagi developer. Ia dapat digunakan sebagai platform mandiri atau diintegrasikan dengan teknologi lain sesuai kebutuhan sistem.

Erlang sebagai Platform Pengembangan

Erlang bukan hanya bahasa pemrograman, tetapi platform lengkap yang terdiri atas beberapa komponen utama:

Bahasa Erlang: bahasa fungsional untuk menulis program yang dijalankan di mesin BEAM.
Mesin Virtual BEAM: mengeksekusi bytecode, mengatur proses, komunikasi antarproses, serta menjaga sistem tetap berjalan meskipun terjadi kesalahan.
OTP (Open Telecom Platform): kumpulan pustaka dan pola desain siap pakai untuk membangun sistem Erlang. OTP mencakup manajemen proses, pengawasan, pembaruan kode tanpa henti, dan pemantauan sistem. OTP sering disebut bersama Erlang sebagai Erlang/OTP.
Tooling: berbagai alat bantu untuk menjalankan, mengelola, dan berinteraksi dengan program Erlang beserta dependensinya.

Erlang/OTP bersifat open source, tersedia di berbagai sistem operasi utama, dan masih aktif dikembangkan oleh Ericsson serta komunitas melalui repositori resmi Erlang/OTP di GitHub.

Referensi

Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.
IONOS Editorial Team. (2021, May 21). Imperative Programming. https://www.ionos.com/digitalguide/websites/web-development/imperative-programming
Federico Pereiro. (n.d.). Declarative Programming: Is It A Real Thing? Diakses Mei 23, 2024, dari https://www.toptal.com/software/declarative-programming

DEV Community: Muzhawir Amri

Variable, Immutability, And Garbage Collection

Table of Contents

Binding - Creating Variables

In Imperative Languages: A Refillable Box

In Elixir: A Sealed Box

Type Inference

Naming Variables

Trailing Question Mark and Exclamation Mark

Rebinding - Updating Variable Values

Memory Management in Elixir

References

Variabel, Imutabilitas, dan Garbage Collection

Daftar Isi

Binding - Membuat Variabel

Di Bahasa Imperatif - Kotak yang Dapat Diisi Ulang

Di Elixir - Kotak Tersegel

Tipe Data Ditentukan Otomatis

Penamaan Variabel

Akhiran Tanda Tanya dan Tanda Seru

Rebinding - Memperbarui Nilai Variabel

Manajemen Memori di Elixir

Referensi

IEx: Elixir's Interactive Shell

Starting and Writing Expressions in IEx

Starting an IEx Session and Evaluating Expressions

Multi-line Expressions

Reading Documentation in IEx

How We Debug in IEx

Exiting the IEx Session or Viewing Other Options

References

IEx: Shell Interaktif Elixir

Daftar Isi

Memulai dan Menulis Ekspresi di IEx

Membaca Dokumentasi di IEx

Melihat Dokumentasi Module

Melihat Dokumentasi Function

Cara Debugging di IEx

Menggunakan dbg/1 di Dalam Pipeline

Keluar dari Sesi IEx atau Menampilkan Opsi Lainnya

Referensi

Preparing the Elixir Development Environment

Table of Contents

What is the asdf version manager?

Why Choose asdf?

Installing asdf

Using a Package Manager

Downloading the Precompiled Binary

Verifying the Binary Location

Verifying the asdf Installation

Installing Plugins in asdf

Erlang Plugin

Elixir Plugin

Node.js Plugin (Optional)

Installing Runtimes in asdf

Checking Elixir and Erlang Compatibility

Checking Available Versions

Installing Erlang

Installing Elixir

Installing Node.js (Optional)

Managing Runtime Versions in asdf

Setting Global Versions

Setting Local Versions

ElixirLS - Editor Extension for Elixir Development

Key Features of ElixirLS

Installing ElixirLS in VS Code

Mempersiapkan Lingkungan Pengembangan Elixir

Daftar Isi

Apa itu asdf version manager?

Mengapa Memilih asdf?

Instalasi asdf

Menggunakan Package Manager

Mengunduh Precompiled Binary

Verifikasi Lokasi Binary

Verifikasi Instalasi asdf

Instalasi Plugin di asdf

Plugin Erlang

Plugin Elixir

Plugin Node.js (Opsional)

Instalasi Runtime di asdf

Menggunakan `dbg/1` di Dalam Pipeline

What is the `asdf` version manager?

Why Choose `asdf`?

Installing `asdf`

Verifying the `asdf` Installation

Installing Plugins in `asdf`

Installing Runtimes in `asdf`

Managing Runtime Versions in `asdf`

Apa itu `asdf` version manager?

Mengapa Memilih `asdf`?

Instalasi `asdf`

Verifikasi Instalasi `asdf`

Instalasi Plugin di `asdf`

Instalasi Runtime di `asdf`

Mengatur Versi Runtime di `asdf`