Rust, performans ve güvenliği aynı anda hedefleyen, sistem programlamaya yönelik modern bir programlama dilidir. En belirgin özelliği, çöp toplayıcı kullanmadan bellek güvenliğini derleme aşamasında garanti etmeye çalışan ownership (sahiplik) modelidir. Bu rehberde Rust'ın ne olduğunu, nasıl çalıştığını ve hangi işler için uygun olduğunu dengeli biçimde ele alıyoruz.
Rust Nedir ve Nereden Geldi?
Rust, başlangıçta Mozilla bünyesinde bir araştırma projesi olarak doğdu ve zamanla açık kaynaklı, topluluk tarafından geliştirilen bağımsız bir dile dönüştü. Amaç, C ve C++ gibi dillerin performansını korurken, bu dillerde sık görülen bellek güvenliği hatalarını büyük ölçüde ortadan kaldırmaktı.
Dilin gelişimi açık bir süreçle, RFC (Request for Comments) belgeleri üzerinden yürütülür. Rust, kararlı bir sürüm takvimine sahiptir ve geriye dönük uyumluluğa önem verir; dil zaman içinde "edition" adı verilen aşamalarla, mevcut kodu bozmadan evrilir.
Ownership: Rust'ın Kalbindeki Model
Rust'ı diğer dillerden ayıran temel fikir ownership modelidir. Her değerin bir sahibi vardır; sahip kapsam dışına çıktığında değerin kullandığı bellek otomatik olarak serbest bırakılır. Değerler bir yerden başka bir yere taşınabilir (move) veya ödünç verilebilir (borrow); ancak bunu yönetirken derleyici katı kurallar uygular.
Bu kurallar, ödünç alma denetleyicisi (borrow checker) tarafından derleme sırasında kontrol edilir. Böylece sarkan işaretçi, çift serbest bırakma ve veri yarışı (data race) gibi hatalar program çalışmadan önce, derleyici tarafından yakalanmaya çalışılır. Bu denetim, çöp toplayıcıya gerek kalmadan bellek güvenliği sağlamayı amaçlar.
fn main() {
let s1 = String::from("selam");
let s2 = s1; // sahiplik s2'ye tasindi, s1 artik gecersiz
println!("{}", s2);
}Rust Nasıl Çalışır?
Rust doğrudan makine koduna derlenir ve bunun için LLVM altyapısını kullanır. Ara bir çalışma zamanı veya çöp toplayıcı olmadığından, üretilen programlar C ve C++'a yakın performans sergileyebilir. Bellek güvenliği ise çalışma anında değil, büyük ölçüde derleme sırasında sağlanır.
Rust, güçlü bir araç zinciriyle gelir. Paket yöneticisi ve derleme aracı Cargo, bağımlılıkları yönetir, projeyi derler ve testleri çalıştırır. Paketler crates.io üzerinden dağıtılır; bu da ekosistemin düzenli ve erişilebilir olmasını sağlar. Ayrıca cargo fmt ve cargo clippy gibi araçlar, kodu biçimlendirmek ve yaygın sorunları statik olarak yakalamak için standart bir temel sunar; böylece ekip içinde ortak bir kalite çizgisi oluşturmak kolaylaşır.
fn topla(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
let sonuc = topla(2, 3);
println!("toplam: {}", sonuc);
}Rust Nerelerde Kullanılır?

Rust, performans ve güvenilirliğin birlikte önemli olduğu alanlarda öne çıkar. Düşük seviyeli kontrol sunması, onu sistem programlama için uygun kılarken, güvenlik garantileri uzun ömürlü servislerde güven verir:
- Sistem programlama ve işletim sistemi bileşenleri
- Komut satırı araçları (CLI)
- Yüksek performanslı ağ servisleri ve arka uç sistemleri
- WebAssembly hedefleri
- Gömülü sistemler ve kaynağı kısıtlı ortamlar
Dilleri birlikte değerlendiren bakış için programlama dilleri rehberi yazımıza göz atabilirsiniz. Benzer sistem programlama alanında Go programlama dili daha sade bir söz dizimi ve çöp toplama ile farklı bir denge sunarken, maksimum kontrol gerektiren işlerde Rust tercih edilebilir.
Rust'ın Güçlü ve Zayıf Yönleri
Rust güçlü garantiler sunar; ancak bu garantilerin bir öğrenme bedeli vardır. Aşağıdaki tablo dengeli bir bakış sağlamayı amaçlar.
| Güçlü Yönler | Dikkat Edilecek Yönler |
|---|---|
| Çöp toplayıcısız bellek güvenliği | Ownership modeli başta öğrenmesi zordur |
| C/C++'a yakın performans | Derleme süreleri bazı projelerde uzayabilir |
| Güçlü araç zinciri (Cargo) | Ekosistem bazı alanlarda daha yenidir |
| Güvenli eşzamanlılık garantileri | Hızlı prototiplemede daha fazla kısıt gerektirir |
Rust Öğrenmeye Nasıl Başlanır?

