Skip to main content

Swift 6–6.1–6.2 ile Gelen Yenilikler, Detaylar ve Örnek Kullanımlar

00:08:47:20

Veri Yarışı Güvenliği (Data-Race Safety)

Veri yarışları (data races), çoklu iş parçacığı (thread) kullanımı sırasında aynı veriye farklı iş parçacıklarının eş zamanlı erişimi sonucu oluşan hatalardır. Bu tür hatalar, beklenmeyen sonuçlara yol açabilir ve uygulamanın çökmesine neden olabilir. Swift 6, veri yarışlarını derleme zamanında tespit ederek, geliştiricilerin bu tür hataları daha kolay ve hızlı şekilde önlemesine yardımcı olur.

Veri yarışı durumu için bir örnek verelim. Örneğin iki iş parçacığı aynı anda bakiyeyi okur ve her biri 1000 TL'ye 1 TL eklemeye çalışır. Ancak, her iki işlem de aynı anda yapıldığı için, her ikisi de 1000 TL'yi okur ve sadece bir artış kaydedilir, bu da 1001 TL'ye neden olur. Bu tür race condition durumları için Swift 5.5 ile gelen async/await yapıları kullanılıyor. Bu yapı, işlemleri asenkron hale getirerek, her iki iş parçacığının aynı anda veriye erişmesini engelliyor. Ayrıca, actor türü kullanarak veriye yalnızca bir iş parçacığının erişmesini sağlayarak veri yarışlarını önlenebiliyor. Swift 6'dan itibaren @concurrent ve @isolation gibi yeni özelliklerle veri yarışlarını engellemek için kullanılan bu yapılar geliştirilmiştir.

@concurrent

@concurrent özelliği, bir kod bloğunun eşzamanlı (concurrent) çalışmasını sağlamak için kullanılır. Yani, işlemlerin paralel çalışmasına olanak tanır. Bu özellik, özellikle asenkron kodlar için önemlidir çünkü, eşzamanlı çalışacak olan işlemleri paralel olarak çalıştırmak isteriz ve her birinin ayrı iş parçacıklarında çalışmasını sağlarız.

@concurrent kullanımının gerekliliğine bir örnek:

swift
func fetchDataFromAPI1() async -> String {
    await Task.sleep(2 * 1_000_000_000) // API 1'den veri çekme simülasyonu
    return "Data from API 1"
}

func fetchDataFromAPI2() async -> String {
    await Task.sleep(3 * 1_000_000_000) // API 2'den veri çekme simülasyonu
    return "Data from API 2"
}

@concurrent // Bu satırla işlemi eşzamanlı olarak çalıştırıyoruz
func fetchDataConcurrently() async {
    async let data1 = fetchDataFromAPI1() // API 1'den veri çek
    async let data2 = fetchDataFromAPI2() // API 2'den veri çek

    // Sonuçları bekle
    let results = await [data1, data2]
    print("Fetched data: \(results)")
}
  • @concurrent anahtar kelimesi, fetchDataConcurrently fonksiyonunun içinde işlemlerin paralel olarak yapılmasını sağlar. Yani, hem fetchDataFromAPI1() hem de fetchDataFromAPI2() eşzamanlı olarak başlatılır.
  • async let ile her iki işlem paralel olarak başlatılır, ancak işlem sonuçları beklenir ve sonunda tek bir yerde toplanır.
  • Eğer @concurrent kullanmasaydık, işlemler sırayla yapılacak ve bir işlem tamamlanmadan diğer işlem başlamayacaktı. Bu da her iki işlem için toplam süreyi artırırdı. (async await yapısıyla asenkron işlem yapabiliyoruz ayrıca @concurrent sayesinde işlemleri paralel olarak gerçekleştirebiliyoruz.)

@isolation

@isolation, verinin yalnızca tek bir iş parçacığı tarafından erişilmesini garanti eder. Bu, daha sıkı bir izolasyon sağlar. Yani, bir actor'da veri üzerine yapılan işlemler bazen birbirinden bağımsız olabilir ve bu durum @isolation kullanılarak daha sıkı bir şekilde kontrol altına alınabilir.

actor yapısı, aslında veri yarışlarını engeller; ancak bazen veriye erişimi sadece belirli bir iş parçacığıyla sınırlamak isteyebiliriz.@isolation, actor'a ek bir koruma ekler ve veri erişimini yalnızca tek bir iş parçacığının gerçekleştirmesini sağlar. Bu, daha güçlü ve belirgin bir veri izolasyonu sağlar. Bir örnek verelim:

swift
actor Counter {
    @isolation private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

let counter = Counter()

Task {
    async let task1 = counter.increment() // İlk artış işlemi
    async let task2 = counter.increment() // İkinci artış işlemi

    await task1
    await task2
    
    let value = await counter.getValue() // Sonuç: 2, doğru
    print(value)
}
  • Burada @isolation ile value değişkeni, yalnızca tek bir iş parçacığı tarafından erişilecek şekilde sıkı bir şekilde izole edilir.
  • Bu durumda, increment() işlemi tek bir iş parçacığı tarafından gerçekleştirilir ve veri yarışları önlenmiş olur.
  • Sonuç olarak, value değişkeni 2 olur, çünkü her iki işlem de düzgün bir şekilde sırasıyla yapılır.

@defaultIsolation

@defaultIsolation, bir actor içindeki tüm veri üyelerinin varsayılan izolasyon seviyesini belirler. actor içindeki tüm değişkenler ve fonksiyonlar bu varsayılan izolasyon seviyesine tabi olur. Yani, @defaultIsolation tanımlandığı zaman, altındaki veri üyeleri (değişkenler) ve fonksiyonlar da bu izolasyon kuralına uygun şekilde çalışır. Kullanım örneği:

swift
actor Counter {
    @defaultIsolation private var value = 0  // Varsayılan izolasyon
    private var anotherValue = 10  // Bu da @defaultIsolation ile izole olur

    func increment() {
        value += 1
        anotherValue += 1
    }

    func getValue() -> Int {
        return value
    }
}
  • @defaultIsolation kullanarak, value ve anotherValue değişkenlerinin her ikisi de aynı izolasyon seviyesinde çalışır.
  • value değişkeni üzerinde @defaultIsolation ile belirlenen izolasyon seviyesi, anotherValue değişkenine de uygulanır.
  • Yani, @defaultIsolation kullanıldığında, tüm veri üyeleri aynı izolasyon seviyesine tabi olur ve veri erişiminde bir tutarlılık sağlanır.

Yeni Veri Yapıları ve Makrolar

Swift 6, veri yapıları ve makrolar konusunda bir dizi önemli geliştirme getirdi. Bu yenilikler, hem bellek yönetimini daha verimli hale getiriyor hem de hata ayıklama süreçlerini hızlandırıyor. Ayrıca, düşük seviyeli bellek erişimi ile ilgili daha fazla esneklik sağlıyor.

InlineArray Veri Yapısı

InlineArray, sabit boyutlu diziler için özel bir veri yapısıdır. Swift 6 ile tanıtılan bu özellik, sabit boyutlu dizilerin daha verimli bir şekilde bellek tahsisi yapmasına olanak tanır. Bu diziler, yığın bellek (stack memory) kullanılarak daha hızlı hale gelir. Swift'teki Array yapısı, dinamik olarak boyutlanabilen bir koleksiyon türüdür. Yani, bir Array ile birden fazla öğe depolayabiliriz ve bu öğeler sürekli olarak eklenip çıkarılabilir. Bu tür diziler, genellikle heap bellek üzerinde saklanır (yani, dinamik bellek kullanımı). Ancak, InlineArray yapısı, sabit boyutlu diziler için optimize edilmiştir ve bu diziler stack bellek üzerinde saklanır. Bu, özellikle küçük dizilerle çalışırken bellek ve performans avantajları sağlar.

Peki heap bellek ve stack bellek nedir ona bakalım:

InlineArray Kullanımı:

swift
// InlineArray kullanımı
@inlineable
func createInlineArray() -> [Int] {
    let inlineArray: [Int] = [1, 2, 3, 4, 5]
    return inlineArray
}

let array = createInlineArray()
print(array) // Çıktı: [1, 2, 3, 4, 5]
  • @inlineable: Bu özellik, diziyi daha verimli hale getirir ve dizinin performansını artırır.
  • Bellek: InlineArray sabit boyutlu diziler için stack bellek üzerinde depolanır, bu da hızlı bellek erişimi sağlar.

Hata Yönetimi ve String İşleme Özellikleri

Swift 6, yazılım geliştirme sürecini daha verimli hale getirmek amacıyla özellikle hata yönetimi ve string işleme konularında önemli iyileştirmeler getirdi. Bu özellikler, hataları daha hızlı tespit etmeyi, anlamlı hata mesajları almayı ve metin işleme işlemlerini daha hızlı ve esnek hale getirmeyi sağlıyor.

Yeni Hata Yönetimi Özellikleri

Swift 6, yeni hata türleri sunarak hata kontrolünü daha detaylı ve açıklayıcı hale getirdi. Artık daha spesifik ve anlamlı hata türleri tanımlanabiliyor. Bu, geliştiricilerin karşılaştıkları hataları daha iyi anlamalarına ve daha hızlı bir şekilde çözüm üretmelerine yardımcı olur.

  • Hata Türlerinin Daha Ayrıntılı Tanımlanması: Daha geniş hata kategorileri ve daha açık hata türleri, hata mesajlarını daha anlamlı hale getirir. Örneğin, NetworkError veya FileReadError gibi özelleştirilmiş hata türleri, hatanın ne olduğunu daha net bir şekilde belirtir.
  • Hata Mesajlarının İyileştirilmesi: Hata mesajları daha açıklayıcı hale getirildi. Bu sayede, geliştiriciler hata mesajlarından daha fazla bilgi alabilir ve hataların kaynağını daha kolay bulabilir.

String İşleme İyileştirmeleri

Swift 6 ile gelen string işleme özellikleri, metin üzerinde yapılan işlemleri daha verimli hale getirmeyi amaçlıyor. En önemli yeniliklerden biri, regex (düzenli ifadeler) desteği ve Unicode iyileştirmeleri.

Regex Desteği

Düzenli ifadeler (regex), belirli bir desenle eşleşen metinleri bulmak ve işlemek için yaygın olarak kullanılır. Swift 6, regex desteği ekleyerek string işleme işlemlerini çok daha kolay ve verimli hale getiriyor.

  • Regex (Düzenli İfadeler): Swift 6, stringlerde arama yapmak, desen eşleştirmek ve metin manipülasyonu yapmak için regex desteği sunuyor.

Örnek Regex Kullanımı:

swift
import Foundation

let text = "Swift 6 is amazing, Swift is fun!"

// Regex ile "Swift" kelimesini arıyoruz
let regex = try! NSRegularExpression(pattern: "Swift", options: [])
let range = NSRange(location: 0, length: text.utf16.count)

let matches = regex.matches(in: text, options: [], range: range)

for match in matches {
    let matchString = (text as NSString).substring(with: match.range)
    print("Found match: \(matchString)")
}

Açıklama: Burada, Swift 6'daki regex desteği ile "Swift" kelimesini metin içinde arıyoruz. Bu özellik sayesinde, düzenli ifadelerle metin arama ve eşleştirme işlemleri çok daha kolay hale gelmiştir.

Unicode İyileştirmeleri

Swift 6 ile birlikte Unicode desteği daha da güçlendirilmiştir. Özellikle çoklu dil ve semboller içeren stringlerin işlenmesi daha verimli hale gelmiştir.

  • Unicode Güçlendirmeleri: String manipülasyonunda farklı dil ve semboller arasında uyum daha kolay sağlanabilir. Swift 6, Unicode karakterlerini doğru bir şekilde işleyebilmek için daha sağlam bir altyapı sunar.

Yeni Hedef Platformlar: WebAssembly ve Gömülü Sistemler

Swift 6 ile gelen en önemli yeniliklerden biri de WebAssembly (WASM) ve gömülü sistemler için destek eklenmesidir. Bu, Swift'in yalnızca masaüstü ve mobil cihazlar için değil, aynı zamanda tarayıcı tabanlı uygulamalar ve daha düşük seviyeli, kaynak sınırlı sistemler gibi farklı platformlarda da kullanılabilmesini sağlıyor.

WebAssembly (WASM) Desteği

WebAssembly, web uygulamalarında çalışan yüksek performanslı kodlar yazabilmek için geliştirilmiş bir teknolojidir. WebAssembly, web tarayıcılarında yerel uygulama hızında çalışan, düşük seviyeli ve verimli bir bytecode biçimidir. WebAssembly, özellikle CPU yoğun uygulamalar için tarayıcıda yüksek performans sağlamak amacıyla kullanılır.

Swift 6.2 ile WebAssembly desteği eklenerek, Swift ile yazılmış uygulamaların tarayıcı üzerinde çalışabilmesi sağlanmıştır. Bu, Swift’i tarayıcı tabanlı uygulamalara taşır ve özellikle hız ve verimlilik açısından önemli iyileştirmeler sunar.

Swift ile WebAssembly kullanımı aşağıdaki gibi olabilir. Swift'in mevcut WebAssembly hedef platformları ile çalışabilmek için belirli araçlar ve derleyiciler gereklidir. Ancak örnek olarak, temel bir Swift WebAssembly uygulaması şöyle görünebilir:

swift
import WebAssembly

// Basit bir fonksiyon
public func add(a: Int, b: Int) -> Int {
    return a + b
}

// WebAssembly ile çalışacak şekilde derlenecek ve tarayıcıda çalışacak

Gömülü Sistemler Desteği

Gömülü sistemler, belirli bir işlevi yerine getirmek için tasarlanmış, sınırlı kaynaklara sahip özel bilgisayar sistemleridir. Örnekler arasında mikrodenetleyiciler, IoT cihazları (Internet of Things), robotlar, otomotiv sistemleri ve medikal cihazlar yer alır.

Swift 6 ile gömülü sistemler desteği, Swift’i düşük seviyeli sistemlerde kullanabilmeyi sağlar. Gömülü sistemler, genellikle daha az bellek ve daha düşük işlem gücü gereksinimi duyar. Swift’in bu platformlar için optimize edilmesi, daha verimli ve yüksek performanslı uygulamaların geliştirilmesini mümkün kılar.

Aşağıdaki örnekte, bir mikrodenetleyici üzerinde Swift ile LED yakma işlemi gerçekleştirebiliriz. Tabii ki, bu örneği gerçekleştirebilmek için gömülü cihazda Swift çalıştırılabilir bir ortam gereklidir.