Rust ile Sistem Programlama: Bellek Güvenli Yüksek Performans

Rust Nedir ve Neden Sistem Programlama İçin Tercih Edilir?

Sistem programlama, donanıma yakın seviyede çalışan, işletim sistemleri, sürücüler, gömülü sistemler ve yüksek performanslı uygulamalar geliştirmeyi kapsayan bir alandır. Onlarca yıl boyunca C ve C++ bu alanın tartışmasız liderleri oldu. Ancak bu dillerin getirdiği bellek güvenliği sorunları — buffer overflow, use-after-free, dangling pointer gibi hatalar — sayısız güvenlik açığına ve sistem çökmesine neden olmuştur. Mozilla'nın sponsorluğunda geliştirilen Rust, bu sorunlara köklü bir çözüm sunarak 2015'teki 1.0 sürümünden bu yana hızla yükselişe geçti.

Rust'ın temel vaadi şudur: garbage collector olmadan bellek güvenliği sağlamak. Bunu derleme zamanında uygulanan katı kurallar sistemiyle başarır. Sonuç olarak, C/C++ seviyesinde performans elde ederken, Java veya Go gibi dillerin sunduğu güvenlik garantilerine sahip olursunuz — üstelik çalışma zamanı maliyeti olmadan.

Ownership, Borrowing ve Lifetime: Rust'ın Üç Temel Direği

Ownership (Sahiplik) Sistemi

Rust'ın bellek güvenliğinin temelinde ownership sistemi yatar. Her değerin bellekte tek bir sahibi (owner) vardır ve bu sahip kapsam dışına çıktığında değer otomatik olarak bellekten temizlenir. Bu basit kural, bellek sızıntılarını büyük ölçüde önler.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1; // s1'in sahipliği s2'ye taşındı (move)

    // println!("{}", s1); // HATA! s1 artık geçerli değil
    println!("{}", s2); // Çalışır: "merhaba"
}

Yukarıdaki örnekte s1 değişkeninin sahipliği s2'ye taşınmıştır. Rust derleyicisi, s1'e tekrar erişmeye çalışırsanız derleme hatasıyla sizi uyarır. Bu sayede double-free gibi kritik hatalar tamamen ortadan kalkar.

Borrowing (Ödünç Alma)

Her seferinde sahiplik transfer etmek pratik olmayacağından, Rust referanslar aracılığıyla ödünç alma mekanizması sunar. İki tür referans vardır:

• Immutable referans (&T): Birden fazla okuma referansı aynı anda var olabilir.
• Mutable referans (&mut T): Aynı anda yalnızca bir yazma referansı olabilir ve bu sırada başka hiçbir referans bulunamaz.

fn hesapla_uzunluk(s: &String) -> usize {
    s.len() // s'yi ödünç aldık, sahipliğini almadık
}

fn buyuk_harfe_cevir(s: &mut String) {
    *s = s.to_uppercase();
}

fn main() {
    let mut metin = String::from("rust programlama");

    let uzunluk = hesapla_uzunluk(&metin);
    println!("Uzunluk: {}", uzunluk);

    buyuk_harfe_cevir(&mut metin);
    println!("Sonuç: {}", metin); // "RUST PROGRAMLAMA"
}

Bu kural, data race hatalarını derleme zamanında engelleyen en güçlü mekanizmadır. Çok iş parçacıklı (multithreaded) programlamada bile veri yarışı koşulları oluşamaz.

Lifetime (Yaşam Süresi)

Lifetime anotasyonları, referansların geçerlilik süresini derleyiciye açıkça belirtmenizi sağlar. Bu sayede dangling reference (sarkık referans) oluşması imkânsız hale gelir:

fn en_uzun<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("uzun metin");
    let sonuc;
    {
        let s2 = String::from("kısa");
        sonuc = en_uzun(s1.as_str(), s2.as_str());
        println!("En uzun: {}", sonuc);
    }
    // sonuc burada s2'ye işaret ediyorsa derleyici hata verir
}

Sıfır Maliyetli Soyutlamalar ve Performans

Rust'ın tasarım felsefesindeki en önemli ilkelerden biri zero-cost abstractions (sıfır maliyetli soyutlamalar) prensibidir. Yüksek seviyeli yapılar kullandığınızda, derleyici bunları elle yazacağınız düşük seviyeli koda eşdeğer makine koduna dönüştürür.

// Iterator kullanımı - yüksek seviyeli ama sıfır maliyetli
fn toplam_cift_kareler(sayilar: &[i64]) -> i64 {
    sayilar.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .sum()
}

// Yukarıdaki kod, derleyici tarafından aşağıdakine eşdeğer
// optimize edilmiş makine koduna dönüştürülür:
fn toplam_cift_kareler_manual(sayilar: &[i64]) -> i64 {
    let mut toplam: i64 = 0;
    for i in 0..sayilar.len() {
        if sayilar[i] % 2 == 0 {
            toplam += sayilar[i] * sayilar[i];
        }
    }
    toplam
}

