Domain Türetilmiş Tipler ve Performans: Project Valhalla'nın Oyunu Nasıl Değiştirdiği

Java'da domain-driven mimarisi tasarlayan herkes bilir: tip güvenliği istiyorsun, ama performans kaybetmek istemezsin. PositiveInt gibi bir tip oluşturmak istiyorsun—hiçbir zaman negatif olamayacak bir sayı. Derleyicinin hatalı değerleri reddetmesini istiyorsun. Ama sonra sıcak yola çıkıyorsun.

Milyonlarca olayı işleyen bir processor, her biri PositiveInt taşıyarak. İşte o zaman bu güvenli wrapper nesneleri bir soruna dönüşüyor—başına 16 byte overhead, milyonlarca heap tahsisi, cache satırlarında çarpışmalar. Yıllar boyunca geliştiriciler şu kuralı takip ettiler: türleri sınırda ayıkla, performans kritik koduna gelmeden önce onları bırak.

Project Valhalla bu kuralı değiştirmek üzere.

Sorun: Wrapper Maliyeti

Basit bir wrapper olan PositiveInt HotSpot'ta 16 byte tutuyor—12 byte nesne başlığı artı 4 byte değer (ya da JDK 25+ ile compact header'larda 8 byte). Şimdi bunun bir milyonunu bir diziye koyarsın. Dizi değerleri doğrudan depolamaz; bu heap nesnelerine referansları depolar. Her referans bir pointer takibi, her takip muhtemel bir cache miss anlamına geliyor.

Matematik acımasız: wrapper'ın koruduğu primitive'in belleği 4 katı tutuyor. Rastgele erişim desenleri sorunu daha kötü yapıyor—her erişim bellekte başka bir yere pointer takibi demek, CPU cache'den faydalı verileri atmak demek.

Bu ağrılı bir mimar sınırlaması yaratıyordu. Domain primitifleri API sınırlarında harika çalışıyordu, input kontrol ederken ve değişmezleri kurarken. Ama veriyi sıcak bir döngüden geçirttiğin andan itibaren—akışları işlerken, koleksiyonları dönüştürürken, sayısal algoritmalar çalıştırırken—ham int veya long'a geri dönerdin ve tip güvenliğini kaybederdin.

Çözüm eksik kalmıştı.

Value Sınıfları: Güvenlik, Maliyet Yok

Java 27 Early Access'te şimdi kullanılabilen Project Valhalla, value anahtar kelimesini getiriyor. Normal sınıflardan farklı olarak (kimliği olan, heap tahsisi gerektiren), value sınıfları kimlik-bağımsız. JVM onları primitive gibi davranıyor—her yerde satır içi yerleştirebiliyor: dizi içinde, nesne alanlarında, CPU register'larında.

Böyle görünüyor:

public value class PositiveInt {
    private final int value;

    public PositiveInt(int value) {
        if (value <= 0) {
            throw new IllegalArgumentException("pozitif olmalı: " + value);
        }
        this.value = value;
    }

    public int value() { 
        return value; 
    }
}

Sözdizimi normal bir sınıfla neredeyse aynı. Kurucu hala çalışıyor. Doğrulama hala gerçekleşiyor. Statik güvence kalıyor: PositiveInt gördüğün her yerde, değerin pozitif olduğunu bilirsin.

Ama büyü burada: JVM o 4 byte'lık int'i doğrudan dizi slotu, nesne alanı veya register'a satır içi yerleştirebiliyor. Nesne başlığı yok. Dolaylılık yok. Cache miss yok.

Pratikten Örnek: Çok Alanlı Value Sınıfları

Value sınıfların gücü tek primitive'i aşıyor. Bir Coordinate value sınıfını düşün: Latitude ve Longitude içeriyor, her biri bir double tarafından destekleniyor:

public value class Coordinate {
    private final Latitude latitude;
    private final Longitude longitude;

    public Coordinate(Latitude latitude, Longitude longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }
}

Geleneksel mimar yapısında üç seviye dolaylılık olur: Coordinate'e bir tane, her bir Latitude ve Longitude'ye birer tane. Value sınıf mimarisinde, her iki double beraber oturur—16 byte sıkıştırılmış veri, sıfır pointer, sıfır cache miss.

