# Rust: Dasar-Dasar untuk Pengembang Berpengalaman di 2026

> Pelajari Rust dengan cepat menggunakan pengalaman pemrograman yang sudah dimiliki. Ownership, borrowing, lifetime, dan pola-pola penting dijelaskan untuk pengembang yang beralih dari C++, Java, atau Python.

- Published: 2026-01-09
- Updated: 2026-04-01
- Author: Anthony Fillion-Maillet
- Tags: rust, systems programming, ownership, memory safety, performance
- Reading time: 14 min

---

Rust terus meningkatkan popularitasnya dari tahun ke tahun, dan hal ini bukan tanpa alasan: keamanan memori yang dijamin pada waktu kompilasi, performa setara C++, dan ekosistem yang modern. Bagi pengembang berpengalaman yang berasal dari C++, Java, atau Python, mempelajari Rust mungkin terasa membingungkan pada awalnya, tetapi konsep-konsep fundamentalnya dengan cepat menjadi intuitif setelah dipahami.

> **Mengapa Rust di Tahun 2026?**
>
> Rust telah menjadi bahasa pemrograman paling disukai di Stack Overflow selama 8 tahun berturut-turut. Diadopsi oleh Microsoft, Google, Amazon, dan Meta untuk komponen-komponen kritis, Rust memberikan keamanan memori tanpa garbage collector.

## Menyiapkan Lingkungan Pengembangan Rust

Sebelum menulis kode, Rust perlu diinstal melalui rustup, yaitu alat manajemen versi resmi.

```bash
# install.sh
# Install Rust via rustup (macOS, Linux)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Verify installation
rustc --version
cargo --version
```

Cargo adalah package manager sekaligus build tool milik Rust. Cargo menggabungkan fungsi npm, Maven, dan Make ke dalam satu alat yang koheren.

```bash
# project-setup.sh
# Create a new project
cargo new my_project
cd my_project

# Generated structure:
# my_project/
# ├── Cargo.toml    # Manifest (like package.json)
# └── src/
#     └── main.rs   # Entry point

# Essential commands
cargo build          # Compile the project
cargo run            # Compile and run
cargo test           # Run tests
cargo check          # Check without building (faster)
```

## Variabel dan Immutability secara Default

Rust membalikkan konvensi yang umum: variabel bersifat **immutable secara default**. Pendekatan ini memaksa pengembang untuk secara eksplisit memikirkan mutabilitas dan mencegah banyak bug.

```rust
// variables.rs
fn main() {
    // Immutable by default
    let x = 5;
    // x = 6;  // Compile error!

    // Explicitly mutable variable
    let mut y = 5;
    y = 6;  // OK

    // Shadowing: redeclaration in the same scope
    let x = x + 1;  // Creates a new variable x
    let x = x * 2;  // x is now 12

    // Shadowing also allows changing the type
    let spaces = "   ";         // &str
    let spaces = spaces.len();  // usize
}
```

> **Shadowing vs Mutabilitas**
>
> Shadowing membuat variabel baru, berbeda dengan `mut` yang mengubah nilai yang sudah ada. Shadowing memungkinkan transformasi nilai sambil mempertahankan nama yang jelas.

## Tipe Data Fundamental

Rust adalah bahasa bertipe statis dengan type inference yang sangat baik. Berikut tipe-tipe primitif esensial yang perlu diketahui.

```rust
// types.rs
fn main() {
    // Signed integers: i8, i16, i32, i64, i128, isize
    let age: i32 = 30;

    // Unsigned integers: u8, u16, u32, u64, u128, usize
    let count: u64 = 1_000_000;  // Underscores for readability

    // Floats: f32, f64 (default)
    let pi: f64 = 3.14159;

    // Boolean
    let active: bool = true;

    // Unicode character (4 bytes)
    let emoji: char = '🦀';

    // Tuple: fixed collection of different types
    let person: (String, i32) = (String::from("Alice"), 28);
    let (name, age) = person;  // Destructuring

    // Array: fixed size, same type
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    let first = numbers[0];

    // Slice: view into a portion of data
    let slice: &[i32] = &numbers[1..4];  // [2, 3, 4]
}
```

## Ownership: Konsep Revolusioner

Ownership merupakan inovasi utama Rust. Sistem ini menjamin keamanan memori tanpa garbage collector, dengan konsekuensi kurva pembelajaran di awal.

### Tiga Aturan Ownership

