Rust Training

Rust ile ilgili temelden orta seviyeye eğitim vermek istesem hangi konuları hangi örneklerle ele alırdım sorusuna cevap aradığım repodur.

Buradaki konular ile ilgili birde Youtube serimiz var. "Birlikte Rust Öğrenelim"

Konular

S koduyla başlayan projelerde aşağıdaki konu başlıkları ele alınmıştır. Orijinal sıralama için youtube video serisine bakabilirsiniz. Buradaki kodlar anlatımları desteklemek amacıyla kullanılır.

• [x] S00 - Hello World
• [x] S01 - Variables, Mut and Scalar Types
• [x] S02 - Vectors and Slices
• [x] S03 - String and &str
• [x] S04 - Functions
• [x] S05 - Control Flows
• [x] S06 - Ownership and Move
• [x] S07 - Structs
• [x] S08 - Lifetimes
• [x] S09 - Enums
• [x] S10 - Pattern Matching
• [x] S11 - Generics
• [x] S12 - Traits
• [x] S13 - Built-In Traits
• [x] S14 - Modules, Crates, Packages
• [x] S15 - Error Handling
• [x] S16 - Testing
• [x] S17 - Closures
• [x] S18 - Smart Pointers (Box, Rc ve RefCell)
• [x] S19 - Concurrency (Threads, Arc ve Mutex)
• [x] S20 - Channels, Deadlock & Thread Poisoning
• [x] S21 - Macros
• [x] S22 - Parallelism (Sequential vs Thread Based vs With Rayon)
• [x] S23 - Asynchronous Programming
• [x] S24 - File I/O Operations
• [x] S25 - Stream Operations
• [x] S26 - Unsafe Zone
• [ ] S27 - Wasm (Web Assembly)

Yardımcılar

Rust dilinde isimlendirme standartları (Naming Conventions) da kod okunurluğu ve genel uyumluluk açısından önemlidir. Aşağıdaki isimlendirme önerilerine ait bilgilerin yer aldığı bir tablo bulunmaktadır.

S03 bölümünde string slice (&str) ve string literal karmaşası için ek bilgi.

S06 Ownership bölümünde Copy ve Clone trait'lerinden bahsedilmektedir. Burada Copy ve Clone arasındaki farkı da bilmek gerekir. Bu kavramlar bellekte veri çoğaltma işlemleriyle ilgilidir, ancak işleyişleri ve kullanım alanları farklıdır.

• Copy
  • Copy özelliği, i32, f64, bool, char gibi küçük ve sabit boyutlu türlerde kullanılır.
  • Bir türün Copy davranışına sahip olması, onun bellekte kopyalanmasının çok hızlı ve maliyetsiz olduğunu da gösterir. (Shallow Copy) işlemi de diyebiliriz.
  • Copy işlemi, sadece basit ve küçük veri türleri için geçerlidir. String veya Vec gibi büyük veri yapıları tutmaya aday yapılar Copy davranışı sergilemezler, çünkü bunların derin kopyalanması (Deep Copy) gerekir.
• Clone
  • Clone, bir veri yapısının derin kopyasını (Deep Copy) oluşturur. Verinin içeriği kopyalanarak yeni bir alan yaratılır.
  • Clone operasyonu daha maliyetlidir çünkü veri yapısının tamamının kopyalanmasını gerektirir.
  • String ve Vec gibi heap üzerinde veri tutan yapılar Clone trait implementasyonu kullanır (String türünün koduna bakılabilir).

