Carbon versus Rust

Topik ini membandingkan dua pendekatan keamanan memori pada waktu kompilasi secara adil, yaitu borrow checker Rust yang sudah berjalan bertahun-tahun dan checked pointer yang dirancang Carbon. Pembahasan mencakup aturan pemilikan dan pinjaman Rust, model keamanan Carbon versi desain beserta perbedaan rinciannya, serta tabel penyandingan yang menyebut kekuatan dan keterbatasan kedua bahasa. Seluruh klaim bersumber dari dokumen resmi masing-masing proyek, dan status implementasi dipisahkan dengan tegas dari desain yang baru dipublikasikan.

Model Rust: pemilikan dan aturan pinjaman#

Keamanan memori Rust dibangun di atas pemilikan (ownership) yang aturannya ditetapkan buku resmi bahasa tersebut, yaitu setiap nilai memiliki satu pemilik, hanya ada satu pemilik pada satu waktu, dan nilai dihapus ketika pemiliknya keluar dari lingkup. Peminjaman (borrowing) memperluasnya melalui referensi (reference), dengan dua aturan pada bab referensi, yaitu pada satu waktu hanya boleh ada satu referensi mutabel atau sejumlah referensi immutable, dan referensi harus selalu sah. Kedua kelompok aturan diperiksa borrow checker pada waktu kompilasi, sehingga program yang melanggarnya tidak pernah sampai dijalankan.

Model ini menjadi fondasi Rust sejak rilis 1.0 pada Mei 2015, dan pengumuman resminya menegaskan kombinasi kendali tingkat rendah atas kinerja dengan jaminan keamanan, yang dicapai tanpa pengumpul sampah maupun runtime. Program berikut melanggar aturan referensinya karena memegang dua referensi mutabel ke elemen yang sama pada waktu yang sama.

// tidak-dijalankan: rustc tidak tersedia di sandbox; diagnostik asli diperoleh dari rustc 1.99.0 di Compiler Explorer
fn main() {
    let mut data = vec![10, 20, 30];
    let a = &mut data[0];
    let b = &mut data[0];
    std::mem::swap(a, b);
}

error[E0499]: cannot borrow `data` as mutable more than once at a time
 --> <source>:4:18
  |
3 |     let a = &mut data[0];
  |                  ---- first mutable borrow occurs here
4 |     let b = &mut data[0];
  |                  ^^^^ second mutable borrow occurs here