```rust
// ownership.rs
fn main() {
    // Rule 1: Each value has a single owner
    let s1 = String::from("hello");

    // Rule 2: When the owner goes out of scope, the value is freed
    {
        let s2 = String::from("world");
        // s2 is valid here
    }
    // s2 is dropped, no longer accessible

    // Rule 3: Only one ownership at a time (move)
    let s3 = s1;  // s1 is MOVED to s3
    // println!("{}", s1);  // Error: s1 is no longer valid!
    println!("{}", s3);     // OK: s3 is the owner
}
```

### Move dan Clone

```rust
// move_clone.rs
fn main() {
    // Simple types (stack): automatic Copy
    let x = 5;
    let y = x;  // Copy, not move
    println!("x = {}, y = {}", x, y);  // Both are valid

    // Complex types (heap): Move by default
    let s1 = String::from("hello");
    let s2 = s1;  // Move
    // s1 is no longer usable

    // Explicit clone to duplicate
    let s3 = String::from("world");
    let s4 = s3.clone();  // Deep copy
    println!("s3 = {}, s4 = {}", s3, s4);  // Both valid
}
```

> **Move dan Fungsi**
>
> Meneruskan nilai ke sebuah fungsi berarti memindahkan ownership. Fungsi tersebut menjadi pemilik baru dan nilai tidak lagi dapat diakses setelah pemanggilan, kecuali jika dikembalikan.

```rust
// ownership_functions.rs
fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // println!("{}", s);  // Error: s has been moved

    let x = 5;
    makes_copy(x);
    println!("{}", x);  // OK: i32 implements Copy

    // To regain ownership, return the value
    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2);
    println!("{}", s3);  // OK
}

fn takes_ownership(s: String) {
    println!("{}", s);
}  // s is dropped here

fn makes_copy(x: i32) {
    println!("{}", x);
}

fn takes_and_gives_back(s: String) -> String {
    s  // Returns ownership
}
```

## Borrowing: Referensi Tanpa Transfer Ownership

Borrowing memungkinkan penggunaan nilai tanpa mengambil kepemilikannya. Mekanisme ini paling sering digunakan dalam Rust.

```rust
// borrowing.rs
fn main() {
    let s1 = String::from("hello");

    // Immutable reference: read-only
    let len = calculate_length(&s1);
    println!("Length of '{}': {}", s1, len);  // s1 still valid

    // Mutable reference: modification allowed
    let mut s2 = String::from("hello");
    change(&mut s2);
    println!("{}", s2);  // "hello, world"
}

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s goes out of scope but doesn't drop (it's a reference)

fn change(s: &mut String) {
    s.push_str(", world");
}
```

### Aturan Borrowing

```rust
// borrowing_rules.rs
fn main() {
    let mut s = String::from("hello");

    // Rule 1: Multiple immutable references simultaneously OK
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);

    // Rule 2: ONLY ONE mutable reference at a time
    let r3 = &mut s;
    // let r4 = &mut s;  // Error: already borrowed mutably
    println!("{}", r3);

    // Rule 3: No mutable ref if immutable ref exists
    let r5 = &s;
    // let r6 = &mut s;  // Error: r5 is still active
    println!("{}", r5);

    // Once r5 is used for the last time, mutable borrow is allowed
    let r7 = &mut s;  // OK: r5 is no longer used after this
    r7.push_str("!");
}
```

## Lifetime: Menjamin Validitas Referensi

Lifetime memastikan bahwa referensi tetap valid. Compiler sering kali dapat menyimpulkannya secara otomatis, tetapi terkadang anotasi eksplisit diperlukan.

```rust
// lifetimes_basic.rs

// Classic error: reference to freed data
// fn dangling() -> &String {
//     let s = String::from("hello");
//     &s  // Error: s will be dropped, invalid reference!
// }

// Solution: return the owned value
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // Ownership transferred, no problem
}
```

### Anotasi Lifetime

```rust
// lifetimes_annotation.rs

// The compiler can't figure out which reference will be returned
// fn longest(x: &str, y: &str) -> &str { ... }  // Error!

// Explicit annotation: return lives as long as BOTH x AND y
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(&string1, &string2);
        println!("Longest: {}", result);  // OK here
    }
    // println!("{}", result);  // Error: string2 dropped
}
```