Burada Shallow Copy ile Deep Copy kavramları zaman zaman birbirlerine karıştırılır. Shallow copy tekniğinde verinin sadece yüzeysel kopyalanması söz konusuru. Sadece adres işaretçisi (pointer) veya adres bilgisi kopyalanır. Ancak gösterilen asıl veri (heap'teki veri) kopyalanmaz. Bu durumda, hem orijinal hem de kopyalanan veri yapısı aynı heap alanını işaret eder.

Rust dilinde kullanılan i32, f64, bool, gibi basit türler stack alanında depolandığı için kopyalanmaları shallow copy gibidir keza verinin kendisi doğrudan kopyalanır ve heap'e erişim yoktur.

Deep copy dediğimizde ise verinin tamamının yani hem işaretçilerin hem de heap üzerindeki asıl verinin kopyalanmasını söz konusudur. Bu yeni bir bellek alanı tahsis edilmesi ve orijinal verinin açılan yeni alana tamamen kopyalanması demektir. Çok doğal olarak bunun bir maliyeti vardır. İşlem sonrasında orijinal veri ile kopyalanan veri birbirlerinden bağımsız kullanılabilirler.

Bir String nesnesi oluşturulduğunda, içerik bir vektör olarak karakter seti halinde heap bellek bölgesinde tutulur. Sadece shallow copy yapılırsa birbirine atanan iki string de aynı heap alanını işaret ederdi. Rust dilinde String veri türü Copy trait'ini bilinçli olarak uygulamaz ve bu tip referans eşleşmelerini zaten istemez. Ancak clone() metodu kullanılarak Deep Copy yapılabilir ve heap üzerindeki karakter serisi yeni bir alana kopyalanır.

S07 Struct konusunu işlerken dikkat edilmesi gereken bir kavram karmaşası var. Fonksiyon mu metot mu? Metotlar, fonksiyonlara benzer ancak metotlar esasında bir Struct Context'ine dahildir ve struct ile ilişkilendirilerler.

S14 isimli bölümde package, crate ve module kavramlarına kısaca değiniyoruz. Her uygulama çözümünde olduğu gibi rust tarafından da projelerin organizasyonu mümkün. Aşağıdaki şema bunu desteklemek amacıyla kullanılabilir.

Bir e-commerce sisteminin olduğunu düşünelim. Burada birçok işlevi içeren kütüpahenelerimiz bu kütüphaneleri referans olarak alan ve kullanan başka binary'lerimiz olabilir. Bir backend kütüphaneler topluluğu ve bir web uygulaması ya da api servisi olduğunu düşünelim. Klasik senaryo... En dış bloğu workspace olarak düşünebiliriz. Kendi Cargo.toml dosyasını içeren bir klasördür aslında. Diğer projeler (library ve binary türleri) bu workspace altına açılabilir. C# tarafındakiler için Workspace'in bir Solution olarak düşünülebileceğini söylesem sanırım yeterli olacaktır. Workspace aynı zamanda bir Package olarak da yorumlanabilir. Paketler birden fazla kütüphane barındıran toplu çözümlerdir. Crates.io sisteminde bu tip birçok kullanışlı paket yer alır. Bir paket içerisinde yer alan library ve binary'ler birer Crate olarak da düşünülebilir. Crate'ler içerisinde modüller (Modules) ve hatta alt modüller (Sub Modules) yer alır. Çalıştığımız projelerin structure iskeletini görebilmek cargo-modules aracından yararlanabiliriz.

cargo install cargo-modules

# ve örneğin
cargo modules structure --package S14_modules

Bu kullanım aşağıdakine benzer bir çıktı üretir.

S18' de ele alınan Smart Pointer konusu ile ilgili bazı notlar;

Pointer bellek üzerindeki bir veri bölgesini işaret eden adres bilgisini taşıyan değişken olduğunu tanımlanabilir.

Farkında olmadan şu ana kadar kullandığımız bir işaretçi de vardır esasında. Birçok yerde & sembolü ile datayı referans ederek kullandığımızı fark etmiş olmalısınız. Smart Pointer'lar ise işaretçilerin taşıdığı adresler bilgilerine ek farklı metadata bilgileri veya kabiliyetler içerirler. Aslında bu konu Rust diline özel bir kavram değildir ve esasen C++ orijinli bir unsurdur. Referanslar (yani & ile kullandığımız değişkenler) veriyi işaret ederken Smart Pointer’ lar genellikle verinin sahipliğini de alır (Sürpriz! String ve Vec türleri smart pointer olarak da geçer zira belli bir bellek adresindeki verinin sahipliğini alırlar ve onu manipüle etmemize izin verirler) * Deref ve Drop* trait’lerini implemente eden struct türleri olarak düşünebiliriz. Bir başka deyişle kendi Smart Pointer modellerimizi tasarlayabiliriz.

Rust standart kütüphanesinde bilinen ve sık kullanılan bazı Smart Pointer yapıları ise sırasıya Box < T > , * Rc < T > ve RefCell < T > orijinli Ref < T > ile RefMut < T > türleridir. Box nesnesi, değişken verisi için Heap' te yer ayrılmasına izin verir. Bunu normal şartlarda stack'e alınan bir veri türü için Heap' te yer ayrılmasına ve işaret edilmesine benzetebiliriz. Ne var ki asıl senaryolar daha farklı olabilir. Örneğin çok büyük bir verinin sahipliğinin taşınırken bu işin kopyalanmadan gerçekleştirilmesini istediğimiz durumlarda işe yarar. Rc işaretçisi birden fazla sahiplik (ownership) imkanı sağlayan ve bu referansları sayan türdendir. Burada sahiplik kalmayıncaya kadar aynı veriyi sahiplenen n sayıda referans olabileceğini ifade edebiliriz. Rust' ın resmi dokümanı bu konuda Tv odası örneğini verir. Televizyon Rc < T >* nesnesidir ve odaya gelen biri televizyonu açar. Odaya gelen diğer insanlar da televizyonu izleyebilir. En son kişi odadan çıkınca da televizyonu kapatır (Ya açık bırakıp giderse : P Olmuyor işte öyle bir şey) Burada Tv sahiplikleri de sayar ve kimse kalmayınca da kapanmış olur bir nevi belleten düşer diyebiliriz.

RefCell < T > türünün senaryosu ise biraz karışık gelebilir zira ödünç alma (borrowing) ilkelerinin derleme zamanı yerine çalışma zamanında (runtime) kullanılmasına olanak tanır. Neden böyle bir şeye ihtiyacımız olsun zira Rust' ın ana felsefesini çalışma zamanında niye kıralım gibi sorular aklımıza düşebilir elbette. Esasında bunun için gerekli senaryolar olur. Örneğin derleme zamanında izin verilmeyen ama memory safe olacağı garanti edilen bazı senaryoları çalışma zamanında işletmenin yolunu açar. Ancakkkk burada dikkat edilmesi gereken bir husus vardır. Herhangi bir ihlal çalışma zamanının panic! lemesine yol açar. Bu konuda Rust resmi kitabı kaynağı neredeyse 1900 yılına dayanan önemli bir problemi örnek gösterir. Dilimize Sonlanma Problemi olarak çevrilen Halting Problem. Bir programın sonsuz döngü halinde sonlanıp sonlanamayacağına karar verememesi gibi özetlenebilir sanıyorum ki ancak an itibariyle beni aşan bir konu. Zira hesaplanabilirlik kuramının bir parçası. Bolca matematik işte.

Smart Pointer kullanımı ile ilgili şöyle bir özet bilgi de verebiliriz.

S19' da ele alınmaya başlayan thread kavramı ayrıca Concurrency ve Parallel Programming gibi modellerle de yakın ilişkilidir. Bu noktada Concurrency (Eş Zamanlılık) ve paralel programlama modelleri arasındaki farkları da bilmek gerekir.

Concurrency modelinde temel amaç bir sistemin birden fazla görevi (task) yönetibilmesini veya reaksiyon verebilmesini sağlamaktır. Başlatılan görevler ya da işler aynı anda tamamlanmasa bile sistem sanki hepsini aynı anda çalıştırıyormuş gibi görünebilir. Esasında sistem başlatılan görevler arasında fark edilmeyecek kadar küçük zaman dilimlerinde geçişler yaparak planlı bir işleyişi yerine getirir. Bunu yaparken birden fazla thread kullanımı tekniklerden birisidir ama Event Loop yaklaşımının kullanıldığı da görülmektedir.

Parallel Programming modelinde amaç işlemleri (ya da hesaplamaları) aynı anda gerçekleştirmektir. Ancak bu yapılırken gerçekten de aynı anda çalışan fiziki iş parçacıkları söz konusudur. Dolayısıyla çekirdek sayısı ve buna bağlı kaynaklar (resources) bu metodolojide kilit noktadır. Örneğin büyük bir veri kümesinin sekiz parçaya bölünüp her parçanın bir CPU çekirdeği tarafından işlenmesi buna örnek gösterilebilir. Bu modelde thread'ler fiziksel olarak paralel şekilde çalıştırılır.