Belajar Rust dari Nol, Memahami Dasar Pemrograman Rust untuk Pemula - PART 1

Belajar Rust dari nol tidak harus dimulai dengan memahami seluruh konsep yang membuat bahasa ini terkenal, seperti ownership, borrowing, lifetime, atau concurrency. Sebelum sampai ke sana, ada satu tahap yang jauh lebih penting: mengenal Rust dan memahami bagaimana sebuah project Rust dibuat serta dijalankan.

Series ini akan membahas Rust secara bertahap dengan pendekatan learning by doing. Artinya, kita tidak hanya membaca teori, tetapi langsung membuat project, menulis kode, menjalankannya, kemudian melihat bagaimana compiler Rust merespons kode yang kita buat.

Pada bagian pertama ini, fokusnya masih sederhana. Kita akan mengenal Rust secara singkat, melihat perbedaannya dengan bahasa yang mungkin sudah familiar, kemudian mulai membuat project pertama menggunakan Cargo.

Apa Itu Rust?

Rust adalah bahasa pemrograman systems programming yang dirancang dengan fokus pada performa dan keamanan memory. Salah satu karakteristik yang membedakannya dari banyak bahasa modern adalah Rust tidak menggunakan Garbage Collector untuk mengelola memory.

Rust menggunakan sistem ownership yang diperiksa oleh compiler. Konsep tersebut memungkinkan banyak aturan keamanan memory diperiksa sebelum program dijalankan. Namun, ownership bukan materi yang akan kita bedah pada bagian pertama ini.

Justru salah satu tujuan series ini adalah membawa konsep tersebut secara bertahap. Kita mulai dari syntax dan tooling terlebih dahulu, kemudian perlahan masuk ke bagian yang membuat Rust terasa berbeda.

Rust untuk Programmer yang Sudah Mengenal Java

Modul pembelajaran ini memang dirancang dengan pendekatan perbandingan antara Rust dan Java. Tujuannya bukan mengatakan bahwa Rust dan Java sama, tetapi memberikan titik referensi bagi programmer yang sudah mengenal Java.

Di Java, program berjalan melalui JVM dan proses eksekusinya berkaitan dengan bytecode serta JIT compilation. Rust memiliki model yang berbeda karena kode dikompilasi menjadi native machine code.

Perbedaan juga terlihat dari tooling. Jika ekosistem Java sangat familiar dengan Maven atau Gradle, Rust memiliki Cargo sebagai tool utama untuk membuat project, melakukan build, menjalankan program, mengelola dependency, hingga menjalankan test.

Java	Rust
JVM	Native binary
javac	rustc
Maven / Gradle	Cargo
pom.xml / build.gradle	Cargo.toml
Main.java	main.rs

Perbandingan ini akan menjadi salah satu pola yang digunakan sepanjang series. Ketika menemukan konsep Rust yang terasa asing, kita akan mencoba melihat apakah ada konsep yang sudah dikenal dari bahasa lain sebagai pembanding.

Rust Tidak Dimulai dari Framework

Kalau tujuan akhirnya adalah membuat backend atau API dengan Rust, mungkin muncul pertanyaan: kenapa tidak langsung menggunakan framework seperti Axum atau Actix Web?

Karena framework sebaiknya datang setelah kita memahami bahasa yang digunakan.

Dalam series ini, kita akan memulai dari Rust tanpa framework. Kita akan melihat terlebih dahulu bagaimana project Rust bekerja, bagaimana kode dikompilasi, bagaimana program dijalankan, dan bagaimana Cargo membantu proses development.

Setelah fondasinya terbentuk, barulah pembahasan bisa berkembang menuju konsep Rust yang lebih dalam dan akhirnya digunakan untuk membuat project yang lebih nyata.

Mengenal rustup dan Cargo

Untuk mulai menggunakan Rust, kita akan bertemu dengan dua nama yang sangat penting: rustup dan Cargo.

rustup digunakan untuk mengelola toolchain Rust. Sementara itu, Cargo adalah tool yang digunakan untuk membuat dan mengelola project Rust.

Setelah Rust terpasang, dua command sederhana berikut dapat digunakan untuk memastikan compiler dan Cargo sudah tersedia:

rustc --version
cargo --version

Jika keduanya memberikan informasi versi, environment dasar Rust sudah siap digunakan.

Membuat Project Rust Pertama

Berbeda dengan membuat satu file program secara manual, cara yang umum digunakan untuk memulai aplikasi Rust adalah melalui Cargo.

