Lewati ke konten
Ferris the Rust crabTutorial Rust

Rust vs C++, Go, dan Python

“Sebaiknya aku belajar Rust, Go, atau tetap di Python?” adalah salah satu pertanyaan paling umum dari orang yang baru mengenal Rust. Jawaban jujurnya: tergantung apa yang ingin kamu bangun. Semua bahasa di halaman ini adalah bahasa yang bagus dan dipakai jutaan orang. Masing-masing hanya memilih kompromi yang berbeda.

Bayangkan bahasa pemrograman seperti kendaraan. Mobil sport, mobil boks, dan sepeda semuanya “bagus”. Hanya saja, kamu tidak akan memakai sepeda untuk pindahan rumah. Halaman ini menjelaskan kompromi-kompromi itu dengan bahasa sederhana, supaya kamu bisa memilih alat yang tepat untuk pekerjaanmu. Kami akan berusaha adil, termasuk soal kelemahan Rust.

Keunggulan Rust

Section titled “Keunggulan Rust”

Janji utama Rust adalah cepat dan aman sekaligus:

  • Cepat, seperti C dan C++. Rust di-compile menjadi kode mesin native dan tidak punya garbage collector, jadi tidak ada jeda saat memori dibersihkan.
  • Aman secara memori tanpa garbage collector. Aturan ownership (kepemilikan) dan borrowing (peminjaman) dicek saat compile. Banyak jenis bug sekaligus (memakai memori yang sudah dibebaskan, data race antar-thread) sudah ditolak sebelum programnya sempat berjalan.
  • Tooling bagus langsung dari awal. Satu tool, Cargo, bisa mem-build kodemu, mengunduh library, menjalankan test, dan membuat dokumentasi. Formatter (rustfmt) dan linter (clippy) juga resmi.
  • Pesan error compiler yang membantu. Compiler sering memberi tahu persis bagaimana cara memperbaiki masalahnya.

Para developer juga tampaknya menikmatinya: di Stack Overflow Developer Survey 2025 (bahasa Inggris), Rust kembali menjadi bahasa pemrograman yang “paling dikagumi”, artinya kebanyakan orang yang memakainya ingin terus memakainya.

Tugas yang sama dalam empat bahasa

Section titled “Tugas yang sama dalam empat bahasa”

Kita mulai dari yang kecil: menjumlahkan bilangan genap dalam sebuah daftar. Ini versi Rust-nya:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum: i32 = numbers.iter().filter(|n| *n % 2 == 0).sum();
    println!("Jumlah bilangan genap: {sum}");
}

Output:

Jumlah bilangan genap: 12
▶ Coba sendiri

Program yang sama dalam C++:

#include <iostream>
#include <vector>


int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    int sum = 0;
    for (int n : numbers) {
        if (n % 2 == 0) {
            sum += n;
        }
    }
    std::cout << "Jumlah bilangan genap: " << sum << "\n";
}

Dalam Go:

package main


import "fmt"


func main() {
  numbers := []int{1, 2, 3, 4, 5, 6}
  sum := 0
  for _, n := range numbers {
    if n%2 == 0 {
      sum += n
    }
  }
  fmt.Println("Jumlah bilangan genap:", sum)
}

Dan dalam Python:

numbers = [1, 2, 3, 4, 5, 6]
total = sum(n for n in numbers if n % 2 == 0)
print("Jumlah bilangan genap:", total)

Keempatnya mencetak baris yang sama. Python paling pendek, Go dan C++ memakai perulangan biasa, sedangkan Rust memakai rangkaian iterator dengan sebuah closure (fungsi kecil tanpa nama), meskipun di Rust kamu juga bisa menulis perulangan for. Untuk program kecil seperti ini, perbedaannya kebanyakan cuma soal gaya. Perbedaan yang sesungguhnya baru terlihat di program yang lebih besar.

Rust vs C++

Section titled “Rust vs C++”

C++ dan Rust menyasar bidang yang sama: program cepat dengan kendali penuh atas memori, seperti browser, game engine, database, dan sistem operasi. Perbedaan besarnya adalah siapa yang memastikan memori dipakai dengan benar.

Di C++, itu tugasmu. Ini contoh bug klasik. Compiler C++ menerima kode ini tanpa protes, padahal push_back bisa memindahkan vektor ke lokasi memori baru, sehingga first bisa menunjuk ke memori yang sudah dibebaskan:

std::vector<int> v = {1, 2, 3};
int& first = v[0];
v.push_back(4);              // bisa memindahkan memori vektornya...
std::cout << first << "\n";  // ...jadi baris ini bisa membaca memori yang sudah dibebaskan