Rust öğrenmek için topluluğun hazırladığı ücretsiz resmi kitap ("The Rust Programming Language") en çok önerilen kaynaktır. Rust'ı kurmak için rustup aracı kullanılır; bu araç derleyiciyi, Cargo'yu ve belgeleri birlikte getirir. Öğrenme sürecinde sabırlı olmak önemlidir: ownership kavramları başta zorlasa da, derleyicinin rehberliğiyle zamanla doğal hale gelir.
- Temel söz dizimi, değişkenler ve tiplerle başlayın
- Ownership, borrow ve lifetime kavramlarını adım adım kavrayın
struct,enumve desen eşleştirme (pattern matching) öğreninResultveOptionile hata yönetimini uygulayın- Cargo ile küçük bir proje oluşturup bağımlılık ekleyin
Rust Söz Diziminin Temelleri
Rust söz dizimi, C ailesine aşina geliştiriciler için tanıdık görünür; ancak kendine özgü bazı seçimler taşır. Değişkenler varsayılan olarak değiştirilemezdir (immutable); bir değişkeni sonradan değiştirmek istiyorsanız let mut yazmanız gerekir. Bu seçim, kazara yapılan değişiklikleri azaltır ve kodun niyetini daha açık kılar. Fonksiyonlar fn ile tanımlanır ve son ifadenin değeri, return yazmadan da fonksiyonun dönüş değeri olabilir.
Rust'ın tip sistemi zengindir. Özel veri yapıları struct ile, farklı durumları tek bir tip altında toplayan toplam tipler ise enum ile tanımlanır. match ifadesi, bir değerin olası tüm biçimlerini kapsamlı biçimde ele almayı zorunlu kılar; böylece gözden kaçan bir durum derleme sırasında yakalanır. Aşağıdaki örnek bir enum ve onu işleyen bir match yapısını gösterir.
enum Durum {
Basarili(u32),
Hata(String),
}
fn isle(durum: Durum) -> String {
match durum {
Durum::Basarili(kod) => format!("basarili: {}", kod),
Durum::Hata(mesaj) => format!("hata: {}", mesaj),
}
}
fn main() {
println!("{}", isle(Durum::Basarili(200)));
println!("{}", isle(Durum::Hata(String::from("bulunamadi"))));
}Hata Yönetimi: Result ve Option
Rust, hataları yönetmek için istisna (exception) mekanizması yerine tip sistemine dayalı bir yaklaşım benimser. Bir değerin var olup olmadığını Option<T> tipi (Some veya None) ile, bir işlemin başarılı olup olmadığını ise Result<T, E> tipi (Ok veya Err) ile ifade eder. Bu, hataların görmezden gelinmesini zorlaştırır; çünkü sonucu kullanmadan önce olası hata durumunu ele almak gerekir.
Hata yayılımını sadeleştirmek için ? operatörü kullanılır. Bir ifadenin sonucu Err ise fonksiyon o hatayı doğrudan çağırana döndürür; Ok ise içindeki değerle devam eder. Bu, derin iç içe denetimler yazmadan temiz bir hata yönetimi akışı kurmayı sağlar. Aşağıdaki örnek, bir metni sayıya çevirip olası hatayı yayan bir fonksiyonu gösterir.
fn iki_kati(metin: &str) -> Result<i32, std::num::ParseIntError> {
let sayi: i32 = metin.parse()?;
Ok(sayi * 2)
}
fn main() {
match iki_kati("21") {
Ok(deger) => println!("sonuc: {}", deger),
Err(e) => println!("cevirme hatasi: {}", e),
}
}Rust Ekosistemi: Cargo ve Crates
Rust'ın benimsenmesini kolaylaştıran etkenlerden biri, dille birlikte gelen tutarlı araç zinciridir. Paket yöneticisi ve derleme aracı Cargo, yeni proje oluşturmaktan bağımlılık eklemeye, test çalıştırmaktan belge üretmeye kadar pek çok işi tek bir komut setiyle yürütür. Bağımlılıklar, projenin kök dizinindeki Cargo.toml dosyasında bildirilir ve topluluk paketleri crates.io üzerinden indirilir.
Araç zinciri yalnızca derlemekle kalmaz, kalite için de standart bir temel sunar. cargo fmt kodu ortak bir stile biçimlendirir, cargo clippy ise yaygın hataları ve daha iyi yazım biçimlerini statik olarak önerir. Aşağıdaki tablo, günlük geliştirmede en sık kullanılan Cargo komutlarını özetler.
| Komut | İşlevi |
|---|---|
| cargo new | Yeni bir proje oluşturur |
| cargo build | Projeyi derler |
| cargo run | Projeyi derleyip çalıştırır |
| cargo test | Testleri çalıştırır |
| cargo clippy | Statik analizle öneriler sunar |
Eşzamanlılık ve Korkusuz Paralellik
Rust, eşzamanlı programlamayı güvenli hale getirme hedefini korkusuz eşzamanlılık (fearless concurrency) olarak adlandırır. Ownership ve ödünç alma kurallarının aynı mantığı iş parçacıkları arasında da uygulanır; böylece birçok dilde çalışma zamanında ortaya çıkan veri yarışı (data race) hataları, Rust'ta derleme sırasında yakalanmaya çalışılır. Send ve Sync gibi işaretleyici özellikler (marker traits), hangi tiplerin iş parçacıkları arasında güvenle paylaşılabileceğini tip düzeyinde belirler.
Pratikte eşzamanlılık, standart kütüphanedeki iş parçacıklarıyla ya da async ve await anahtar sözcükleriyle yazılır. Eşzamansız model, çok sayıda ağ bağlantısını az kaynakla yönetmek gereken yüksek performanslı servislerde yaygındır ve genellikle Tokio gibi bir çalışma zamanı kütüphanesiyle birlikte kullanılır. Rust'ın buradaki temel vaadi, yüksek performansı güvenlik garantilerinden ödün vermeden sunmasıdır.
Trait'ler ve Jenerik Programlama
Rust'ta davranışların paylaşılması trait adı verilen yapılarla sağlanır. Bir trait, farklı tiplerin uygulayabileceği ortak bir yetenek kümesini tanımlar; bu yönüyle diğer dillerdeki arayüz kavramına benzer. Bir tip bir trait'i uyguladığında, o trait'in gerektirdiği metotları sağlamak zorundadır ve böylece tip güvenli bir çok biçimlilik elde edilir.
Trait'ler, jeneriklerle birlikte kullanıldığında Rust'ın ifade gücünü ortaya koyar. Jenerik bir fonksiyon, yalnızca belirli bir trait'i uygulayan tiplerle çalışacak biçimde sınırlandırılabilir (trait bound). Ayrıca #[derive(...)] ile bazı yaygın trait'ler otomatik olarak türetilebilir. Aşağıdaki örnek, basit bir trait ve onu uygulayan bir tipi gösterir.
trait Selamla {
fn selam(&self) -> String;
}
struct Kisi {
ad: String,
}
impl Selamla for Kisi {
fn selam(&self) -> String {
format!("Merhaba, {}", self.ad)
}
}
fn duyur<T: Selamla>(oge: &T) {
println!("{}", oge.selam());
}
fn main() {
let k = Kisi { ad: String::from("Ada") };
duyur(&k);
}Edition Sistemi ve Topluluk
Rust'ın geriye dönük uyumluluğa verdiği önem, edition adı verilen bir mekanizmayla sağlanır. Edition'lar, dile daha büyük değişiklikler getirirken mevcut kodu bozmamayı amaçlar; bir proje, kendi edition'ını belirterek o sürümün kurallarıyla derlenir. Böylece ekosistem, eski kodu geçersiz kılmadan ileriye doğru evrilebilir. Bu yaklaşım, uzun ömürlü projelerde güven veren önemli bir tasarım kararıdır.
Dilin gelişimi açık bir süreçle, RFC belgeleri üzerinden ve geniş bir topluluğun katkısıyla yürütülür. Cargo, crates.io ve ayrıntılı resmi belgeler, yeni başlayanların hızlıca üretken olmasını kolaylaştırır. Rust topluluğu, öğretici ve kapsayıcı bir kültürüyle de bilinir; bu, dilin öğrenme eğrisini aşmada önemli bir destek sağlar.
Rust'ın Performans Yaklaşımı

