Rust adalah bahasa pemrograman modern yang dirancang untuk menghasilkan software cepat, aman, dan efisien. Rust menawarkan performa mendekati C/C++, tetapi dengan perlindungan memory safety yang diperiksa oleh compiler tanpa garbage collector.

1. Mengapa belajar Rust?

Rust cocok untuk system programming, backend, command-line tools, WebAssembly, networking, dan aplikasi yang membutuhkan performa tinggi. Compiler Rust memang lebih ketat, tetapi aturan tersebut membantu menemukan banyak bug sebelum program dijalankan.

Konsep utama yang perlu dipahami adalah ownership, borrowing, dan lifetime. Ketiganya mengatur siapa yang memiliki data, kapan data boleh dipakai, dan kapan data tetap valid.

2. Instalasi Rust dengan rustup

Cara yang direkomendasikan untuk memasang Rust adalah menggunakan rustup. Di Linux dan macOS, jalankan:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"

rustc --version
cargo --version

Di Windows, gunakan installer rustup-init.exe dari situs resmi Rust. Setelah instalasi, pastikan toolchain stable aktif:

rustup show
rustup update stable

Selalu unduh installer dari sumber resmi dan periksa kebijakan keamanan organisasi sebelum menjalankan script remote.

3. Membuat project pertama dengan Cargo

Cargo adalah package manager sekaligus build tool bawaan Rust. Buat project baru dengan perintah:

cargo new hello-rust
cd hello-rust
cargo run

Cargo membuat file Cargo.toml untuk metadata dan dependency, serta folder src yang berisi main.rs. Isi awalnya:

fn main() {
    println!("Halo, Rust!");
}

Gunakan cargo check untuk memeriksa kode dengan cepat, cargo build untuk membuat binary debug, dan cargo build --release untuk build yang dioptimalkan.

4. Variable, mutability, dan tipe data

Variable di Rust immutable secara default. Gunakan mut hanya ketika nilai memang perlu diubah:

fn main() {
    let name = "Afry";
    let mut counter = 0;
    counter += 1;

    println!("{} sudah dihitung {} kali", name, counter);
}

Rust memiliki tipe scalar seperti integer, float, boolean, dan character, serta tipe compound seperti tuple dan array. Compiler biasanya dapat menyimpulkan tipe, tetapi anotasi eksplisit berguna ketika konteksnya tidak jelas.

5. Ownership dan borrowing

Setiap nilai di Rust memiliki owner. Ketika owner keluar dari scope, resource yang dimiliki akan dibersihkan otomatis. Aturan ini mencegah double free dan banyak bug memory lainnya.

fn panjang(text: &String) -> usize {
    text.len()
}

fn main() {
    let message = String::from("Belajar Rust");
    println!("Panjang: {}", panjang(&message));
    println!("Masih bisa dipakai: {}", message);
}

Tanda & membuat reference sehingga function meminjam data tanpa mengambil ownership. Secara umum, Rust mengizinkan banyak immutable reference atau satu mutable reference pada satu waktu, bukan keduanya secara bersamaan.

6. Struct, enum, dan pattern matching

Gunakan struct untuk membentuk data dengan field yang jelas:

struct User {
    name: String,
    active: bool,
}

fn status(user: &User) -> &str {
    if user.active { "aktif" } else { "nonaktif" }
}

Enum berguna untuk merepresentasikan beberapa kemungkinan. Pattern matching dengan match membantu memastikan setiap kemungkinan ditangani:

enum Role {
    Admin,
    Member,
}

fn label(role: Role) -> &'static str {
    match role {
        Role::Admin => "administrator",
        Role::Member => "anggota",
    }
}

7. Result dan Option untuk error handling

Rust tidak menggunakan exception sebagai mekanisme utama. Nilai Option merepresentasikan data yang mungkin ada atau tidak, sedangkan Result merepresentasikan operasi yang berhasil atau gagal.

fn bagi(a: f64, b: f64) -> Result {
    if b == 0.0 {
        Err("pembagi tidak boleh nol".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match bagi(10.0, 2.0) {
        Ok(value) => println!("Hasil: {}", value),
        Err(error) => eprintln!("Error: {}", error),
    }
}

Gunakan operator ? di function yang mengembalikan Result agar error dapat diteruskan dengan ringkas dan tetap eksplisit.

8. Dependency dan testing

Tambahkan library melalui Cargo, bukan dengan menyalin source secara manual. Periksa versi dependency dan commit Cargo.lock untuk aplikasi yang dapat dieksekusi.

cargo add serde
cargo add serde_json
cargo test
cargo fmt --check
cargo clippy -- -D warnings

Rust mendukung unit test di dalam module dan integration test di folder tests. Jalankan format, lint, dan test di CI agar kualitas tetap konsisten.

9. Build dan deployment

Untuk binary production:

cargo build --release
./target/release/hello-rust

Gunakan multi-stage Docker build bila perlu membuat image kecil. Pisahkan konfigurasi dari binary, jangan menanamkan secret ke source code, dan gunakan logging yang tidak membocorkan data sensitif.

10. Tips belajar Rust

  • Pelajari ownership melalui contoh kecil, bukan dengan menghindari borrow checker.
  • Gunakan dokumentasi resmi dan Rustlings untuk latihan bertahap.
  • Biasakan membaca pesan error compiler karena biasanya berisi saran perbaikan.
  • Mulai dari CLI sederhana sebelum membangun service kompleks.
  • Gunakan test, formatter, dan Clippy sejak awal.

Kesimpulan

Rust membutuhkan cara berpikir yang sedikit berbeda, terutama tentang ownership dan borrowing. Namun setelah konsep tersebut dikuasai, Rust membantu menghasilkan program yang cepat dan aman dengan banyak bug terdeteksi saat compile time. Mulailah dengan Cargo, latihan kecil, error handling yang eksplisit, dan kebiasaan testing yang konsisten.