Kesalahan yang sama di Rust tidak bisa di-compile:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);
    println!("{first}");
}
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(4);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

Compiler menjelaskan (dalam bahasa Inggris) bahwa v tidak bisa dipinjam sebagai mutable (untuk diubah) karena sedang dipinjam sebagai immutable oleh first, dan first masih dipakai sesudahnya.

Dalam praktik, hal ini sangat penting. Tim Chromium melaporkan bahwa sekitar 70% bug keamanan serius mereka adalah masalah keamanan memori (bahasa Inggris). Tim Android di Google sudah menulis kode baru dengan Rust selama beberapa tahun. Mereka melaporkan nol kerentanan keamanan memori yang ditemukan di kode Rust Android (bahasa Inggris) pada tahun 2022, dan pada tahun 2025 kepadatan kerentanan keamanan memori yang lebih dari 1000 kali lebih rendah dibandingkan kode C dan C++ mereka (bahasa Inggris). Kernel Linux (bahasa Inggris) juga mendukung kode yang ditulis dengan Rust.

Tooling: C++ punya banyak build system dan package manager, dan tim sering menghabiskan waktu yang tidak sedikit hanya untuk setup. Rust punya satu tool standar, Cargo, jadi setiap proyek Rust di-build dengan cara yang sama.

Kurva belajar: keduanya sulit. C++ sangat besar, dan banyak aturannya baru dipelajari setelah membuat kesalahan saat runtime. Aturan Rust memang ketat, tapi compiler yang menegakkan dan menjelaskannya, jadi kamu mempelajarinya saat compile.

Di mana C++ masih unggul: puluhan tahun kode yang sudah ada, library, dan developer berpengalaman. Kalau perusahaanmu atau game engine-mu dibangun di atas C++, C++ sering menjadi pilihan yang paling praktis. Rust bisa memanggil kode C, dan juga C++ lewat antarmuka bergaya C, tapi mencampurkan keduanya butuh usaha.

Rust vs Go

Section titled “Rust vs Go”

Go dan Rust sering dibandingkan karena keduanya modern, di-compile, dan populer untuk server serta tool command line. Tapi keduanya dirancang dengan tujuan yang berbeda.

Garbage collection vs ownership. Go memakai garbage collector (bahasa Inggris) yang mencari dan membebaskan memori yang tidak terpakai saat programmu berjalan. Itu membuat kode Go lebih sederhana untuk ditulis: kamu tidak pernah perlu memikirkan siapa pemilik sebuah nilai. Harganya adalah sedikit memori dan CPU tambahan, serta jeda-jeda singkat. Rust tidak punya garbage collector. Memori dibebaskan pada titik yang jelas, yaitu saat pemiliknya keluar dari scope (cakupan). Hasilnya performa lebih bisa diprediksi, tapi kamu harus mempelajari ownership dan borrowing.

Konkurensi. Goroutine dan channel di Go terkenal mudah dipakai. Ini contoh kecil yang mengkuadratkan tiga angka secara paralel lalu menjumlahkannya:

results := make(chan int)


for n := 1; n <= 3; n++ {
  go func() {
    results <- n * n
  }()
}


total := 0
for i := 0; i < 3; i++ {
  total += <-results
}
fmt.Println("total:", total)

Versi Rust-nya memakai thread dan sebuah channel. Kodenya sedikit lebih panjang: kamu meng-clone pengirim (sender) untuk setiap thread dan memakai move:

use std::sync::mpsc;
use std::thread;


fn main() {
    let (tx, rx) = mpsc::channel();


    for n in 1..=3 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(n * n).unwrap();
        });
    }
    drop(tx); // tutup salinan milik kita supaya perulangan di bawah bisa selesai


    let total: i32 = rx.iter().sum();
    println!("total: {total}");
}

Output:

total: 14
▶ Coba sendiri

Apa yang kamu dapat dari ketikan tambahan itu: Rust menolak meng-compile kode di mana dua thread bisa mengubah data yang sama secara bersamaan (disebut data race). Di Go, data race masih mungkin terjadi; Go menyediakan race detector (bahasa Inggris) yang menemukannya saat program berjalan. Lihat Konkurensi untuk penjelasan lebih lanjut.

Waktu compile. Go memang dibuat supaya cepat di-compile. FAQ-nya menyebutkan bahwa mem-build executable yang besar seharusnya hanya butuh paling lama beberapa detik (bahasa Inggris). Rust lebih lambat di-compile, karena compiler-nya melakukan jauh lebih banyak pengecekan dan optimasi. Kamu akan merasakannya di proyek-proyek besar.

