OpenJDK ‘Project Detroit’ (FFM ile V8 ve CPython), Spring Boot Yerel ‘Cloud Foundry / kind’ Orkestrasyonu ve Quarkus 4.0 Mimarisi

Kurumsal Java Ekosisteminde Üç Mimari Atılım: Süreç İçi Yabancı Çalışma Zamanları, Yerel PaaS ve Quarkus 4.0

Modern Java platformu, yalnızca kendi dil sınırları içinde evrimleşmekle kalmayıp yabancı dil ekosistemlerini (Python / PyPI ve JavaScript / V8) doğrudan JVM süreci içine bağlayan düşük seviyeli köprüler, yerel geliştirici makinelerinde çalışan bulut-yerel PaaS orkestrasyonları ve yeni nesil ağ/veri standartlarıyla (HTTP/3 QUIC, Jakarta Data 1.1, Hibernate ORM 8) yeniden şekilleniyor. Inside.java, Spring.io ve kurumsal Java ekosisteminde yayımlanan üç kritik gelişme bu mimari dönüşümü özetliyor:

1. OpenJDK ‘Project Detroit’ (Yabancı Kütüphanelerden Yabancı Dil Çalışma Zamanlarına): Maurizio Cimadamore tarafından Devoxx Belgium kapsamında detaylandırılan ve Project Panama'nın Foreign Function & Memory (FFM) API'sini kullanarak Google V8 ile CPython çalışma zamanlarını doğrudan aynı JVM süreci içinde çalıştıran yeni OpenJDK projesi.
2. Spring Ekosisteminde Yerel PaaS Orkestrasyonu (This Week in Spring — Docker, kind ve Cloud Foundry): Josh Long tarafından paylaşılan Kasım 2026 bülteninde; Kubernetes in Docker (kind), Cloud Foundry (cf CLI) ve yapay zeka ajanları kullanılarak Spring Boot uygulamalarının yerel geliştirme ortamında sıfır sürtünmeyle üretim PaaS topolojisine dağıtılması.
3. Quarkus 4.0 GA ve Hibernate ORM 8.0 Hizalanması: Kasım 2026 sonunda genel kullanıma (GA) sunulacak olan Quarkus 4.0'ın Java 21 tabanı, Vert.x 5 / Netty 4.2 reaktif ağ çekirdeği, deneysel HTTP/3 (QUIC) desteği, Jackson 3 / CDI 5.0 geçişi ve Hibernate ORM 8.0 / Jakarta Data 1.1 entegrasyonu.

1. OpenJDK ‘Project Detroit’: FFM API Üzerinden JVM İçinde Doğrudan ‘V8’ ve ‘CPython’

Java ekosistemi uzun yıllar boyunca diğer programlama dillerini desteklemek için o dillerin yorumlayıcılarını JVM bayt kodunda sıfırdan yeniden yazma (reimplementation) stratejisini izledi. JDK 8 ile gelen Nashorn JavaScript motoru veya Jython bunun en bilinen örnekleriydi. Ancak bu yaklaşım iki yapısal duvara çarptı: hızla evrilen dil standartlarına (ECMAScript ve modern Python 3.x) yetişmenin bakım maliyeti ve daha da önemlisi C/C++ eklentilerine dayanan devasa paket ekosistemlerinin (PyPI üzerindeki PyTorch/NumPy veya yerel npm modülleri) saf JVM yeniden yazımlarında çalışamaması. Bu nedenle Nashorn JDK 11'de kullanımdan kaldırıldı ve JDK 15'te tamamen silindi.

Inside.java'da yayımlanan "Project Detroit: From Foreign Libraries to Foreign Language Runtimes" incelemesi, OpenJDK'nın bu sorunu çözmek için başlattığı yeni nesil mimariyi ortaya koyuyor.