Coğrafi veriyi ölçekte işleyen her uygulama için—harita servisleri, hava durumu analizi, konum takibi—bu, tip güvenliğinden hiç ödün vermeden verimde kat sayılı artış demek.

Türleri Geliştirmek, Performansı Kaybetmek Yok

Bu, daha önce yasak olan bir tasarım deseni açıyor: iyileştirilmiş tipleri (iş kurallarını kodlayan tipler) algoritmaların derinliklerine gömmek.

NameOcean'da bunu sürekli düşünüyoruz. Domain kaydı, doğrulama içeriyor—geçerli domain isimleri, fiyatlandırma sınırları, kullanılabilirlik pencereleri. Bugün API sınırında doğrulayıp iç tarafta stringler ya da sayılarla çalışıyor olabilirsin. Value sınıflarla şunu tanımlayabilirsin:

public value class DomainName {
    private final String value;

    public DomainName(String value) {
        if (!isValidDomain(value)) {
            throw new IllegalArgumentException("Geçersiz domain: " + value);
        }
        this.value = value;
    }
}

public value class Tld {
    private final String value;

    public Tld(String value) {
        if (!isValidTld(value)) {
            throw new IllegalArgumentException("Geçersiz TLD: " + value);
        }
        this.value = value;
    }
}

Şimdi milyonlarca domain araması DNS çözümleme hattından geçirtebilirsin—JVM bu value sınıfları ham stringlerle aynı bellek kapladığında dönüştürdüğü için—tip güvenliği garantileriyle tüm yol boyunca.

Tip Güvenliğinin Avantajı

Performansın ötesinde, value sınıfları Java geliştirme için önemli birşeyi geri getiriyor: derleme-zamanı doğruluğu. Bu arayüz deseni düşün:

public interface RefinedInt<T extends RefinedInt<T>> extends Comparable<T> {
    int value();

    default int compareTo(T that) {
        return Integer.compare(this.value(), that.value());
    }
}

public value class Probability implements RefinedInt<Probability> {
    private final double value;
    // ...
}

public value class Price implements RefinedInt<Price> {
    private final long value;
    // ...
}

F-bounded generics'le (T extends RefinedInt<T> deseni), derleyici seni Probability'i Price'la karşılaştırmaktan korur. İş kavramlarını yanlışlıkla karıştıramassın. Bu sınırı teorik olarak hep sağlamlı idi, ama wrapper overhead'i domain tiplemeleri derinlemesine kullanmayı caydırmışken pratik hale gelmiyordu.

Value sınıflar bunu pratik yapıyor.

Mimarini Anlamına Gelenler

NameOcean'ın Vibe Hosting gibi AI-destekli altyapılı platformlarda bulut uygulamaları oluşturan geliştiriciler için, value sınıflar performans optimizasyonunu nasıl düşünüyorsun değişiyor:

• Sınır doğrulaması artık sıcak-yol performansıyla çatışmıyor
• Tip güvenliği kozmetik katmandan tüm kodunuza ölçekleniyor
• Domain-driven tasarım teorik safılık yerine pratik verimli hale geliyor

İş kurallarını doğrudan tip sisteminize kodlayabilir, JVM'e performans sonuçlarını halletmesine izin verebilirsin. Artık doğruluk ve hız arasında seçim yapmıyorsun.

Ufukta Gelen

Project Valhalla hala preview'dedir (Java 27 EA), ama yön açık. Value sınıflar Java LTS sürümlerinde istikrara kavuştuğunda, ciddi Java mimarilerinin temelinde yer alacaklar.

Bugün sistem tasarlarsan, iyileştirilmiş tiplerin kodunuzda hiç performans cezası olmadan nereye yerleşebileceği hakkında düşün. Sınırda bir kere doğrulayıp sonra güvensiz primitive'lerle mi çalışıyorsun? Bunlar yarının value sınıfları adayları.

Tip güvenliği ve performans arasındaki uyuşmazlık gidiyor. Domain primitive'lerini yeniden düşünmek için güzel bir zaman.

Yüksek performanslı sistemler modern altyapıda oluşturmak istiyorum mu? NameOcean'ın Vibe Hosting, bulut uygulamalar için AI-destekli optimizasyon sağlıyor. Value sınıfların modern cloud-native mimaride nasıl yeraldığını keşfet.