Kesederhanaan. Go sengaja dibuat sebagai bahasa yang kecil, dengan sedikit fitur untuk dipelajari, sehingga banyak orang merasa bisa membaca kode Go dengan cepat. Rust punya lebih banyak fitur (trait, generics, lifetime, makro), yang memberi kekuatan lebih tapi butuh waktu lebih lama untuk dipelajari.

Rust vs Python

Section titled “Rust vs Python”

Python dan Rust sangat berbeda, dan keduanya sering dipakai bersama-sama, bukan saling menggantikan.

Kecepatan. Python adalah bahasa yang diinterpretasi, jadi kode Python murni yang banyak melakukan komputasi jauh lebih lambat daripada kode yang di-compile. Itulah sebabnya library Python yang populer sering mengerjakan bagian beratnya dengan C, C++, atau Rust di balik layar.

Pengecekan tipe. Di Python, tipe dicek saat program berjalan. Fungsi ini bekerja untuk angka dan gagal untuk string, tapi kamu baru tahu saat baris itu dijalankan:

def add_tax(price):
    return price * 1.2


print(add_tax(10))    # 12.0
print(add_tax("10"))  # TypeError: can't multiply sequence by non-int of type 'float'

Python punya type hint yang opsional, tapi runtime Python tidak menegakkannya (bahasa Inggris). Di Rust, setiap tipe dicek sebelum program berjalan:

fn add_tax(price: f64) -> f64 {
    price * 1.2
}


fn main() {
    println!("{}", add_tax(10.0));
    println!("{}", add_tax("10"));
}
error[E0308]: mismatched types
 --> src/main.rs:7:28
  |
7 |     println!("{}", add_tax("10"));
  |                    ------- ^^^^ expected `f64`, found `&str`
  |                    |
  |                    arguments to this function are incorrect

Artinya: tipenya tidak cocok. Fungsi ini mengharapkan f64, tapi yang diberikan adalah &str (sebuah teks).

Kapan Python masih jadi alat yang lebih baik: script cepat, analisis data, machine learning, notebook, otomasi, dan mengajar pemula. Ekosistem Python untuk data science sangat besar, dan kamu bisa mencoba sebuah ide dalam hitungan menit. Kalau programmu lebih banyak menunggu jaringan atau database, kecepatan Python sering tidak jadi masalah.

Memakai keduanya: proyek PyO3 (bahasa Inggris) memungkinkanmu menulis modul Python dengan Rust, jadi kamu bisa tetap memakai kode Python-mu dan hanya memindahkan bagian yang lambat ke Rust. Beberapa tool Python yang populer bahkan ditulis dengan Rust; misalnya, survei Stack Overflow mencatat bahwa package manager Python uv dibangun dengan Rust (bahasa Inggris).

Perbandingan berdampingan

Section titled “Perbandingan berdampingan”

Ini kecenderungan umum, bukan aturan mutlak. Program yang ditulis dengan baik dalam bahasa mana pun bisa “cukup cepat”.

Rust C++ Go Python
Kecepatan Sangat cepat, kode native, tanpa GC Sangat cepat, kode native, tanpa GC Cepat, kode native dengan GC Lebih lambat untuk komputasi berat dengan Python murni
Keamanan memori Dicek saat compile (di luar unsafe) Tanggung jawab programmer GC; data race masih mungkin terjadi GC; aman, tapi error tipe baru muncul saat runtime
Kurva belajar Curam di awal Curam, dan bahasanya sangat besar Landai Paling landai
Waktu compile Agak lambat Agak lambat (tergantung proyek) Sangat cepat Tidak ada tahap compile
Ekosistem Lebih muda, terus berkembang; Cargo sudah bawaan Sangat besar dan matang; banyak build tool Standard library yang kuat, bagus untuk server Sangat besar, terutama untuk data dan ML
Penggunaan umum Tool CLI, server, kode sistem, WebAssembly, embedded Game, browser, sistem berperforma tinggi dan sistem lama Web service, tool cloud dan DevOps Scripting, data science, ML, otomasi

Kapan sebaiknya memilih Rust?

Section titled “Kapan sebaiknya memilih Rust?”