flowchart TD
    subgraph Pillar1["1. OpenJDK Project Detroit (FFM & Süreç İçi Runtimes)"]
        D1["javax.script API & Project Panama FFM (Linker / Arena)"]
        D2["Aynı İşletim Sistemi Sürecinde Yerel Google V8 & CPython"]
        D3["Çapraz GC Senkronizasyonu & Virtual Thread Pinning Önleme"]
        D1 --> D2 --> D3
    end

    subgraph Pillar2["2. Spring Boot Yerel PaaS (Docker + kind + Cloud Foundry)"]
        S1["Spring Boot Uygulaması & Paketo Cloud Native Buildpacks"]
        S2["Docker Üzerinde kind (Kubernetes in Docker) + Korifi / CF"]
        S3["Ajan Destekli 'cf push' ve Yerel Üretim Topolojisi Testi"]
        S1 --> S2 --> S3
    end

    subgraph Pillar3["3. Quarkus 4.0 GA & Hibernate ORM 8.0 Yığını"]
        Q1["Java 21 Tabanı + Vert.x 5 + Netty 4.2 + HTTP/3 (QUIC)"]
        Q2["Jackson 3 + CDI 5.0 Derleme Zamanı Enjeksiyonu"]
        Q3["Hibernate ORM 8.0 + Jakarta Persistence 4.0 & Data 1.1"]
        Q1 --> Q2 --> Q3
    end

Project Detroit Mimarisi ve Çözülen Üç Derin Mühendislik Problemi

Project Detroit, bir dili JVM üzerinde baştan yazmak yerine Project Panama ile standartlaşan Foreign Function & Memory (FFM) API (java.lang.foreign) katmanını kullanarak endüstri standardı yerel çalışma zamanlarını (JavaScript için Google V8, Python için CPython) doğrudan aynı JVM işletim sistemi süreci (in-process) içine gömüyor ve bunları standart javax.script API'si üzerinden Java geliştiricilerine sunuyor.

Maurizio Cimadamore'un teknik analizinde vurguladığı üzere, iki farklı çalışma zamanını aynı süreç içinde birleştirmek üç kritik sistem mühendisliği zorluğunu beraberinde getiriyor:

1. Çapraz Çöp Toplama (Cross-Runtime Garbage Collection): JVM'in kendi çöp toplayıcısı (G1 / ZGC) ile V8'in çöp toplayıcısı veya CPython'un referans sayma (reference counting + döngüsel GC) mekanizması birbirinden habersiz çalışıyor. Bir Java nesnesi bir Python nesnesine, o Python nesnesi de geri bir Java geri çağrısına (upcall stub) referans tuttuğunda süreçler arası döngüsel bellek sızıntıları (cross-heap cyclic leaks) veya erken silinen bellek segmentleri (use-after-free) oluşmaması için deterministik Arena yaşam döngüsü bağlamaları geliştiriliyor.
2. Sanal İş Parçacığı Sabitlemesi (Virtual Thread Pinning): Bir Java sanal iş parçacığı (VirtualThread), FFM üzerinden uzun süren veya G/Ç bekleyen bir yerel CPython/V8 fonksiyonunu çağırdığında ve o yerel kod tekrar Java'ya geri çağrı (upcall) yaptığında taşıyıcı işletim sistemi iş parçacığının (carrier thread) bloke edilmemesi için zamanlayıcı koordinasyonu gerekiyor.
3. Durum ve İzolasyon (GIL ve V8 Isolate Yönetimi): Çok iş parçacıklı JVM ortamı ile CPython'un Global Interpreter Lock (GIL) veya Sub-interpreter (PEP 684) yapısı ve V8'in tek iş parçacıklı Isolate modeli arasında güvenli bağlam anahtarlama (context switching) köprüleri kuruluyor.

2. Spring Ekosisteminde Yerel PaaS: Docker, ‘kind’ ve Ajan Destekli Cloud Foundry

Josh Long tarafından kaleme alınan "This Week in Spring - November 3rd, 2026" bülteni, kurumsal mikroservis geliştirmede "yerel geliştirme ortamı ile üretim platformu arasındaki uçurum" sorununa odaklanıyor.

Büyük ölçekli kurumlarda uygulamalar üretimde Cloud Foundry veya çok katmanlı Kubernetes kümeleri üzerinde çalışırken, geliştiricilerin yerel makinelerinde yalnızca çıplak bir java -jar süreci çalıştırması; ağ politikaları, servis bağlamaları (service bindings), sağlık kontrolleri ve konteyner katmanlandırma hatalarının ancak uzak CI/CD boru hatlarında fark edilmesine yol açıyor.

kind (Kubernetes in Docker) ve cf push Otomasyonu

Spring ekibinin sergilediği modern yerel platform mimarisi üç bileşeni birleştiriyor:

• Yerel Kubernetes Omurgası (kind): Docker konteynerlerini Kubernetes düğümleri (nodes) olarak kullanan kind, saniyeler içinde yerel bir kontrol düzlemi ayağa kaldırıyor.
• Kubernetes Üzerinde Cloud Foundry Deneyimi: Cloud Foundry soyutlama katmanı (Korifi / yerel CF dağıtımı) kind kümesi üzerine kurularak, standart Spring Boot (DemoApplication) projelerinin tek bir cf push komutuyla Paketo Cloud Native Buildpacks üzerinden OCI konteyner imajına dönüştürülüp yerel kümeye dağıtılmasını sağlıyor.
• Yapay Zeka Ajanlarıyla Altyapı Hazırlığı: Küme sertifikalarının üretilmesi, yerel DNS/Ingress yönlendirmelerinin yapılandırılması ve cf CLI kimlik doğrulaması gibi tekrarlayan platform mühendisliği adımları otonom kodlama ajanları tarafından betikleştirilerek geliştirici makinesinde tek adımlı bir PaaS deneyimi sunuluyor.

3. Quarkus 4.0 GA ve Hibernate ORM 8.0: Vert.x 5, HTTP/3 (QUIC) ve Jakarta Data 1.1

Kasım 2026'nın son haftasında Genel Kullanıma (GA) açılması planlanan Quarkus 4.0 (Ekim ayındaki 4.0.0.Beta1 kilometre taşının ardından), kurumsal Java çerçevelerinde son yılların en kapsamlı alt sistem yenilemesini gerçekleştiriyor:

1. Java 21 Minimum Tabanı ve Sanal İş Parçacıkları: Quarkus 4.0, minimum JDK gereksinimini Java 21 LTS seviyesine çekerek sanal iş parçacıklarını (Virtual Threads), yapılandırılmış eşzamanlılığı ve FFM API yeteneklerini çekirdek varsayılanı haline getiriyor.
2. Vert.x 5, Netty 4.2 ve Deneysel HTTP/3 (QUIC): Çerçevenin reaktif G/Ç omurgası Vert.x 5 ve Netty 4.2 sürümlerine yükseltiliyor. Bu geçişle birlikte UDP üzerinde çoklu akış (multiplexing) ve sıfır gidiş-dönüşlü (0-RTT) TLS el sıkışması sunan deneysel HTTP/3 (QUIC) protokol desteği devreye giriyor.
3. Hibernate ORM 8.0, Jakarta Persistence 4.0 ve Jakarta Data 1.1: Veri katmanında Hibernate ORM 8.0 entegrasyonu ile birlikte Jakarta Persistence 4.0 ve Jakarta Data 1.1 standartları destekleniyor. Ayrıca serileştirme katmanı Jackson 3'e, bağımlılık enjeksiyonu ise CDI 5.0 spesifikasyonuna taşınıyor.

Mühendislik Uygulaması: Project Detroit Tarzı FFM ‘CPython/V8’ Köprüsü ve Arena Yaşam Döngüsü

Aşağıdaki referans Java uygulaması, Project Detroit mimarisinin temelini oluşturan Project Panama FFM API (Linker, SymbolLookup, Arena, MemorySegment, FunctionDescriptor) mekanizmasını kullanarak yerel bir çalışma zamanı bağlamını (NativeRuntimeIsolate) sınırlı bellek arenasıyla yöneten ve sanal iş parçacığı uyumlu deterministik temizleme (AutoCloseable) sağlayan mimariyi göstermektedir:

package com.tastutanlabs.architecture.detroit;

import java.lang.foreign.Arena;
import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SymbolLookup;
import java.lang.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * OpenJDK Project Detroit tarzı FFM API (Project Panama) tabanlı
 * Yabancı Dil Çalışma Zamanı (CPython / V8) Arena ve İzolasyon Yöneticisi.
 */
public class ProjectDetroitForeignRuntimeBridge {

    public enum RuntimeEngine {
        CPYTHON_3_14("python3", "Py_Initialize", "PyRun_SimpleString"),
        GOOGLE_V8("v8", "V8_Initialize", "V8_ExecuteScript");

        private final String libraryName;
        private final String initSymbol;
        private final String evalSymbol;

        RuntimeEngine(String libraryName, String initSymbol, String evalSymbol) {
            this.libraryName = libraryName;
            this.initSymbol = initSymbol;
            this.evalSymbol = evalSymbol;
        }

        public String libraryName() { return libraryName; }
        public String initSymbol() { return initSymbol; }
        public String evalSymbol() { return evalSymbol; }
    }

    /**
     * Çapraz GC sızıntılarını önlemek için deterministik FFM Arena ile sınırlandırılmış
     * süreç içi (in-process) yabancı dil çalışma zamanı bağlamı.
     */
    public static final class ScopedForeignRuntimeContext implements AutoCloseable {
        private final RuntimeEngine engine;
        private final Arena runtimeArena;
        private final Map<String, MemorySegment> pinnedHandles = new ConcurrentHashMap<>();
        private boolean closed = false;

        public ScopedForeignRuntimeContext(RuntimeEngine engine) {
            this.engine = engine;
            // Paylaşımlı ancak deterministik olarak kapatılabilen FFM bellek arenası
            this.runtimeArena = Arena.ofShared();
        }

        public MemorySegment allocateUtf8ScriptBuffer(String scriptId, String sourceCode) {
            ensureOpen();
            MemorySegment nativeString = runtimeArena.allocateFrom(sourceCode);
            pinnedHandles.put(scriptId, nativeString);
            return nativeString;
        }

        public long measureNativeStandardLibraryStrlen(String scriptContent) {
            ensureOpen();
            Linker nativeLinker = Linker.nativeLinker();
            SymbolLookup stdlib = nativeLinker.defaultLookup();
            MemorySegment strlenAddr = stdlib.find("strlen")
                .orElseThrow(() -> new IllegalStateException("Yerel strlen sembolü bulunamadı."));

            MethodHandle strlenHandle = nativeLinker.downcallHandle(
                strlenAddr,
                FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
            );

            try {
                MemorySegment cString = runtimeArena.allocateFrom(scriptContent);
                return (long) strlenHandle.invokeExact(cString);
            } catch (Throwable t) {
                throw new RuntimeException("FFM downcall yürütme hatası", t);
            }
        }

        public String diagnosticSummary() {
            return String.format(
                "Engine=%s | InitSymbol=%s | PinnedBuffers=%d | ArenaActive=%s",
                engine.name(), engine.initSymbol(), pinnedHandles.size(), !closed
            );
        }

        private void ensureOpen() {
            if (closed) {
                throw new IllegalStateException("Yabancı çalışma zamanı arenası kapatıldı.");
            }
        }

        @Override
        public void close() {
            if (!closed) {
                pinnedHandles.clear();
                runtimeArena.close();
                closed = true;
            }
        }
    }

    public static void main(String[] args) {
        try (ScopedForeignRuntimeContext cpythonCtx =
                 new ScopedForeignRuntimeContext(RuntimeEngine.CPYTHON_3_14)) {

            String pythonSnippet = "import numpy as np; result = np.linalg.norm([3.0, 4.0])";
            MemorySegment scriptSeg = cpythonCtx.allocateUtf8ScriptBuffer("calc_norm", pythonSnippet);
            long byteLen = cpythonCtx.measureNativeStandardLibraryStrlen(pythonSnippet);

            System.out.println("=== Project Detroit FFM Köprü Durumu ===");
            System.out.println(cpythonCtx.diagnosticSummary());
            System.out.println("Yabancı Bellek Segment Adresi: 0x" + Long.toHexString(scriptSeg.address()));
            System.out.println("FFM Native strlen Doğrulaması (Byte): " + byteLen);
        }
    }
}

Mimari Değerlendirme

OpenJDK'nın Project Detroit hamlesi, Java dünyasının diğer dillerle kurduğu ilişkiyi "rekabet ve yeniden yazma" ekseninden çıkarıp FFM API üzerinden sıfır kopyalı süreç içi birlikte çalışabilirlik (in-process interoperability) düzeyine taşıyor. Bu sayede kurumsal Java uygulamaları Python'un yapay zeka kütüphanelerini veya V8'in JavaScript ekosistemini harici mikroservis ağ gecikmesi olmadan doğrudan çağırabilecek. Eşzamanlı olarak Spring Boot + kind / Cloud Foundry yerel PaaS iş akışları ve Quarkus 4.0 / Hibernate 8 yığını, geliştirici dizüstü bilgisayarından HTTP/3 tabanlı üretim kümelerine kadar uçtan uca modernleştirilmiş bir kurumsal Java omurgası sunuyor.