Merhaba değerli takipçilerim,

Gelecekte Python, Java, .NET, C, C++, JavaScript gibi günümüz dillerinden Rust ve Go programlama dillerine geçiş olacağı kanaatindeyiz. Bu programlama dilleri Java, .NET ve NodeJS’ye göre doğrudan assembly’e derlendikleri için daha hızlıdır. Nesne yönelimli programlama dilleri bir hataydı diye savunanlar var. O yüzden Rust ve Go eski tip prosedürel programlama ile multithreaded mimarilerini birleştirmiş. Bu yüzden Go programlama dili Java’dan ve .NET’ten daha hızlıdır ve onlardan daha güvenlidir.

Ancak Rust Go’dan da hızlıdır, Rust C ve C++ ile aynı performansı sergiler. Go programlama dilinde Garbage-Collector bulunmaktadır ve bu Garbage-Collector tüm uygulamayı yavaşlatmaktadır.

Rust’ta garbage-collector bulunmaz, buna karşın ona ihtiyaç olmadan da benzeri hafıza güvenliğini sağlar. Böylece Rust, eski C ve C++ kadar hızlı olmasına karşın memory-leak sorunu olmayacak şekilde tasarlanmıştır.

Bu makaleyi Rust’a hızlıca bir göz gezdirmek için hazırladım:

fn main() {
    println!("Merhaba dünya"); // Rust'ta makrolar ünlem (!) işareti ile çağrılır
}

Şimdi de hello_world adında bir fonksiyon tanımlayalım:

fn main() {
    hello_world();
}

fn hello_world() {
    println!("Merhaba dünya");
}

Rust’da Değişken Tipleri

Rust’ta değişken tipleri, temelde iki kategori altında toplanabilir: önceden belirlenmiş veri tipleri ve özelleştirilmiş (custom) veri tipleri. İşte Rust’ta yaygın olarak kullanılan değişken tipleri:

  1. Önceden Belirlenmiş (Primitive) Veri Tipleri:
    • Tamsayı Tipleri: i8, i16, i32, i64, i128 (işaretli tamsayılar), u8, u16, u32, u64, u128 (işaretsiz tamsayılar).
    • Ondalık Sayı Tipleri: f32, f64 (ondalık sayılar).
    • Mantıksal Tipler: bool (mantıksal değerler: true veya false).
    • Karakter Tipleri: char (Unicode karakterler).
  2. Özelleştirilmiş (Custom) Veri Tipleri:
    • Tuple (Demet) Tipleri: Farklı tipteki değerleri bir araya getirir.
    • Dizi Tipleri: Sabit boyutlu, aynı tipteki değerlerden oluşan veri yapıları.
    • Yapı (Struct) Tipleri: Alan adları ile belirli tipteki değerleri içeren veri yapıları.
    • Enum (Enumerasyon) Tipleri: Belirli bir veri türünden birden fazla değeri gruplayan tipler.
    • Referans (Reference) Tipleri: Varolan bir değeri ödünç almak veya paylaşmak için kullanılır.
    • Kod Bloğu Tipleri: Bir kod bloğunun son ifadesinin değeri.

Rust, tür güvenliği konusunda oldukça titizdir. Bu nedenle, değişken türleri genellikle derleme zamanında belirlenir ve tür uyumsuzlukları derleme sırasında hatalara neden olur. Bu da programlarınızın daha güvenli ve hatasız olmasına yardımcı olur.

Şimdi de değişkenlerin nasıl tanımlandığına bakalım:

fn main() {
    // Tamsayı Tipleri
    let num_i8: i8 = 42;
    let num_i16: i16 = 12345;
    let num_i32: i32 = -67890;
    let num_i64: i64 = 9876543210;
    let num_i128: i128 = -123456789012345678901234567890;

    // Ondalık Sayı Tipleri
    let num_f32: f32 = 3.14;
    let num_f64: f64 = 2.71828;

    // Mantıksal Tipler
    let is_true: bool = true;
    let is_false: bool = false;

    // Karakter Tipleri
    let char_a: char = 'a';
    let char_heart: char = '❤';

    // Tuple (Demet) Tipleri
    let person: (String, i32, bool) = ("Alice".to_string(), 30, true);

    // Dizi Tipleri
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];

    // Yapı (Struct) Tipleri
    struct Person {
        name: String,
        age: i32,
    }
    let person_struct = Person {
        name: "Bob".to_string(),
        age: 25,
    };

    // Enum (Enumerasyon) Tipleri
    enum Color {
        Red,
        Green,
        Blue,
    }
    let favorite_color = Color::Blue;

    // Referans (Reference) Tipleri
    let x = 42;
    let x_ref = &x;

    // Kod Bloğu Tipleri
    let result = {
        let a = 5;
        let b = 7;
        a + b
    };

    println!("i8: {}", num_i8);
    println!("i16: {}", num_i16);
    println!("i32: {}", num_i32);
    println!("i64: {}", num_i64);
    println!("i128: {}", num_i128);
    println!("f32: {}", num_f32);
    println!("f64: {}", num_f64);
    println!("bool (true): {}", is_true);
    println!("bool (false): {}", is_false);
    println!("char 'a': {}", char_a);
    println!("char '❤': {}", char_heart);
    println!("Tuple: {:?}", person);
    println!("Array: {:?}", numbers);
    println!("Struct: {:?}", person_struct);
    println!("Enum: {:?}", favorite_color);
    println!("Reference: {}", x_ref);
    println!("Code Block: {}", result);
}

Sizi bilmem ama ben Rust’ı çok sevdim. Linux ta sevdi. Mark Zuckerberg Diem kriptopara projesini Rust ile hazırlamıştı. Daha geçen gün Elon Musk Yapay Genel Zeka’yı Rust ile hazırlamalıyız dedi.

Neden Rust?

  1. C ve C++ gibi çok hızlı,
  2. Çok kalite bir derleyicisi var, daha kodlama aşamasında tüm hataları tespit edebiliyor,
  3. Mikroçip, yapay zeka, blockchain, kuantum projeleri dahil her proje için uygun,
  4. Hafıza güvenliği konusunda en iyisi,
  5. Dil özellikleri çok gelişmiş.

Dezavantajları

  • Öğrenmesi zor,
  • çok bellek istiyor,
  • ve nesne-yönelimli değil yani class’lara, interface’lere veda ediyoruz.

Mutlu kodlamalar 🙂