Elixir untuk Technical Leader — Bab 1 dari 10

Kenapa Elixir & BEAM

Bukan "bahasa terbaik di dunia" — tapi bahasa yang paling cocok untuk LabaBersih. Dan kamu harus tau kenapa.

Sejarah Singkat (2 Menit)

Elixir lahir tahun 2012, dibuat oleh José Valim — core contributor Ruby on Rails. Dia frustrasi: Ruby bagus untuk developer happiness, tapi jelek untuk concurrency (handle banyak hal bersamaan).

José gak bikin dari nol. Dia bangun Elixir di atas BEAM — virtual machine yang sudah proven selama 30+ tahun di industri telekomunikasi (Ericsson, WhatsApp).

Timeline penting:

BEAM — Mesin di Balik Elixir

BEAM = Bogdan/Björn's Erlang Abstract Machine. Ini virtual machine (kayak JVM untuk Java). Semua code Elixir jalan di atas BEAM.

Kenapa BEAM spesial? 4 Superpower:

1. Lightweight Processes (Bukan Thread OS)

BEAM bisa jalankan jutaan proses secara bersamaan. Bukan thread OS yang berat (1 thread = ~1MB RAM). BEAM process cuma ~2KB.

# Di LabaBersih, setiap user yang buka browser = 1 LiveView process
# 100 user online = 100 process. Ringan banget.
# Di Next.js v1: 100 user = 100 HTTP connection, masing-masing stateless

2. Fault Tolerance ("Let it crash")

Filosofi BEAM: kalau 1 proses error, biarkan crash — supervisor akan restart otomatis. Gak perlu try-catch di mana-mana.

3. Hot Code Reload

BEAM bisa update code tanpa mematikan server. Ericsson pakai ini untuk switch telepon yang literally gak boleh mati 24/7.

Untuk LabaBersih: saat development, kamu ubah code → browser auto-refresh (LiveView). Gak perlu restart server.

4. Distribution (Multi-Node)

BEAM process bisa komunikasi antar server semudah komunikasi di 1 server. Ini kenapa WhatsApp bisa 2 juta koneksi per server — mereka connect banyak BEAM node.

Untuk LabaBersih sekarang: belum perlu (1 server Fly.io cukup). Tapi kalau scale ke 50.000 order/hari, tinggal tambah node. Arsitektur gak perlu berubah.

Kenapa Elixir Cocok untuk LabaBersih

Ini bukan soal "Elixir terbaik" — ini soal match antara kebutuhan bisnis dan kemampuan teknologi.

v1 vs v2 — Perbedaan Arsitektur

Supaya kamu paham apa yang berubah secara fundamental:

v1: 3 Layer Terpisah

# v1 Architecture (Next.js + Supabase)

Browser (React/Next.js)
    ↓ HTTP request
Supabase Edge Functions (31 functions, Deno runtime)
    ↓ SQL query
PostgreSQL (Supabase, + 16 RPC functions di database)

# Masalah:
# - Logic tersebar di 3 tempat (React, Edge, SQL)
# - Gak ada shared type system
# - Error baru ketemu saat runtime
# - Edge Function stateless = gak bisa share state

v2: 1 Layer Terintegrasi

# v2 Architecture (Elixir/Phoenix)

Browser (HTML dari LiveView, minimal JS)
    ↑↓ WebSocket (persistent connection)
Phoenix LiveView + Contexts (semua logic di 1 tempat)
    ↓ Ecto query
PostgreSQL (Fly.io, zero stored procedures)

# Keuntungan:
# - Logic HANYA di Elixir contexts (1 tempat)
# - Compile-time error checking
# - Persistent WebSocket = real-time tanpa polling
# - Database bersih = hanya data, gak ada logic

Compile-Time Safety — Kenapa Ini Game Changer

Ini yang tadi kamu lihat dari LSP diagnostics. Elixir punya 3 lapis pengecekan sebelum code jalan di production:

Lapis 1: Compiler

Elixir compiler cek setiap kali kamu save file:

# Kamu tulis ini (typo di nama function):
Orders.shiip_order(order_id, email)

