Bellek Güvenliği

BERK, Rust seviyesinde bellek güvenliği sağlayan modern bir sistem programlama dilidir. Segmentation fault'lar, null pointer dereference'lar ve buffer overflow'lar BERK'te compile-time'da yakalanır.

Temel Güvenlik Garantileri

1. Null Güvenliği

BERK'te null değerleri Seçenek (Option) tipi ile açıkça işlenir:

// ❌ Hata: Null olamaz
değişken isim: metin = boş  // Derleme hatası!

// ✅ Doğru: Seçenek kullan
değişken isim: Seçenek<metin> = Hiçbiri

eşleştir isim yap
    Bir(değer) => yazdır("İsim: " + değer),
    Hiçbiri => yazdır("İsim yok")
son

2. Sınır Kontrolü

Dizi erişimleri otomatik olarak kontrol edilir:

değişken sayılar = [1, 2, 3, 4, 5]

// ❌ Runtime hatası: Index out of bounds
değişken x = sayılar[10]  // Panic!

// ✅ Güvenli erişim
eğer 10 < sayılar.uzunluk() yap
    değişken x = sayılar[10]
yoksa yap
    yazdır("Geçersiz index")
son

3. Tip Güvenliği

Güçlü tip sistemi ile runtime hataları compile-time'da yakalanır:

// ❌ Hata: Tip uyuşmazlığı
değişken x: sayı = "merhaba"  // Derleme hatası!

// ❌ Hata: İmplicit dönüşüm yok
değişken y: kesir = 42  // Derleme hatası!

// ✅ Doğru: Açık dönüşüm
değişken y: kesir = 42.0
// veya
değişken y: kesir = kayıt(kesir, 42)

Sahiplik Sistemi (Ownership)

BERK, Rust'tan ilham alan bir sahiplik sistemi kullanır:

Temel Kurallar

1. Her değerin bir sahibi vardır
2. Aynı anda sadece bir sahip olabilir
3. Sahip kapsam dışına çıkınca değer otomatik temizlenir

Sahiplik Transferi (Move)

fonksiyon örnek() yap
    değişken metin1 = "Merhaba"
    değişken metin2 = geçir metin1  // Sahiplik transfer edildi
    
    // ❌ Hata: metin1 artık geçerli değil
    yazdır(metin1)  // Derleme hatası!
    
    // ✅ Doğru: metin2 şimdi sahip
    yazdır(metin2)
son

Referanslar (Paylaş)

fonksiyon uzunluk_bul(paylaş s: metin) -> sayı yap
    dön s.uzunluk()
son

fonksiyon örnek() yap
    değişken metin1 = "Merhaba"
    değişken len = uzunluk_bul(paylaş metin1)
    
    // ✅ Doğru: metin1 hala geçerli
    yazdır(metin1)  // Çalışır!
    yazdır("Uzunluk: " + len)
son

Değiştirilebilir Referanslar

fonksiyon büyüt(paylaş değiştirilebilir s: metin) yap
    s += " Dünya!"
son

fonksiyon örnek() yap
    değişken metin1 = "Merhaba"
    büyüt(paylaş değiştirilebilir metin1)
    yazdır(metin1)  // "Merhaba Dünya!"
son

Yaşam Süreleri (Lifetimes)

BERK derleyicisi, referansların geçerliliğini otomatik olarak kontrol eder:

// ❌ Hata: Dangling reference
fonksiyon hatalı() -> paylaş metin yap
    değişken yerel = "merhaba"
    dön paylaş yerel  // Derleme hatası! yerel scope dışına çıkacak
son

// ✅ Doğru: Sahipliği döndür
fonksiyon doğru() -> metin yap
    değişken yerel = "merhaba"
    dön geçir yerel  // Sahiplik transfer edildi
son

Bellek Yönetimi Stratejileri

1. Otomatik Bellek Yönetimi

Varsayılan olarak BERK otomatik bellek yönetimi kullanır:

fonksiyon örnek() yap
    değişken liste = [1, 2, 3, 4, 5]
    // Kullan...
son  // liste otomatik olarak temizlenir

2. Region-Based Memory (263x Daha Hızlı!)

kullan bölge::Bölge;

fonksiyon yüksek_performans() yap
    değişken bölge = yeni Bölge()
    
    için i içinde 0..1000000 yap
        değişken x = bölge.ayır(boyut_of(sayı))
        // Kullan...
    son
    
    bölge.temizle()  // Tek seferde tüm bellek serbest
son

3. Manuel Bellek Yönetimi (unsafe)