Benchmark testlerinde bu iki fonksiyon neredeyse aynı performansı sergiler. Rust derleyicisi (rustc), LLVM altyapısını kullanarak agresif optimizasyonlar gerçekleştirir: döngü açma (loop unrolling), satır içi genişletme (inlining) ve otomatik vektörizasyon bunlardan bazılarıdır.

Eşzamanlı Programlamada Fearless Concurrency

Rust, eşzamanlı (concurrent) programlamayı "korkusuz" hale getirir. Ownership ve borrowing kuralları, iş parçacıkları arasında paylaşılan verilerde oluşabilecek yarış koşullarını derleme zamanında yakalar:

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let sayac = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let sayac_klon = Arc::clone(&sayac);
        let handle = thread::spawn(move || {
            let mut deger = sayac_klon.lock().unwrap();
            *deger += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Sonuç: {}", *sayac.lock().unwrap()); // Her zaman 10
}

Burada Arc (Atomic Reference Counting) ile güvenli paylaşım, Mutex ile karşılıklı dışlama sağlanır. Send ve Sync trait'leri sayesinde, iş parçacıkları arasında güvenle paylaşılamayan türler derleme zamanında reddedilir.

Gerçek Dünyada Rust: Kullanım Alanları

• İşletim Sistemleri: Linux çekirdeği 6.1'den itibaren Rust desteği içermektedir. Google, Android'de Rust kullanımını artırmaktadır.
• Web Altyapısı: Cloudflare, Fastly ve Discord gibi şirketler performans-kritik bileşenlerini Rust ile yeniden yazmıştır.
• Gömülü Sistemler: no_std desteğiyle mikrodenetleyiciler üzerinde çalışabilir.
• WebAssembly: Rust, WASM hedefine derleme konusunda birinci sınıf destek sunar.
• Komut Satırı Araçları: ripgrep, fd, bat gibi popüler araçlar Rust ile yazılmıştır ve C alternatiflerinden daha hızlı çalışır.

Cargo: Güçlü Paket Yöneticisi ve Derleme Sistemi

Rust'ın ekosisteminin kalbi olan Cargo, proje yönetimi, bağımlılık çözümlemesi, derleme, test ve belgelendirme gibi işlemleri tek bir araçta birleştirir:

# Yeni proje oluşturma
cargo new sistem_araci --bin

# Bağımlılık ekleme (Cargo.toml)
# [dependencies]
# serde = { version = "1.0", features = ["derive"] }
# tokio = { version = "1", features = ["full"] }

# Derleme, test ve çalıştırma
cargo build --release    # Optimize edilmiş derleme
cargo test               # Tüm testleri çalıştır
cargo bench              # Benchmark testleri
cargo clippy             # Lint kontrolü

crates.io üzerinde 150.000'den fazla paket (crate) bulunmaktadır ve ekosistem hızla büyümeye devam etmektedir.

unsafe Rust: Kontrollü Güvensizlik

Bazı sistem programlama senaryolarında — donanıma doğrudan erişim, FFI (Foreign Function Interface) çağrıları veya performans optimizasyonları için — derleyicinin güvenlik kontrollerini aşmak gerekebilir. Rust bunu unsafe bloklarıyla mümkün kılar:

unsafe fn tehlikeli_islem(ptr: *const i32) -> i32 {
    *ptr // Ham pointer'ı dereference etme
}

fn main() {
    let deger = 42;
    let ptr = °er as *const i32;

    // unsafe blok açıkça işaretlenir
    let sonuc = unsafe { tehlikeli_islem(ptr) };
    println!("Değer: {}", sonuc);
}

unsafe kullanımı, güvensiz kodun sınırlarını açıkça belirler ve kod incelemelerinde dikkat edilmesi gereken noktaları görünür kılar. İyi tasarlanmış Rust projelerinde unsafe blokları güvenli bir API arkasına sarılır; böylece kullanıcılar güvensiz detaylardan habersiz kalır.

Sonuç: Rust ile Geleceğe Yatırım

Rust, sistem programlama dünyasında bir paradigma değişimini temsil eder. Bellek güvenliği, iş parçacığı güvenliği ve sıfır maliyetli soyutlamalar üçlüsünü bir arada sunarak, performanstan ödün vermeden güvenli yazılım geliştirmeyi mümkün kılar. Öğrenme eğrisi diğer dillere kıyasla daha dik olsa da, derleyicinin sunduğu ayrıntılı hata mesajları ve güçlü topluluk desteği bu süreci önemli ölçüde kolaylaştırır. Bellek hatalarının yazılım güvenlik açıklarının yaklaşık yüzde yetmişini oluşturduğu günümüzde, Rust'ı öğrenmek yalnızca teknik bir tercih değil, aynı zamanda stratejik bir yatırımdır.