# Compiler langsung bilang:
# ** (UndefinedFunctionError) function Orders.shiip_order/2 is undefined
# Did you mean: ship_order/2

# Di v1 (JavaScript): GADA ERROR sampai user klik button dan function dipanggil

Lapis 2: Dialyzer (Type Analysis)

Ini yang ElixirLS pakai — analisis tipe data tanpa kamu nulis type annotation:

# Dialyzer detect: "pattern {:ok, _} can never match"
# Artinya: function itu SELALU return {:error, _}
# Code path {:ok, _} = DEAD CODE, gak pernah kepakai

# Ini yang tadi kamu lihat di sync_facebook.ex, sync_scalev.ex, sync_tiktok_ads.ex
# Kalau di v1: gak ada yang detect. Silent fail.

Lapis 3: Tests (ExUnit)

# 133+ automated tests di LabaBersih v2
# v1 punya: 0 (nol) automated tests

# Setiap function penting di-test:
# - ship_order happy path + edge cases
# - jurnal balanced (debit = credit)
# - FEFO lot consumption order
# - Status transition enforcement

Batteries Included — Tooling Bawaan Elixir

Salah satu alasan Elixir terasa "lengkap" dibanding stack lain: hampir semua tools yang kamu butuhkan sudah built-in atau 1 dependency away. Gak perlu rakit sendiri kayak JavaScript ecosystem.

Tools Inti (Built-in, gak perlu install)

Tools Ecosystem (1 dependency, minimal config)

Perbandingan Langsung: v1 vs v2

Mix Commands yang Kamu Harus Tau

Ini perintah terminal yang bisa kamu jalankan sendiri tanpa Claude:

# ── DEVELOPMENT ──
mix phx.server          # Start development server (buka localhost:4000)
mix deps.get            # Install dependencies (kayak npm install)
mix compile             # Compile code — detect errors SEBELUM jalankan

# ── DATABASE ──
mix ecto.create         # Buat database baru
mix ecto.migrate        # Jalankan migration (ubah struktur tabel)
mix ecto.rollback       # Undo migration terakhir (kalau salah)
mix ecto.reset          # Drop + create + migrate (HATI-HATI: hapus semua data!)
mix run priv/repo/seeds.exs  # Isi data sample

# ── QUALITY ──
mix test                # Jalankan semua test (133+ tests)
mix test --failed       # Cuma jalankan test yang gagal terakhir
mix test test/lababersih/orders/orders_test.exs  # Test 1 file aja
mix credo               # Code quality check
mix sobelow             # Security scan
mix dialyzer            # Type analysis (lama pertama kali, cepat setelahnya)

# ── DOCS ──
mix docs                # Generate HTML docs → buka doc/index.html
mix hex.docs online ecto  # Buka docs library di browser

# ── DEPLOYMENT ──
mix phx.gen.release     # Generate Dockerfile untuk production
mix release             # Build production binary
fly deploy              # Deploy ke Fly.io (ini CLI Fly, bukan Mix)

ExDoc — Documentation dari Code (Detail)

Ini fitur favorit Elixir community. Setiap @moduledoc dan @doc yang ditulis di code otomatis jadi halaman dokumentasi.

defmodule Lababersih.Orders do
  @moduledoc """
  Order management — pesanan, packing, shipment.

  ## Fungsi Utama
  - `create_order/2` — buat pesanan baru
  - `ship_order/2` — kirim pesanan (atomic 5 langkah)
  - `delete_order/1` — hapus + reverse stok + void jurnal
  """

  @doc """
  Ship order — ATOMIC transaction (5 langkah):
  1. Validasi status = dikemas
  2. Update status → dikirim, set shipped_at
  3. Potong stok per item (FEFO+FIFO lot consumption)
  4. Generate jurnal penjualan + HPP
  5. Insert audit trail

  ## Contoh

      iex> Orders.ship_order("PS2603-00001", "nelly@lababersih.id")
      {:ok, %{order: %Order{}, journal: %JournalEntry{}}}
  """
  def ship_order(order_id, actor_email) do
    # ... implementation
  end
end

