• Sahiplik (Ownership): Rust'taki her değerin bir sahibi (owner) vardır ve bir değerin aynı anda yalnızca bir sahibi olabilir. Bu, kaynakların ne zaman tahsis edilip ne zaman serbest bırakılacağının derleme zamanında net bir şekilde belirlenmesini sağlar. Sahip kapsam dışına çıktığında, değer otomatik olarak düşürülür (dropped) ve belleği güvenli bir şekilde serbest bırakılır. Bu model, dangling pointer'lar ve çift serbest bırakmalar gibi yaygın bellek hatalarını tamamen ortadan kaldırır.
• Ödünç Alma (Borrowing): Değerlerin sahipliğini değiştirmeden onlara geçici olarak referanslarla erişmek için kullanılır. Referanslar ya değiştirilemez (`&T`) ya da değiştirilebilir (`&mut T`) olabilir. Rust'ın ödünç alma kuralları (borrow checker), aynı anda tek bir değiştirilebilir referansa veya birden fazla değiştirilemez referansa izin verir. Bu kural, veri yarışlarını (data races) derleme zamanında engeller ve eşzamanlı programlamayı çok daha güvenli hale getirir. Bu kısıtlamalar ilk başta zorlayıcı gelse de, uzun vadede çok daha sağlam kod yazılmasına olanak tanır.
• Yaşam Süreleri (Lifetimes): Referansların geçerlilik sürelerini tanımlar ve derleyicinin referansların işaret ettikleri veriden daha uzun yaşamasını engelleyen bir mekanizmadır. Yaşam süreleri sayesinde derleyici, referansların geçerli oldukları süre boyunca işaret ettikleri verinin de geçerli kalmasını sağlar. Bu sayede sallanan referanslar (dangling references) ve onlardan kaynaklanan bellek ihlalleri ortadan kalkar. Yaşam süreleri, özellikle karmaşık veri yapıları ve FFI (Foreign Function Interface) kullanıldığında kritik bir rol oynar.

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

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

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // Mutex'i kilitler
            *num += 1; // Sayacı güvenli bir şekilde artırır
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap(); // İş parçacıklarının bitmesini bekler
    }

    println!("Sonuç: {}", *counter.lock().unwrap());
}

"Rust'ın bellek güvenliği garantileri, eşzamanlı programlamada sıkça karşılaşılan birçok hatayı ortadan kaldırarak geliştiricilerin daha güvenli ve stabil uygulamalar oluşturmasına olanak tanır. Bu sayede 'korkusuz eşzamanlılık' gerçekten mümkün hale gelir." - Rust Topluluğu

Genişletmek için tıkla ...

• Option<T>: Bir değerin var olup olmadığını (`Some(T)`) veya eksik olduğunu (`None`) temsil eder. Bu, null değer kavramını ortadan kaldırır ve null pointer dereference hatalarını derleme zamanında yakalar.
• Result<T, E>: Bir işlemin başarılı (`Ok(T)`) veya başarısız (`Err(E)`) olduğunu temsil eder. Fonksiyonların hata durumlarını açıkça belirtmesini sağlayarak, hata yönetimini kodun ayrılmaz bir parçası haline getirir. Geliştiriciler bu enümleri `.unwrap()` veya `.expect()` gibi yöntemlerle doğrudan ele alabilir ya da `match` ifadeleri ve `?` operatörü ile daha zarif bir şekilde işleyebilirler.

extern "C" {
    // C standart kütüphanesindeki 'abs' fonksiyonunu içe aktarırız.
    fn abs(input: i32) -> i32;
}

fn main() {
    // unsafe blok içinde yabancı fonksiyonları çağırabiliriz.
    unsafe {
        println!("Mutlak değer -3: {}", abs(-3));
    }
}

• Cargo: Rust'ın resmi paket yöneticisi ve derleme sistemidir. Bağımlılık yönetiminden test çalıştırmaya, belge oluşturmaktan derlemeye kadar birçok görevi üstlenir. Yeni bir Rust projesi başlatmak, bağımlılık eklemek veya projeyi derlemek Cargo sayesinde son derece kolaydır. Cargo dökümantasyonunu incelemek ve daha fazla bilgi edinmek için buraya tıklayın.
• Crates.io: Rust topluluğu tarafından geliştirilen kütüphanelerin (crate'lerin) merkezi kayıt defteridir. Binlerce hazır ve yüksek kaliteli kütüphane sunar; ağ iletişimi, veri yapıları, web çerçeveleri, kriptografi ve daha fazlasını kapsar. Bu zengin kütüphane havuzu, Rust geliştiricilerinin tekerleği yeniden icat etmeden hızlıca çözümler üretmesini sağlar.

• İşletim Sistemleri ve Gömülü Sistemler: Bellek güvenliği, düşük seviye kontrol imkanı ve kaynak verimliliği sayesinde Redox OS gibi işletim sistemleri, mikrodenetleyiciler ve IoT (Nesnelerin İnterneti) cihazları için ideal bir seçenektir.
• WebAssembly (Wasm): Performanslı web uygulamaları geliştirmek için Rust kodu, WebAssembly'ye derlenebilir. Bu, web tarayıcılarında neredeyse yerel hızda çalışan karmaşık uygulamalar oluşturmayı mümkün kılar.
• Ağ Programlama: Yüksek performanslı ve eşzamanlı sunucular, proxy'ler, API ağ geçitleri ve diğer ağ servisleri için kullanılır. Özellikle `Tokio` gibi asenkron çalışma zamanları (async runtimes) sayesinde Rust, modern ağ uygulamalarının omurgasını oluşturabilir.
• Komut Satırı Araçları (CLI): `ripgrep` (grep'e hızlı bir alternatif), `fd` (find'a hızlı bir alternatif) ve `exa` (ls'e modern bir alternatif) gibi birçok popüler ve performanslı CLI aracı Rust ile yazılmıştır.
• Kripto Para ve Blockchain: Güvenlik ve performans kritik uygulamalar olan blockchain node'ları ve kripto para birimleri için Rust, tercih edilen dillerden biridir.

• Güvenlik: Bellek güvenliği garantileri sayesinde çoğu çalışma zamanı hatasını derleme zamanında önler, bu da daha az güvenlik açığına yol açar.
• Performans: C/C++ seviyesinde performans sunar, gereksiz soyutlamalardan kaçınır ve çöp toplayıcıya (garbage collector) ihtiyaç duymaz.
• Eşzamanlılık: Veri yarışlarını derleme zamanında engelleyerek eşzamanlı programlamayı hem güvenli hem de daha kolay hale getirir.
• Geliştirici Deneyimi: Cargo ile güçlü bir paket yönetimi, zengin bir ekosistem ve yardımcı derleyici mesajları sayesinde geliştirici dostu bir ortam sunar.
• Güçlü Tip Sistemi: Hataları erken yakalamaya yardımcı olan, ifade edici ve esnek bir tip sistemi vardır.
• Topluluk ve Gelecek: Aktif ve büyüyen bir topluluğa sahip olup, sürekli geliştirilmekte ve genişlemektedir.