Tanyakan hal-hal ini pada dirimu sendiri:

  • Apakah kamu butuh kecepatan maksimal atau pemakaian memori yang kecil, misalnya untuk game engine, database, atau kode di perangkat kecil? Rust (atau C++) adalah pilihan yang kuat.
  • Apakah bug akan berakibat mahal? Kode yang sensitif terhadap keamanan, server yang berjalan lama, dan kode yang diandalkan banyak orang paling diuntungkan oleh pengecekan Rust saat compile.
  • Apakah kamu membuat tool command line yang ingin kamu bagikan? Rust menghasilkan satu binary cepat tanpa runtime yang perlu diinstal. Go juga sangat bagus untuk ini.
  • Apakah kamu butuh web service dengan cepat, bersama tim yang belum mengenal bahasa-bahasa ini? Go mungkin akan membawamu ke sana lebih cepat. Rust juga bisa dipakai dengan baik (lihat Proyek: Web API), tapi waktu belajarnya lebih lama.
  • Apakah ini script cepat, analisis data, atau eksperimen ML? Pakai Python. Gunakan Rust belakangan, lewat PyO3, kalau ada satu bagian yang jadi terlalu lambat.
  • Apakah sudah ada codebase C++ yang besar? Tetap pakai C++ untuk sekarang, atau perkenalkan Rust di bagian-bagian baru yang terpisah, seperti yang dilakukan Android.

Dan kalau kamu hanya ingin menjadi programmer yang lebih baik: belajar Rust mengajarkanmu bagaimana memori sebenarnya bekerja, dan pengetahuan itu berguna di bahasa apa pun.

Kekurangan Rust, secara jujur

Section titled “Kekurangan Rust, secara jujur”

Rust tidak sempurna. Ini hal-hal yang paling sering membuat orang kesulitan:

  • Kurva belajarnya memang nyata. Minggu-minggu pertama dengan borrow checker (bagian compiler yang mengecek aturan borrowing) bisa bikin frustrasi. Siap-siap “berkelahi dengan compiler” untuk sementara. Semuanya jadi jauh lebih mudah begitu ownership mulai terasa masuk akal.
  • Waktu compile lebih lambat daripada Go, terutama untuk proyek besar dan build release.
  • Beberapa hal lebih sulit diekspresikan. Data berbentuk graf dengan banyak hubungan antar-objek, atau kode yang berbagi banyak state yang bisa diubah, butuh alat seperti smart pointer dan perencanaan yang lebih matang.
  • Ekosistemnya lebih muda. Untuk beberapa bidang (aplikasi GUI, library ilmiah tertentu), pilihan yang matang lebih sedikit dibandingkan C++ atau Python.
  • Penggunanya lebih sedikit (untuk saat ini). Di survei Stack Overflow 2025 (bahasa Inggris), jauh lebih banyak responden yang mengaku memakai Python (sekitar 58%) atau C++ (sekitar 24%) dibandingkan Rust (sekitar 15%). Artinya, lebih sedikit developer Rust berpengalaman yang bisa direkrut, ditanyai, atau dijadikan tempat belajar di kantor.
  • Lebih banyak kode untuk hal-hal sederhana. Seperti yang terlihat di contoh channel, Rust sering memintamu menulis secara eksplisit hal-hal yang di bahasa lain dibiarkan longgar.

Ringkasan

Section titled “Ringkasan”
  • Rust memberi kecepatan setara C++ dengan keamanan memori yang dicek saat compile, plus tooling bawaan yang sangat bagus.
  • Dibandingkan C++, Rust mencegah banyak jenis bug memori sebelum program berjalan; C++ punya jauh lebih banyak kode dan library yang sudah ada.
  • Dibandingkan Go, Rust tidak punya garbage collector dan menghentikan data race saat compile; Go lebih sederhana dan jauh lebih cepat di-compile.
  • Dibandingkan Python, Rust jauh lebih cepat dan mengecek tipe sebelum program berjalan; Python lebih cepat ditulis dan mendominasi data science. PyO3 memungkinkanmu menggabungkan keduanya.
  • Harga utama Rust adalah kurva belajar yang curam, compile yang lebih lambat, dan ekosistem yang lebih muda.

Kuis singkat

Section titled “Kuis singkat”

Kuis singkat

1. Bagaimana Rust mengelola memori tanpa garbage collector?

2. Manakah yang merupakan keunggulan Go dibandingkan Rust secara adil?

3. Kamu punya program Python yang salah satu fungsinya terlalu lambat. Apa pendekatan yang umum?

4. Di contoh C++ vs Rust, apa yang terjadi pada kode yang menyimpan &v[0] lalu menambahkan elemen ke v?

Skor: 0 / 4

Bacaan lebih lanjut

Section titled “Bacaan lebih lanjut”