Kompilasi satu berkas dengan rustc memang cukup untuk program tiga baris, tetapi proyek nyata menuntut lebih dari itu: struktur folder yang konsisten, pencatatan dependency, proses build yang dapat diulang, dan binary yang mudah dijalankan ulang. Cargo adalah perkakas resmi Rust yang menangani seluruh kebutuhan tersebut dalam satu perintah. Pada Chapter ini kita akan membuat proyek pertama dengan cargo, membedah strukturnya, menjalankan program, dan memeriksa kode tanpa harus menghasilkan binary.

Mengenal Cargo #

Cargo berperan ganda: sebagai build system yang mengompilasi kode, dan sebagai package manager yang mengunduh library (disebut crate) dari registry publik crates.io. Kedua peran tersebut menyatu dalam satu perintah cargo yang sudah terpasang bersama rustup pada Chapter sebelumnya. Hampir seluruh proyek Rust di dunia — dari skrip kecil hingga sistem produksi — dikelola oleh cargo, sehingga memahami pola kerjanya sejak awal adalah investasi jangka panjang.

Alur kerja dasar cargo berlangsung dalam empat perintah: cargo new membuat proyek, cargo build mengompilasi, cargo run mengompilasi lalu menjalankan, dan cargo check memeriksa galat tanpa menghasilkan binary. Kita akan mencicipi keempatnya secara berurutan.

Membuat Proyek Baru #

Pindah ke folder tempat kita menyimpan proyek (misalnya ~/projects atau /tmp), lalu jalankan perintah berikut:

bash 
cargo new hello_cargo

Output yang Dihasilkan:

text 
    Creating binary (application) `hello_cargo` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

Perintah tersebut membuat folder hello_cargo berisi proyek Rust lengkap. Kata binary pada baris pertama menandakan jenis paket yang dihasilkan: program yang dapat dieksekusi. Jenis kedua, library, akan kita pelajari saat mulai menulis crate untuk dipakai orang lain. Isi folder proyek tersebut dapat kita lihat dengan ls:

bash 
ls hello_cargo
ls hello_cargo/src

Output yang Dihasilkan:

text 
Cargo.toml
src
main.rs

Folder proyek memuat dua item inti: berkas Cargo.toml di akar proyek dan folder src yang berisi main.rs.

Membaca Struktur Proyek #

Berikut isi Cargo.toml yang dihasilkan cargo secara otomatis:

text 
[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

Berkas ini disebut manifest karena mendeskripsikan identitas proyek kita. Mari kita bedah arti setiap bagian:

  1. Baris [package]: membuka tabel metadata paket — nama, versi, dan edition yang dimiliki proyek.
  2. Baris name = "hello_cargo": nama paket sekaligus nama binary yang akan dihasilkan. Nama ini juga menjadi identitas paket ketika dipublikasikan ke crates.io.
  3. Baris version = "0.1.0": nomor versi proyek mengikuti pola SemVer. Cargo menulis 0.1.0 sebagai titik awal yang lazim bagi proyek baru.
  4. Baris edition = "2024": edition bahasa yang dipakai proyek. Edition mengatur aturan bahasa mana yang aktif; angka ini berbeda makna dari versi kompilator.
  5. Bagian [dependencies]: daftar crate eksternal yang dipakai proyek. Bagian ini masih kosong karena program kita belum membutuhkan library apa pun.

Selanjutnya, seluruh kode sumber Rust wajib berada di dalam folder src. Cargo mengenali src/main.rs sebagai titik masuk program binary. Isi bawaannya adalah program halo dunia:

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

Struktur folder sumber ini bukan gaya selera; cargo mengandalkan konvensi tersebut untuk menemukan kode, dan konvensi yang sama dipakai semua proyek Rust sehingga kita selalu tahu ke mana harus melihat.

Menjalankan Program dengan cargo run #

Masuk ke folder proyek, lalu jalankan:

bash 
cd hello_cargo
cargo run

Output yang Dihasilkan:

text 
   Compiling hello_cargo v0.1.0 (/tmp/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.10s
     Running `target/debug/hello_cargo`
Hello, world!

Tiga baris pertama adalah laporan kerja cargo: mengompilasi paket, menyelesaikan proses build dengan profil dev, lalu menjalankan binary yang terletak di target/debug/hello_cargo. Baris terakhir adalah output program itu sendiri. Lokasi path dan durasi proses akan berbeda di komputer kita; yang penting adalah urutan kejadian: compile dulu, lalu run.

Sekarang kita ubah isi src/main.rs menjadi program yang sedikit lebih hidup:

rust 
fn main() {
    let buyer = "Siti";
    let quantity = 3;
    let unit_price = 45000;
    let total = quantity * unit_price;

    println!("Pembeli: {}", buyer);
    println!("Total belanja: Rp{}", total);
}

Jalankan cargo run sekali lagi:

text 
   Compiling hello_cargo v0.1.0 (/tmp/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/hello_cargo`
Pembeli: Siti
Total belanja: Rp135000

Mari kita telaah program di atas baris demi baris:

  1. Baris 2 (let buyer = "Siti";): membuat variable buyer berisi teks nama pembeli.
  2. Baris 3 (let quantity = 3;): menyimpan jumlah barang sebagai bilangan bulat.
  3. Baris 4 (let unit_price = 45000;): menyimpan harga satuan dalam bilangan bulat rupiah.
  4. Baris 5 (let total = quantity * unit_price;): menghitung hasil kali quantity dan unit_price (135000), lalu menyimpannya ke variable total.
  5. Baris 7 (println!("Pembeli: {}", buyer);): mencetak label dan isi variable buyer; placeholder {} digantikan nilai "Siti".
  6. Baris 8 (println!("Total belanja: Rp{}", total);): mencetak total belanja dengan cara yang sama, hasilnya Rp135000.

Saat file berubah, cargo mendeteksi perubahan dan mengompilasi ulang sebelum menjalankan. Ketika file tidak berubah, cargo melewati kompilasi dan langsung menjalankan binary yang sudah ada — prosesnya selesai dalam hitungan milidetik.

Memeriksa Kode dengan cargo check #

Selama menulis kode, kita sering hanya ingin tahu apakah program masih lolos pemeriksaan kompilator tanpa perlu menghasilkan binary. Untuk itu cargo menyediakan cargo check:

bash 
cargo check

Output yang Dihasilkan:

text 
    Checking hello_cargo v0.1.0 (/tmp/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s

Perhatikan kata Checking menggantikan Compiling. Perintah ini menjalankan pemeriksaan tipe dan analisis kode secara penuh, tetapi melewati tahap penerjemahan ke machine code sehingga lebih cepat. Kabar baiknya: semua galat yang bisa ditangkap cargo build juga bisa ditangkap cargo check.

Ringkasan #

Cargo membungkus seluruh siklus hidup proyek Rust: cargo new membuat kerangka proyek dengan manifest dan folder src, cargo run mengompilasi lalu menjalankan program, dan cargo check memeriksa galat dengan cepat tanpa menghasilkan binary. Struktur konvensinya seragam di seluruh ekosistem Rust. Dengan proyek pertama yang sudah hidup, kita siap membedah setiap bagian program Rust pada Chapter berikutnya.