> **Aturan Elision Lifetime**
>
> Rust menerapkan aturan elision yang menghilangkan kebutuhan anotasi untuk kasus-kasus sederhana. Pada tahap awal, mengikuti pesan error eksplisit dari compiler sudah cukup memadai.

## Struct dan Implementation

Struct merupakan blok pembangun dasar untuk membuat tipe kustom di Rust.

```rust
// structs.rs

// Struct definition
#[derive(Debug)]  // Enables printing with {:?}
struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

// Implementation block for methods
impl User {
    // Constructor (convention: fn new or descriptive name)
    fn new(username: String, email: String) -> Self {
        Self {
            username,
            email,
            active: true,
            sign_in_count: 1,
        }
    }

    // Method: takes &self (reference to instance)
    fn is_active(&self) -> bool {
        self.active
    }

    // Method with mutation: takes &mut self
    fn deactivate(&mut self) {
        self.active = false;
    }

    // Method consuming self (rare)
    fn into_username(self) -> String {
        self.username
    }
}

fn main() {
    let mut user = User::new(
        String::from("alice"),
        String::from("alice@example.com"),
    );

    println!("Active: {}", user.is_active());
    user.deactivate();
    println!("Active: {}", user.is_active());

    // Debug print
    println!("{:?}", user);
}
```

## Enum dan Pattern Matching

Enum di Rust jauh lebih powerful dibandingkan bahasa-bahasa lain: setiap varian dapat menyimpan data.

```rust
// enums.rs

// Simple enum
enum Direction {
    North,
    South,
    East,
    West,
}

// Enum with data (algebraic data type)
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(u8, u8, u8),
}

impl Message {
    fn process(&self) {
        match self {
            Message::Quit => println!("Quitting"),
            Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
            Message::Write(text) => println!("Writing: {}", text),
            Message::ChangeColor(r, g, b) => {
                println!("Color: rgb({}, {}, {})", r, g, b)
            }
        }
    }
}

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    msg.process();

    let msg2 = Message::Write(String::from("Hello Rust!"));
    msg2.process();
}
```

### Option dan Result: Dasar Penanganan Error

```rust
// option_result.rs
use std::fs::File;
use std::io::{self, Read};

fn main() {
    // Option<T>: present or absent value (replaces null)
    let numbers = vec![1, 2, 3];
    let first: Option<&i32> = numbers.first();

    match first {
        Some(n) => println!("First: {}", n),
        None => println!("Empty list"),
    }

    // Utility methods
    let value = first.unwrap_or(&0);
    let doubled = first.map(|n| n * 2);

    // Result<T, E>: success or error
    let result = read_file("config.txt");
    match result {
        Ok(content) => println!("Content: {}", content),
        Err(e) => println!("Error: {}", e),
    }
}

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;  // ? propagates the error
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
```

> **Operator ?**
>
> Operator `?` adalah syntactic sugar untuk propagasi error. Operator ini secara otomatis mengembalikan error jika Result bernilai Err, dan membuka nilai Ok jika berhasil.

## Trait: Polimorfisme Gaya Rust

Trait mendefinisikan perilaku bersama, serupa dengan interface di Java atau protocol di Swift.

```rust
// traits.rs

// Trait definition
trait Summary {
    fn summarize(&self) -> String;

    // Method with default implementation
    fn preview(&self) -> String {
        format!("{}...", &self.summarize()[..50.min(self.summarize().len())])
    }
}

struct Article {
    title: String,
    author: String,
    content: String,
}

struct Tweet {
    username: String,
    content: String,
}

// Implementation for Article
impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{} by {}", self.title, self.author)
    }
}

// Implementation for Tweet
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("@{}: {}", self.username, self.content)
    }
}

// Function accepting any type implementing Summary
fn notify(item: &impl Summary) {
    println!("Breaking news: {}", item.summarize());
}

// Equivalent syntax with trait bound
fn notify_generic<T: Summary>(item: &T) {
    println!("Breaking news: {}", item.summarize());
}

fn main() {
    let article = Article {
        title: String::from("Rust 2026"),
        author: String::from("Community"),
        content: String::from("..."),
    };

    let tweet = Tweet {
        username: String::from("rustlang"),
        content: String::from("Rust is awesome!"),
    };

    notify(&article);
    notify(&tweet);
}
```

## Koleksi Esensial

Standard library Rust menyediakan tipe-tipe koleksi yang powerful.