Rust, yüksek seviyeli ve okunabilir kod yazmayı sağlarken bunun için performanstan ödün vermemeyi hedefler. C++'tan devraldığı sıfır maliyetli soyutlama ilkesi gereği, kullanılan üst düzey yapılar (yineleyiciler, trait'ler ve closure'lar) elle yazılmış düşük seviyeli koda yakın makine kodu üretir. Çöp toplayıcının bulunmaması, çalışma zamanında öngörülemeyen duraklamaların önüne geçer; bu da gecikmenin kritik olduğu sistemlerde önemli bir avantajdır.
Bellek güvenliğinin derleme sırasında sağlanması, çalışma zamanına ek bir denetim yükü bindirmez. Bu sayede Rust programları hem hızlı hem de öngörülebilir biçimde çalışır. Performans kazanımı yalnızca hızla sınırlı değildir; güvenlik garantileri, uzun ömürlü servislerde beklenmedik çökmeleri azaltarak bakım ve işletme maliyetini de düşürebilir.
Yine de her soyutlamanın bir tasarım maliyeti vardır. Ownership kurallarını karşılamak bazen ek düşünme gerektirir; ancak bu çaba, çalışma zamanında ortaya çıkabilecek pahalı hataları baştan önlediği için birçok ekip tarafından değerli bulunur. Rust'ın öne çıktığı alanlar, genellikle bu dengenin anlamlı olduğu yerlerdir.
- Düşük gecikmeli ağ servisleri ve arka uç sistemleri
- Oyun motoru bileşenleri ve grafik işleme
- Gömülü ve kaynağı kısıtlı sistemler
- Tarayıcı ve işletim sistemi bileşenleri
Rust ile İlk Projeye Başlamak
Rust'a başlamanın en kolay yolu, Cargo ile yeni bir proje oluşturmaktır. cargo new proje_adi komutu, çalışmaya hazır bir dizin yapısı ve örnek bir program üretir; cargo run ise projeyi derleyip çalıştırır. Bu akış, bağımlılık eklemeyi, test yazmayı ve derlemeyi tek bir tutarlı araç altında topladığı için yeni başlayanların hızlıca üretken olmasını sağlar.
İlk adımlardan sonra, küçük ama gerçek bir hedef belirlemek öğrenmeyi hızlandırır. Örneğin bir komut satırı aracı yazmak, hem ownership kavramlarını hem de hata yönetimini doğal bir bağlamda uygulamaya olanak tanır. Derleyicinin verdiği ayrıntılı hata mesajları bu süreçte güçlü bir rehber işlevi görür.
Rust Ekosisteminde Yaygın Kütüphaneler
Rust ekosistemi genç olmasına rağmen, günlük geliştirmede ihtiyaç duyulan birçok alanda olgun kütüphanelere sahiptir. Veriyi serileştirmek ve farklı biçimler arasında dönüştürmek için serde, eşzamansız programlama için Tokio çalışma zamanı, web servisleri için Actix ve Axum gibi çatılar yaygın olarak kullanılır. Bu kütüphaneler, crates.io üzerinden kolayca projeye eklenir.
Komut satırı araçları, ağ programlama ve veri işleme gibi alanlarda da güçlü seçenekler bulunur. Kütüphanelerin çoğu, Rust'ın güvenlik ve performans ilkelerini benimseyerek tasarlanmıştır; bu da farklı bağımlılıkların bir arada tutarlı biçimde çalışmasını kolaylaştırır. Ekosistemin olgunlaşması, Rust'ın giderek daha fazla üretim ortamında tercih edilmesini sağlamaktadır.
Sık Sorulanlar
Rust öğrenmek zor mu?
Rust'ın ownership ve ödünç alma kavramları, başka dillerden gelenler için başlangıçta zorlayıcı olabilir. Bu kavramlar kavrandığında ise derleyici, hataların çoğunu önceden yakaladığı için güvenle kod yazmayı kolaylaştırır.
Rust, C++'ın yerini alır mı?
Rust, C++'ın güçlü olduğu birçok alanda alternatif sunar ve özellikle bellek güvenliği konusunda avantaj sağlar. Ancak C++'ın olgun ekosistemi ve mevcut kod tabanları nedeniyle iki dil çoğu zaman birlikte var olmaya devam eder.
Rust çöp toplayıcı kullanır mı?
Hayır. Rust, bellek güvenliğini çalışma anında bir çöp toplayıcıyla değil, derleme sırasında ownership kurallarıyla sağlamaya çalışır. Bu, öngörülebilir performans ve düşük çalışma zamanı yükü sağlar.
Rust hangi işletim sistemlerinde çalışır?
Rust; Windows, Linux ve macOS başta olmak üzere birçok platformu hedefler. rustup aracı, farklı hedef platformlar için derleme desteğini kurmayı kolaylaştırır; ayrıca WebAssembly ve gömülü sistemler gibi hedefler de desteklenir.
Rust ile web geliştirilebilir mi?
Evet. Sunucu tarafında Actix ve Axum gibi çatılarla yüksek performanslı API'ler yazılabilir; istemci tarafında ise Rust, WebAssembly'ye derlenerek tarayıcıda çalışan performans kritik modüller için kullanılabilir.
Rust öğrenmek için önce başka bir dil bilmek gerekir mi?
Şart değildir, ancak yardımcı olur. Değişken, fonksiyon ve veri yapısı gibi temel programlama kavramlarına aşina olmak, ownership gibi Rust'a özgü konulara odaklanmayı kolaylaştırır. Topluluğun hazırladığı ücretsiz resmi kitap, sıfırdan başlayanlar için de uygundur.