Rust adalah bahasa pemrograman sistem modern yang dirancang untuk kinerja, keamanan, dan konkruensi. Bahasa ini memberikan fitur-fitur bahasa yang kuat kepada pengguna sambil berusaha menghilangkan kesalahan pemrograman umum, seperti dereferensi pointer null dan data race. Rust menekankan abstraksi tanpa biaya, memungkinkan pengembang untuk menulis kode tingkat tinggi tanpa mengorbankan kinerja. Bahasa ini sangat cocok untuk tugas-tugas di mana kontrol tingkat rendah terhadap perangkat keras dan manajemen memori diperlukan, seperti pemrograman sistem, web assembly, dan pembuatan aplikasi berkinerja tinggi.
Rust diciptakan pada tahun 2006 oleh Graydon Hoare di Mozilla Research. Tujuan awal bahasa ini adalah untuk mengatasi tantangan dalam mengembangkan perangkat lunak konkuren yang aman dan untuk menciptakan alternatif yang lebih andal untuk bahasa pemrograman sistem yang ada. Pada tahun 2010, versi publik pertama dari Rust dirilis, dan dengan cepat menarik perhatian karena pendekatannya yang inovatif terhadap keamanan memori dan konkruensi.
Rust mengambil inspirasi dari beberapa bahasa pemrograman, seperti C++ untuk desain yang berorientasi kinerja dan bahasa pemrograman fungsional untuk penekanan pada ketidakberubahan dan abstraksi yang kuat. Desainnya juga mencerminkan prinsip-prinsip dari bahasa seperti Haskell, terutama dalam sistem tipe yang kuat dan kemampuan pencocokan pola.
Sejak awal, Rust telah berkembang menjadi bahasa yang diakui secara luas, dengan komunitas pengembang yang kuat dan ekosistem pustaka yang terus berkembang. Bahasa ini telah didukung secara resmi oleh Mozilla dan telah mendapatkan perhatian di berbagai domain, termasuk pengembangan web, sistem tertanam, dan pengembangan game. Rilis Rust 1.0 pada tahun 2015 menandai tonggak penting, mengukuhkan stabilitas dan kesiapan untuk penggunaan produksi. Yayasan Rust, yang didirikan pada tahun 2021, mendukung pengembangan dan tata kelola yang berkelanjutan.
Model kepemilikan unik Rust memungkinkan pengembang untuk mengelola memori tanpa pengumpul sampah. Setiap variabel di Rust memiliki satu pemilik, dan kepemilikan dapat dipindahkan, atau "dipinjam," melalui referensi. Fitur ini membantu memastikan keamanan memori dengan menegakkan aturan peminjaman yang ketat.
fn main() {
let s1 = String::from("Hello");
let s2 = &s1; // Meminjam s1
println!("{}", s2);
}
Pencocokan pola di Rust memungkinkan pengembang untuk mendestrukturisasi tipe data dan mengelola alur kontrol yang kompleks dengan mulus. Pernyataan match menyediakan cara yang kuat untuk membagi logika berdasarkan pola nilai.
fn main() {
let number = 4;
match number {
1 => println!("Satu"),
2 => println!("Dua"),
_ => println!("Lainnya"),
}
}
Rust menggunakan inferensi tipe, memungkinkan kompiler untuk menyimpulkan tipe variabel secara otomatis, yang menyederhanakan kode dan meningkatkan keterbacaan.
fn main() {
let x = 5; // Kompiler menyimpulkan x adalah tipe i32
}
Trait mirip dengan antarmuka di bahasa lain dan memungkinkan polimorfisme. Mereka mendefinisikan perilaku bersama yang dapat diimplementasikan oleh tipe.
trait Speak {
fn speak(&self);
}
struct Dog;
impl Speak for Dog {
fn speak(&self) {
println!("Guk!");
}
}
Tipe Option dan Result di Rust menyediakan penanganan kesalahan yang kuat dan paradigma pemrograman yang aman dari null, memungkinkan pengembang untuk mengekspresikan kemungkinan ketidakhadiran atau kesalahan secara eksplisit.
fn divide(x: f64, y: f64) -> Option<f64> {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
Rust mendukung konkruensi tanpa rasa takut melalui sistem kepemilikannya, memungkinkan beberapa thread untuk beroperasi pada data dengan risiko minimal terhadap data race.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Halo dari sebuah thread!");
});
handle.join().unwrap();
}
Sistem makro Rust memungkinkan untuk generasi kode, membuatnya mungkin untuk menulis konstruksi sintaksis kustom yang dapat digunakan kembali di seluruh basis kode.
macro_rules! say_hello {
() => {
println!("Halo!");
};
}
fn main() {
say_hello!();
}
Closure di Rust adalah fungsi anonim yang dapat menangkap variabel dari lingkungan mereka, membuatnya fleksibel untuk paradigma pemrograman fungsional.
fn main() {
let add = |a, b| a + b;
println!("{}", add(5, 7));
}
Rust memanfaatkan sistem modul untuk mengorganisir kode dan mengontrol visibilitas. Crate adalah paket kode Rust yang dapat dibagikan dan digunakan kembali.
mod my_module {
pub fn hello() {
println!("Halo dari my_module!");
}
}
fn main() {
my_module::hello();
}
Rust memiliki fitur dokumentasi bawaan, dan alat Rustdoc secara otomatis menghasilkan dokumentasi dari komentar di kode sumber.
/// Fungsi ini menambahkan dua angka.
///
/// # Contoh
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
a + b
}
Rust memiliki seperangkat alat pengembang yang kaya, termasuk manajer paketnya, Cargo, yang memfasilitasi manajemen ketergantungan, pembangunan, dan penerbitan pustaka serta aplikasi. Pustaka standar Rust menyediakan dukungan runtime yang melimpah untuk berbagai tugas.
Beberapa IDE dan editor mendukung pengembangan Rust, termasuk:
Untuk membuat proyek Rust baru, pengembang dapat menggunakan Cargo dengan perintah berikut:
cargo new my_project
Perintah ini menghasilkan direktori baru yang berisi struktur proyek Rust dasar. Untuk membangun proyek, cukup navigasikan ke direktori proyek dan jalankan:
cargo build
Rust digunakan di berbagai domain karena fitur kinerja dan keamanannya. Aplikasi kunci termasuk:
Rust sering dibandingkan dengan bahasa pemrograman sistem lainnya karena penekanan pada kinerja dan keamanan. Berikut adalah beberapa perbandingan:
Menerjemahkan kode Rust ke bahasa lain bisa menjadi tantangan karena model kepemilikannya yang unik dan fitur-fitur canggih. Namun, beberapa alat memfasilitasi terjemahan sumber ke sumber, seperti: