Merhabalar, yine blog yazılarıma uzun bir ara verdikten sonra kaldığım yerden devam ediyorum. Bu yazıda uzun süredir merakla takip ettiğim bir programlama dilinden bahsedeceğim. Bu programlama dilinin adı Rust. Yeni bir dil olmasına rağmen diğer dillerden farklı özellikleriyle sıyrılmasından dolayı, ben de Rust hakkında bir yazı yazmak istedim. Fakat unutmamamız gereken bir kısım var; Rust dili hala geliştirilmekte olduğundan dolayı, yazdığım şeyler ileride geçerliliğini yitirebilir. Ben bu yazıyı elimden geldiğince güncel tutmaya çalışacağım. Siz de ilerideki sürümlerle ilgili bir uyuşmazlık, sorun fark ederseniz benimle iletişime geçtiğiniz taktirde en kısa sürede güncellemeye çalışırım. Umarım bilgilendirici ve yararlı bir yazı olur. Bu yazıda Rust hakkında bazı bilgiler vereceğim da dil hakkındaki düşüncelerimi yazmaya çalışacağım. Artık girizgahımızı da yaptığımıza göre konumuza giriş yapabiliriz. 🙂

Rust Programlama Dili Hakkında Kısa Bilgiler ve Benim Naçizane Düşüncelerim

Rust Programlama dili; ilk önce, Mozilla çalışanı olan Graydon Hoare tarafından kişisel proje olarak geliştirilmeye başlanmış, daha sonra da Mozilla’nın 2009’da sponsor olmasıyla birlikte Mozilla Research tarafından günümüzde hala geliştirilmeye devam edilen bir programlama dilidir. İlk olarak 2010 yılında tanıtılmıştır ve aynı yıl; oCaml ile yazılmış ilk compiler’ından artık kurtularak, kendi dili ile yazılan compiler’ı(self hosted) ortaya çıkmıştır. Kendi kendisini ilk defa 2011 yılında başarılı bir şekilde compile etmiştir. Aynı zamanda merak edenler için bu bahsettiğimiz self-hosted compiler, LLVM altyapısı kullanmaktadır.

Rust’ın ilk kararlı sürümü olan 1.0, 15 Mayıs 2015’te yayımlandı. (Bu yazının yayımlanmasından yaklaşık 6 ay kadar önce) Bu tarihe bakacak olursak gerçekten daha çok yeni bir dil olduğu anlaşılabiliyor. Fakat 1.0 versiyonunun üzerinden bu kadar az zaman geçmesine rağmen 1.4 sürümü yayımlandı bile. Bunun nedeni de, Mozilla’nın Rust’ta Firefox’da da uygulandığı gibi 6 haftalık sürüm döngüsüne geçmesi. Yani bu demek oluyor ki, büyük ya da küçük update olmasına bakılmadan, Rust’a her 6 haftada bir update geliyor demek. Umarım önümüzdeki günlerde bu hızı da arkasına alarak arkasında community ile daha güzel yerlere gelir.

Artık Rust dilinin yapısal özelliklerine geçmemizin zamanı geldi. Rust diğer dillerden bir özelliği ile ayrılıyor. O da Rust’ın tam olarak orjinal bir dil olmaması. Her ne kadar önceki cümle rahatsız edici gözükse de, aslında bu iyi bir şey. Bunun nedeni de Rust’ın aslında diğer dillerin iyi özelliklerinin birleştirilmesinden ortaya çıkan bir melez dil olması. Örneğin, C++ dilinin hafıza referanslama ve destructor özellikleri, SML’in veri yapıları, Python’un lexer sistemi gibi özelliklerini alarak kendine uygun bir biçimde birleştirmiş ve sonuç olarak Rust gibi bir dil ortaya çıkmış. Tabi bu örneklerin arasında saymadığımız daha niceleri var. Aynı zamanda bazı dillerin kötü yanlarından da dersler çıkartarak onlara çözüm getirmiş. Mesela, C++’ın bellek güvenliği problemlerinden dersler çıkartarak bellek güvenliğini(memory safety) saplaması gibi.

Rust’ı diğer dillerden ayıran en büyük özellik bence varsayılan olarak memory safe bir dil olması. Peki memory safety nedir? Memory safety; bir dilin RAM’de bellek ayırırken herhangi bir açığa neden olmayacağından emin olduğu anlamına geliyor. C ve C++ gibi diller memory safe bir değillerdir (yani memory unsafe dillerdir.) Bunun nedeni de C ve C++ da pointerların olmasıdır. Örneğin C’de bir pointer tanımlayıp, daha sonra o pointer ile işiniz bittiğinde belleği serbest bırakmazsanız, o ayrılan veri belleğinizde kalacaktır ve bellek sızıntısı gibi açıklara neden olacaktır. Rust buna Borrowing (borç alma) ile bir çözüm getirmiş. C veya C’den esinlenilen bir dilden Rust’a geçiyorsanız karşılaşacağınız en büyük sorun da muhtemelen bu konuyu kavramakla ilgili olacaktır. Üstte verdiğim linkte detaylı bir şekilde öğrenebilirsiniz. Borrowing aslında ayrı bir makale konusu olacak kadar uzun olduğu için ona çok fazla değinmeden geçiyoruz. Fakat Rust’a ilginiz varsa mutlaka öğrenmenizi tavsiye ederim. Bazı yüksek seviyeli diller ise memory safe’dir fakat onlarda da memory unsafe yapılar olan Pointer, reference gibi yapıları bulunmamaktadır. Bu yüzden bu dillerde bellekte tam olarka kontrol elimizde değildir.

Rust’ın bir diğer temel özelliği de fonksiyonel bir dil olması. Yani nesneye yönelimli bir dil değil. Ben nesneye yönelimli bir dil olmadığını öğrenince çok büyük bir eksiklik gibi gelmişti. Fakat daha sonra Rust’daki gelişmiş Struct, trait ve implementation yapılarını gördüğümde nesneye yönelik bir dil olmamasının eksikliklerini gayet iyi bir şekilde giderdiklerini fark ettim. Örneğin diğer dillerde struct en basitinden belirli türlerde verileri depolayan bir yapıdır. Rust bunu bir adım öteye taşıyıp, aynı zamanda impl(implemetation) yapıları ile structlara fonksiyon ekleyebilme özelliği katmış. Onu da nasıl yapıyoruz dersek küçük bir kod örneği vereyim. Hem de Rust’ın sözdizimi bakımından bir örnek olur:

// Öncelikle Point adını verdiğimiz bir struct tanımlıyoruz
struct Point {
    x: f64,
    y: f64,
}

// Sonra da Point adlı struct'ımızın implementini yazıyoruz
impl Point {
    // Bu bir static metoddur.
    // Bu tür metodlar genel olarak constructor olarak kullanılır.
    fn origin() -> Point {
        Point { x: 0.0, y: 0.0 }
    }

    // 2 adet parametre alan başka bir metod.
    fn new(x: f64, y: f64) -> Point {
        Point { x: x, y: y }
    }
}

// Bu metodları nasıl kullandığımızı görelim
fn main() {
    let point1 = Point::origin();
    let point2 = Point::new(5.0, 6.5);
}

Görüldüğü üzere “fn” anahtar kelimesi fonksiyonları tanımlıyor. Parantez içindekiler alınan parametreler ve “->” işaretinden sonraki tür ise geri dönen değişken türünü gösteriyor. Eğer “->” ve sonrasını yazmazsak bir değer döndürmüyor anlamına geliyor. Buradaki origin ve new metodları ise Point adlı struct’a tanımlanarak constructor metodları gibi kullanılıyor. Tabi ki constructor olarak kullanılmak zorunda değil.

Kendimce güzel yerlerinden bahsetmeye çalıştım. Tabiki bunları yazarken aklıma gelmeyen birçok şey olabilir. Artık bundan sonraki yazılarımda değinmeye çalışırım. Şimdi kendimce kötü yanlarına değinme zamanı geldi. En büyük sorunlarından biri bence farklı olan syntax’ı diyebilirim. Eğer C gibi bir dilden Rust’a geçiyorsanız ilk bakışta C’yi andıracaktır fakat daha sonra derincelere indikçe o farkı hissedeceksiniz. En büyük syntax sorunlarından biri de her tarafta göreceğiniz “&” işareti. Borrowing özelliğinden dolayı bolca kullanmamız gereken bu karakter, tüm kodumuzu işgal etmeye başlayınca bir yerden sonra yeter artık diyebiliyorsunuz. Borrowing demişken, güzel bir özellik olması bir yana, daha yeni başlayanlar için kafa karıştırıcı olabiliyor. Hele ki C türevi bir dilden geliyorsanız. Bunu da bir dezavantaj olarak sayabiliriz.

Şimdilik kısa kısa; dilden, olumlu ve olumsuz yönlerinden bahsederek Rust dili ile ilgili küçük bir giriş yapmış olduk. Bundan sonraki yazılarımda Rust için önemli özellikler olan Ownership, Borrowing ve Lifetime‘dan bahsetmek istiyorum. Şimdilik benden bu kadar, umarım sizin için yararlı bir yazı olmuştur. Önümüzdeki yazılarda görüşmek üzere, kendinize iyi bakın 🙂