5 |     std::mem::swap(a, b);
  |                    - first borrow later used here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0499`.

Keluaran di atas adalah diagnostik asli rustc 1.99.0 yang dieksekusi di Compiler Explorer, dan isinya menunjukkan bahwa kompilator Rust menolak program tersebut dengan error E0499, yaitu variabel dipinjam secara mutabel lebih dari satu kali, karena referensi a masih digunakan pada std::mem::swap ketika b dibuat. Pengecekan itu konsisten dengan aturan referensi di atas, dan dokumen error resmi mengutip aturan yang sama sebagai alasannya. Bagi pengembang C++, penolakan semacam ini terasa ketat, tetapi inilah konsekuensi yang diambil Rust agar use after free dan data race tertangkap sebelum program berjalan.

Model Carbon: pemeriksaan pada hasil migrasi#

Dokumen strategi keamanan Carbon menyatakan model keamanan memori Carbon pada tingkat tinggi sebagian besar menyamai Rust, yaitu keamanan temporal dan data race ditegakkan pada waktu kompilasi melalui sistem tipe, tanpa biaya pengumpul sampah. Penyimpangan yang disebut dokumen justru berada pada detail, dan dokumen yang sama merinci tiga di antaranya. Pertama, keamanan inisialisasi lebih banyak memanfaatkan teknik waktu jalan, misalnya inisialisasi otomatis dan semantik optional dinamis, demi kenyamanan penggunaan. Kedua, Carbon mengizinkan mutasi pada pointer yang saling beralias sepanjang place-nya dinyatakan terpisah, sehingga pola C++ seperti menukar dua elemen vector pada indeks yang mungkin sama tetap dapat ditulis tanpa unsafe. Ketiga, penegakan data race dirancang mengikuti jalur bertahap semacam Swift, karena dokumen tersebut menilai bukti kerusakan murni akibat data race tanpa pelanggaran temporal belum menunjukkan porsi kerentanan yang signifikan.

Mekanisme place dan place set yang menopang pemeriksaan tersebut sudah dibahas pada topik Checked Pointer, sehingga di sini cukup dicatat posisinya dalam strategi migrasi. Carbon memasang pemeriksaannya bertahap melalui dua langkah, yaitu migrasi otomatis dari C++ ke dialek interop pada mode permissive, lalu refactoring inkremental menuju kode aman memori pada mode strict. Statusnya perlu dinyatakan secara jujur, karena materi deep dive keamanan memori 2026 dipublikasikan untuk masukan komunitas, dan pemelihara proyek menyatakan desain tersebut belum mulai diimplementasikan pada toolchain.

Menyandingkan keduanya secara adil#

Cara paling konkret untuk melihat perbedaannya adalah pola pertukaran dua elemen vector pada indeks yang mungkin sama. Program C++ berikut menjalankan pola itu, termasuk pertukaran sebuah elemen dengan dirinya sendiri.

#include <cstdio>
#include <utility>
#include <vector>

int main() {
  std::vector<int> suhu_kota = {28, 31, 24};
  std::swap(suhu_kota[0], suhu_kota[2]);
  std::swap(suhu_kota[1], suhu_kota[1]);
  for (int nilai : suhu_kota) {
    printf("%d ", nilai);
  }
  printf("\n");
  return 0;
}

24 31 28 

Versi Rust dari std::swap(suhu_kota[1], suhu_kota[1]) ditolak borrow checker karena kedua argumen adalah referensi mutabel yang tumpang tindih, dan penulisannya perlu dirombak, misalnya dengan split_at_mut yang membelah vector menjadi dua potongan mutabel terpisah menurut dokumentasi std. Desain Carbon justru mengakomodasi pola ini melalui deklarasi place terpisah tanpa kata unsafe, sebagaimana dicontohkan dokumen desain keamanannya. Tabel berikut merangkum penyandingan keduanya.

Keadilan perbandingan menuntut kekuatan dan keterbatasan kedua pihak disebut apa adanya. Kekuatan Rust terbukti, yaitu pemeriksa yang matang, bebas pengumpul sampah, pencegahan data race sejak kompilasi, dan ekosistem library aman yang tumbuh pesat, sedangkan keterbatasannya juga nyata, yaitu desainnya menghadirkan hambatan adopsi dan migrasi dari C++, mulai dari perubahan idiom hingga biaya kinerja sebagaimana dinilai README. Kekuatan Carbon adalah titik berangkatnya pada basis kode C++ dan keleluasaan idiom beraliasnya, sedangkan keterbatasannya fatal untuk pemakaian nyata saat ini, yakni pemeriksa yang belum ada dan ekosistemnya yang belum terbentuk. Keynote pengumuman Carbon menyatakannya secara eksplisit, bahwa tim yang sudah nyaman dengan Rust sebaiknya tetap menggunakan Rust, dan README proyek memuat pernyataan serupa bahwa pengembang yang dapat menggunakan bahasa modern lain sebaiknya menggunakannya.

Ringkasan#

• Rust menegakkan pemilikan tunggal dan aturan pinjaman pada waktu kompilasi sejak rilis 1.0 tahun 2015, tanpa pengumpul sampah maupun runtime, sehingga dua referensi mutabel yang tumpang tindih ditolak dengan error E0499.
• Desain Carbon menyamai model Rust pada tingkat tinggi, dengan perbedaan pada keamanan inisialisasi waktu jalan, mutasi beralias yang diizinkan lewat deklarasi place terpisah, dan penegakan data race bertahap.
• Keduanya menempatkan pemeriksaan pada waktu kompilasi, tetapi statusnya berbeda jauh, yaitu pemeriksa Rust teruji produksi, sedangkan pemeriksa Carbon masih desain yang belum diimplementasikan.
• Kedua bahasa direncanakan saling melengkapi, karena Carbon mengandalkan interop dengan ekosistem Rust untuk library aman lintas platform alih-alih menduplikasinya.

Referensi#

• Safety — Proyek Carbon Language — Menyatakan model keamanan Carbon yang sebagian besar menyamai Rust beserta perbedaan rinciannya dan strategi interop library Rust.
• Carbon Language: An experimental successor to C++ — Proyek Carbon Language — Memuat rencana migrasi dua langkah serta penilaian hambatan adopsi bahasa modern dari C++.
• Understanding Ownership — The Rust Programming Language — Menetapkan tiga aturan pemilikan Rust beserta perilaku penghapusan nilai keluar lingkup.
• References and Borrowing — The Rust Programming Language — Menetapkan aturan referensi, yaitu satu referensi mutabel atau banyak referensi immutable serta referensi yang selalu sah.
• Error code E0499 — Dokumentasi rustc — Menjelaskan error variabel yang dipinjam mutabel lebih dari satu kali beserta contohnya.
• Vec — Dokumentasi std Rust — Mendokumentasikan split_at_mut yang membelah satu potongan mutabel menjadi dua bagian terpisah.
• Fearless Concurrency — The Rust Programming Language — Menjelaskan pencegahan data race Rust pada waktu kompilasi.
• Announcing Rust 1.0 — Blog Rust — Pengumuman rilis 1.0 pada Mei 2015 beserta klaim kendali tingkat rendah dan keamanan tanpa pengumpul sampah.
• C++: What Comes Next? (CppNorth 2022 keynote) — Chandler Carruth — Slide keynote yang menegaskan posisi tim yang sudah cocok dengan Rust agar tetap menggunakan Rust.