Jalankan mix docs → semua @doc di atas jadi halaman web yang bisa di-browse, lengkap dengan navigasi, search, dan cross-reference antar module. Ini yang lu lihat di hexdocs.pm untuk library Elixir manapun.

IEx — Interactive Shell (Power Tool)

IEx = Interactive Elixir. Bayangkan Chrome DevTools console, tapi bisa akses seluruh backend.

# Start IEx dengan project LabaBersih loaded:
$ iex -S mix

# Sekarang kamu bisa jalankan function APAPUN:
iex> Lababersih.Orders.get_order!("PS2603-00001")
%Order{id: "PS2603-00001", customer_name: "Budi", status: "dikemas", ...}

iex> Lababersih.Inventory.list_products(org_id)
[%Product{name: "Forbest", stok: 100}, ...]

iex> Lababersih.Accounting.trial_balance(org_id)
%{total_debit: #Decimal<5516585336>, total_credit: #Decimal<5516585336>, balanced: true}

# Bahkan bisa connect ke PRODUCTION server yang sedang jalan!
# (Fly.io: fly ssh console)

Immutability — Data Gak Bisa Diubah Diam-Diam

Di Elixir, semua data immutable (gak bisa diubah setelah dibuat). Kalau mau ubah, harus bikin salinan baru.

# JavaScript (v1) — mutable, BAHAYA:
order.status = "dikirim"     # langsung ubah object asli
# Siapa yang ubah? Kapan? Gak ada record.

# Elixir (v2) — immutable, AMAN:
new_order = %{order | status: "dikirim"}
# order asli GAK BERUBAH. new_order = salinan dengan status baru.
# Kalau ada bug, order asli masih intact.

Kenapa ini penting untuk LabaBersih:

• ship_order = 5 langkah atomic. Kalau langkah 4 gagal, data dari langkah 1-3 gak corrupt karena belum di-commit ke database (immutable sampai Repo.transaction selesai)
• FEFO lot consumption = consume lot satu-satu. Kalau di tengah jalan stok gak cukup, semua rollback. Lot yang sudah "di-consume" di memory balik seperti semula.
• Concurrent access = 2 orang ship order bersamaan, gak bisa overwrite data satu sama lain

Pattern Matching — Preview

Ini akan dibahas mendalam di Bab 2, tapi preview karena ini yang bikin Elixir sangat readable:

# Status transition di LabaBersih v2 (Elixir)
def advance_order_status("dibuat"),    do: {:ok, "diproses"}
def advance_order_status("diproses"),  do: {:ok, "selesai"}
def advance_order_status("selesai"),   do: {:error, "sudah selesai"}
def advance_order_status(status),      do: {:error, "status #{status} gak bisa maju"}

# Baca dari atas ke bawah:
# - "dibuat" → boleh maju ke "diproses"
# - "diproses" → boleh maju ke "selesai"
# - "selesai" → GAK BOLEH maju (sudah final)
# - status lain → GAK BOLEH
#
# Gak ada if-else. Gak ada switch-case. Cuma pattern matching.
# Kamu bisa BACA ini dan langsung paham business rule-nya.

function advanceStatus(status) {
  if (status === "dibuat") return "diproses"
  if (status === "diproses") return "selesai"
  if (status === "selesai") throw new Error("sudah selesai")
  throw new Error(`status ${status} gak bisa maju`)
}

def advance("dibuat"),    do: {:ok, "diproses"}
def advance("diproses"),  do: {:ok, "selesai"}
def advance("selesai"),   do: {:error, "sudah final"}
def advance(other),       do: {:error, "invalid"}

Perhatikan: Elixir gak pakai throw / exception. Semua error di-return sebagai {:error, reason}. Caller HARUS handle kedua case. Gak ada silent failure.

Ekosistem — Siapa Lagi yang Pakai

Elixir bukan bahasa eksperimen. Ini perusahaan yang pakai di production:

Risiko — Yang Harus Kamu Tau

Sebagai leader, kamu HARUS tau risikonya. Ini bukan bahasa sempurna.

Checklist Review — Pertanyaan yang Bisa Kamu Tanya

Setelah baca bab ini, kamu sekarang bisa tanya hal-hal ini ke Claude (atau developer manapun):

Ringkasan Bab 1