Project pertama dapat dibuat menggunakan command:

cargo new hello_rust

Kemudian masuk ke directory project tersebut:

cd hello_rust

Dan jalankan program dengan:

cargo run

Cargo akan membuat struktur project dasar secara otomatis:

hello_rust/
├── Cargo.toml
├── Cargo.lock
└── src/
    └── main.rs

Kalau Anda berasal dari Java, struktur ini bisa terasa cukup familiar. Cargo.toml berperan sebagai konfigurasi project dan dependency, sedangkan src/main.rs menjadi tempat program utama ditulis.

Hello, World!

Project yang baru dibuat Cargo sudah memiliki program sederhana untuk dijalankan. Bentuk paling dasar program Rust adalah:

fn main() {
    println!("Hello, World!");
}

Di sinilah kita mulai melihat bahwa Rust memiliki syntax yang berbeda dari Java.

Tidak ada class Main yang membungkus fungsi tersebut. Fungsi main dapat berada langsung di level file. Sementara println! menggunakan tanda seru karena yang digunakan adalah macro, bukan function biasa.

Untuk programmer Java, perbedaannya terlihat cukup jelas jika dibandingkan dengan program Hello, World! pada Java:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Programnya sama-sama sederhana, tetapi struktur bahasa dan cara menjalankannya berbeda.

Cargo Bukan Sekadar Menjalankan Program

Salah satu hal yang akan sering digunakan selama belajar Rust adalah Cargo. Tool ini bukan hanya digunakan untuk menjalankan program.

Command	Fungsi
cargo new	Membuat project baru
cargo run	Compile dan menjalankan program
cargo build	Melakukan build project
cargo check	Memeriksa error tanpa melakukan full compilation
cargo test	Menjalankan test

Untuk tahap awal, Anda tidak perlu menghafalkan semuanya. Cukup mulai dengan tiga command:

cargo new
cargo run
cargo check

Seiring project semakin besar, command Cargo lainnya akan mulai terasa berguna.

Compiler Rust Akan Menjadi Bagian dari Proses Belajar

Belajar Rust bukan hanya tentang mengetahui syntax. Salah satu kebiasaan yang perlu dibangun sejak awal adalah membaca pesan error dari compiler.

Rust memang dikenal memiliki compiler yang cukup ketat. Kode yang tidak sesuai dengan aturan bahasa dapat dihentikan sebelum program berhasil dijalankan.

Dalam konteks belajar, hal ini justru bisa dimanfaatkan. Ketika program gagal dikompilasi, jangan buru-buru mencari cara untuk membungkam error tersebut. Baca pesan yang diberikan compiler dan cari tahu mengapa kode tersebut ditolak.

Pendekatan learning by doing dalam modul ini memang mendorong proses tersebut: tulis kode sendiri, jalankan, ubah sedikit, kemudian perhatikan respons compiler.

Apa yang Akan Kita Pelajari Setelah Ini?

Bagian pertama ini baru membuka pintu. Kita belum masuk ke bagian Rust yang biasanya membuat programmer dari bahasa lain mulai berpikir dengan cara yang berbeda.

Setelah project pertama berhasil dibuat dan dijalankan, pembahasan berikutnya akan mulai masuk ke cara Rust menangani variabel, tipe data, dan mutability.

Dari sana, kita akan mulai melihat beberapa aturan Rust yang berbeda dari bahasa seperti Java. Variabel di Rust, misalnya, memiliki perilaku default yang berbeda terkait perubahan nilai.

Setelah fondasi syntax terbentuk, barulah perjalanan berlanjut menuju function, control flow, collection, hingga konsep yang menjadi salah satu inti Rust: ownership dan borrowing.

Namun, bagian tersebut belum perlu dibahas sekarang.

Part 1: Mulai dari Nol

Belajar Rust dari nol bukan tentang seberapa cepat kita bisa membuat aplikasi kompleks. Yang lebih penting adalah membangun mental model secara bertahap.

Di Part 1, targetnya sederhana: mengenal Rust, menyiapkan environment, memahami peran rustc dan Cargo, membuat project pertama, lalu menjalankan program Hello, World!.

Setelah itu, kita akan mulai membongkar syntax Rust sedikit demi sedikit.

Part berikutnya akan masuk ke variabel, tipe data, dan mutability—dan di sinilah mulai terlihat bahwa Rust punya beberapa aturan yang cukup berbeda dibandingkan bahasa yang mungkin sudah Anda gunakan sebelumnya.