```rust
// collections.rs
use std::collections::HashMap;

fn main() {
    // Vec<T>: dynamic array
    let mut numbers: Vec<i32> = Vec::new();
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);

    // vec! macro for initialization
    let nums = vec![1, 2, 3, 4, 5];

    // Iteration
    for n in &nums {
        println!("{}", n);
    }

    // Functional methods
    let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
    let sum: i32 = nums.iter().sum();
    let evens: Vec<&i32> = nums.iter().filter(|x| *x % 2 == 0).collect();

    // String: growable UTF-8 string
    let mut s = String::from("Hello");
    s.push_str(", World!");
    s.push('!');

    // Concatenation
    let s1 = String::from("Hello, ");
    let s2 = String::from("World!");
    let s3 = s1 + &s2;  // s1 moved, s2 borrowed
    // or with format!
    let s4 = format!("{}{}", "Hello, ", "World!");

    // HashMap<K, V>
    let mut scores: HashMap<String, i32> = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Red"), 50);

    // Access with get (returns Option)
    if let Some(score) = scores.get("Blue") {
        println!("Blue: {}", score);
    }

    // Entry API for conditional insertion
    scores.entry(String::from("Yellow")).or_insert(25);
}
```

## Penanganan Error Idiomatis di Rust

Penanganan error yang tepat sangat penting dalam Rust. Berikut pola-pola yang direkomendasikan.

```rust
// error_handling.rs
use std::fs::File;
use std::io::{self, Read};
use std::num::ParseIntError;

// Define a custom error type
#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Parse(ParseIntError),
    Custom(String),
}

// Implement From for automatic conversion
impl From<io::Error> for AppError {
    fn from(err: io::Error) -> Self {
        AppError::Io(err)
    }
}

impl From<ParseIntError> for AppError {
    fn from(err: ParseIntError) -> Self {
        AppError::Parse(err)
    }
}

// Function returning Result with custom error
fn read_number_from_file(path: &str) -> Result<i32, AppError> {
    let mut file = File::open(path)?;  // io::Error -> AppError
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    let number: i32 = content.trim().parse()?;  // ParseIntError -> AppError
    Ok(number)
}

fn main() {
    match read_number_from_file("number.txt") {
        Ok(n) => println!("Number: {}", n),
        Err(AppError::Io(e)) => println!("IO error: {}", e),
        Err(AppError::Parse(e)) => println!("Parse error: {}", e),
        Err(AppError::Custom(msg)) => println!("Error: {}", msg),
    }
}
```

> **Crate yang Direkomendasikan**
>
> Untuk proyek nyata, crate `thiserror` (untuk library) dan `anyhow` (untuk aplikasi) sangat menyederhanakan penanganan error.

## Pengujian di Rust

Rust mengintegrasikan framework pengujian langsung ke dalam bahasa.

```rust
// lib.rs

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

// Test module (compiled only for `cargo test`)
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, 1), 0);
    }

    #[test]
    fn test_divide_success() {
        assert_eq!(divide(10, 2), Ok(5));
    }

    #[test]
    fn test_divide_by_zero() {
        assert!(divide(10, 0).is_err());
    }

    #[test]
    #[should_panic(expected = "index out of bounds")]
    fn test_panic() {
        let v = vec![1, 2, 3];
        let _ = v[99];  // Panic!
    }
}
```

## Kesimpulan

Rust menawarkan paradigma unik yang menggabungkan keamanan memori dan performa tinggi. Konsep ownership dan borrowing memang terasa membatasi pada awalnya, tetapi menjadi natural seiring dengan praktik. Compiler Rust merupakan sekutu yang sangat berharga: pesan error-nya termasuk yang terbaik di industri.

### Daftar Periksa untuk Memulai

- Instalasi Rust melalui rustup dan penguasaan Cargo
- Pemahaman perbedaan antara immutability dan mutabilitas eksplisit
- Penguasaan tiga aturan ownership
- Praktik borrowing dengan referensi `&` dan `&mut`
- Penggunaan `Option` dan `Result` sebagai pengganti null dan exception
- Penulisan test dengan `#[test]`

Komunitas Rust sangat ramah dan sumber daya tersedia berlimpah. Buku resmi "The Rust Programming Language" tersedia secara gratis secara daring. Dengan fondasi yang kokoh ini, eksplorasi topik lanjutan seperti async/await, macro, dan WebAssembly dapat segera dimulai.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/id/blog/rust/rust-basics-experienced-developers