// Sadece çok özel durumlar için
güvensiz yap
    değişken ptr = ayır(1024)  // Raw pointer
    // Manuel yönetim...
    serbest_bırak(ptr)
son

Veri Yarışı Önleme

Tek Yazıcı veya Çoklu Okuyucu

// ❌ Hata: Aynı anda birden fazla değiştirilebilir referans
değişken x = 5
değişken ref1 = paylaş değiştirilebilir x
değişken ref2 = paylaş değiştirilebilir x  // Derleme hatası!

// ✅ Doğru: Çoklu immutable referans
değişken x = 5
değişken ref1 = paylaş x
değişken ref2 = paylaş x  // OK

Thread-Safe Veri Yapıları

kullan thread::Mutex;

değişken sayaç = yeni Mutex(0)

fonksiyon artır() yap
    değişken kilit = sayaç.kilit()
    *kilit += 1
    // Kilit otomatik serbest bırakılır
son

Yaygın Bellek Hataları ve Önleme

1. Use-After-Free

C/C++'ta:

int* ptr = malloc(sizeof(int));
free(ptr);
*ptr = 5;  // ❌ Use-after-free bug!

BERK'te:

değişken x = yeni 42
serbest_bırak(x)
yazdır(*x)  // ❌ Derleme hatası! x artık geçerli değil

2. Double Free

C/C++'ta:

int* ptr = malloc(sizeof(int));
free(ptr);
free(ptr);  // ❌ Double free bug!

BERK'te:

değişken x = yeni 42
serbest_bırak(x)
serbest_bırak(x)  // ❌ Derleme hatası! x artık geçerli değil

3. Buffer Overflow

C/C++'ta:

int arr[5];
arr[10] = 42;  // ❌ Buffer overflow!

BERK'te:

değişken arr = [0; 5]
arr[10] = 42  // ❌ Runtime panic! (debug modda)
              // Optimized modda bounds check yapılır

Akıllı İşaretçiler (Smart Pointers)

Kutu (Box) - Heap Tahsisi

değişken x = Kutu::yeni(42)
yazdır(*x)  // 42
// Kutu scope dışına çıkınca otomatik temizlenir

Rc (Referans Sayımlı)

kullan bellek::Rc;

değişken x = Rc::yeni(42)
değişken y = x.klon()  // Referans sayısı artar
// Her iki değişken de aynı veriyi gösterir
// Son referans yok olunca bellek temizlenir

Arc (Atomik Referans Sayımlı - Thread Safe)

kullan bellek::Arc;
kullan thread;

değişken veri = Arc::yeni(vec![1, 2, 3])

değişken thread1 = thread::spawn(geçir || yap
    yazdır(veri[0])
son)

değişken thread2 = thread::spawn(geçir || yap
    yazdır(veri[1])
son)

Performans vs Güvenlik

Debug vs Release Modu

Debug Modu

berk-lang build --debug

• ✅ Tüm güvenlik kontrolleri aktif
• ✅ Daha iyi hata mesajları
• ✅ Stack trace'ler
• ⚠️ Daha yavaş

Release Modu

berk-lang build --release

• ✅ Optimizasyonlar aktif
• ✅ En hızlı performans
• ✅ Temel güvenlik kontrolleri hala var
• ⚠️ Bazı debug bilgileri yok

Bellek Profiling

# Bellek kullanımını analiz et
berk-lang build --profile=memory

# Bellek sızıntılarını tespit et
berk-lang check-leaks program.berk

En İyi Uygulamalar

1. ✅ Varsayılan olarak sahiplik kullan

   değişken x = veri_al()  // Sahiplik transfer
   

2. ✅ Gerektiğinde referans al

   işle(paylaş x)  // Sadece okuma için
   

3. ✅ Seçenek kullan, null kullanma

   değişken değer: Seçenek<metin> = bul_kullanıcı()
   

4. ✅ Sonuç tipi ile hata yönetimi

   fonksiyon dosya_aç() -> Sonuç<Dosya> yap
   

5. ⚠️ Unsafe'i minimize et

   // Sadece çok gerekli yerlerde
   güvensiz yap
       // Dikkatli kod
   son
   

Özet

• ✅ Null güvenliği: Seçenek tipi ile
• ✅ Sınır kontrolü: Otomatik array bounds checking
• ✅ Tip güvenliği: Güçlü statik tiplemee
• ✅ Sahiplik sistemi: Memory leaks yok
• ✅ Yaşam süreleri: Dangling references yok
• ✅ Thread safety: Data races önleniyor
• ✅ Zero-cost abstractions: Güvenlik bedava değil ama çok ucuz
• ⚡ 263x daha hızlı: Region memory ile