No OpenJDK project has excited Java developers as much as Valhalla. And no other has strung us along for that long.But now the wait is over!
Value types are the first step to mending the rift in Java's type system and allow us the creation of more primitive-like classes. They will (likely) preview for the first time in JDK 28, so it's time to take a close look at:
- syntax and semantics of value types
- limitations and capabilities
- performance characteristics
- the next steps Valhalla is planning to take
After this talk, you'll know what value types can do in JDK 28 - and what they can't. And the latter is just as important because the trek to Valhalla is still long and value types are neither intended nor capable to fulfill all expectations we may have for the project at large.
The age of artificial intelligence (because the search for regular intelligence hasn't gone well..) is nearly at hand, and it's everywhere! But is it in your application? It should be. AI is about integration, and here the Java and Spring communities come second to nobody. In this talk, we'll demystify the concepts of modern day Artificial Intelligence and look at its integration with the white hot new Spring AI project, a framework that builds on the richness of Spring Boot to extend them to the wide world of AI engineering.
當 AI 加入軟體開發流程後，雖然產出變多了，但若是需求不清楚、邊界沒定義、驗收條件不明確時，即便模型聰明也可能產生看似合理、實際卻不符合期待的實作。而看似老派的測試方法論，在這樣的流程裡反而發揮關鍵的作用。
這場分享將從開發者熟悉的 TDD 經驗出發，重新理解 Spec-Driven Development（SDD）在 AI 時代的價值。SDD 將規格、設計、任務拆解、測試與實作串成完整的開發流程，並透過 TDD 驗證結果是否符合預期。我們將以 Java/Kotlin 專案中常見的開發情境為例，示範如何先定義功能規格、限制條件與驗收標準，再引導 AI Agent 產生測試與實作，並用測試回饋檢查產出是否真的對齊規格。
除了基礎流程外，也會討論如何透過增加 Context、Skill 等方式，讓 AI Agent 能更穩定地理解開發慣例與團隊工作流程。聽完這場演講後，聽眾將對 SDD 如何提升 AI 生成品質、協助團隊取得更穩定的開發成果有更進一步的認識，並重新思考在 AI Agent 時代，開發者應該如何守住規格、測試與品質責任。
在半導體電路設計（EDA）領域，C/C++ 統治了超過三十年，使用 Java 開發常被視為「不可能的任務」。然而過去十年，我們團隊從 JDK 8 一路推進到 JDK 25，正面挑戰 Java 在極致效能與超大容量的物理上限。我們經歷了早期效能與記憶體足跡落後 C/C++ 高達十倍的困境，一路優化到如今，這是一段 Java 在半導體頂尖戰場的逆襲心路歷程。
本場演講將深度解密我們如何突破 Java 原生極限，解決四大核心硬核挑戰：
- 擺脫包袱： 為什麼 Java Stream、Eclipse Collections 與 Guava 在極端場景不再敷使？我們如何改變使用思維與優化導向。
- 全手刻 EDA 資料庫： 面對 1TB RAM 伺服器、100M（億級）資料量，原生 HashMap 如何崩潰？解密高低密度欄位設計的記憶體佈局。
- 馴服 1TB 的 GC 巨獸： 經歷過 GC 停頓高達數分鐘的黑暗期，我們如何透過 Zero-allocation（零配置）與 GC Invisibility（GC 隱形）技術實現流暢運行，並重新設計高效率的生命週期管理。
- 打破 OOP 牆壁： 深入緊湊與壓縮物件的底層實踐，如何無情消除物件頭（Object Header）浪費，不讓物件導向成為效能絆腳石。
聽眾收穫：這趟旅程還在繼續。透過本場分享，您將帶走一套將 Java 推向硬體極限的底層優化思維，顛覆你對 Java 效能上限的既定認知。
2026 年釋出的 Java 版本為 26 和 27，各自包括了 10 和 9 項功能，其中有 10 項預覽功能（總共為 5 項）、6 項底層／效能改善、1 項安全性、1 項移除，和 1 項函式庫更新。相較於前幾版來說（25 有 18 項、24 有 24 項、23 和 22 各有 12 項、21 有 15 項，且多數為重大更新），今年的 Java 溫和安靜許多。本議程將介紹幾項 2026 年 Java 釋出的重要功能，以及如何運用它們以建立更穩健的程式。
Spring Boot applications often grow into layers of builders, null checks, utility classes, and repetitive mapping code. Kotlin removes much of that weight without replacing it with “magic.”
Join me for a practical introduction to Kotlin from the perspective of a Spring Boot developer. I will show how features like strict nullability, smart casts, extension functions, reified generics, and Kotlin DSLs make backend code safer, smaller, and easier to reason about while still working seamlessly with existing Java codebases.
Along the way, we will look under the hood at what actually happens when Kotlin meets Spring. Why does Spring need the allOpen plugin? What changes when classes become final by default? How does Java interoperability really work? And why do some Kotlin features feel so natural in Spring applications while others can quietly work against you?
I will also share lessons from introducing Kotlin into large production systems, including common mistakes Java developers make early on, how Kotlin’s type system changes everyday coding habits, and how libraries like Mappie, MockK, Kotest, and Exposed fit naturally into the ecosystem.
By the end of the talk, you will understand not just how to write Kotlin in Spring Boot, but why Kotlin changes the way Spring applications feel to build and maintain.
LM 正快速滲透各種應用場景，但當它進入複雜業務領域時，我們也開始看見它在理解與推理上的限制 🤔
透過實際改造古老系統的案例，帶你重新認識 LLM 在領域模型中的角色，並思考在人機協作與團隊協作中，如何更好的識別系統應當設計到什麼樣的產出水準，才適合堪稱為可交付的狀態。
在這個演講內容中，涉及但不僅限於以下主題 : 團隊協作、 mainframe、領域驅動設計、引導工作坊、 Example Mapping 、 Wardley Mapping、Context engineering、 Harness engineering、Ontology、SSOT (Single Source of Truth)。
🍴Lunch and Break
在臺灣的企業與政府大型舊系統中，處理 Big5 擴充難字與自造字一直是揮之不去的 IT 噩夢。當系統需要同時介接多個外部業務中心，且每個中心都維護著各自專屬、甚至相互衝突的難字定義時，傳統的字元處理機制便面臨束縛。由於底層框架在設計上屬於全域共享的靜態規格，導致多套難字對映無法在同一個執行環境中並存。
為了解決這個困境，許多專案被迫採取不優雅的客製化手段：在系統的 I/O 邊界撰寫大量繁瑣的低階程式碼，手動從串流中讀取原始位元組，再透過密密麻麻的條件式硬編碼去判斷高低位元組的數值範圍，符合特定範圍後才進行暴力查表或字串代換。這種遍布於程式邏輯的低階位元組處理，不僅讓程式碼破碎、技術債高昂，維護成本更是災難性的。
本場短講將分享一套優雅的架構重構方案——動態字元集機制。這套機制將目光投向 Java 核心，直接重構與翻轉底層的字元編解碼引擎，將原本硬編碼在各處的位元組判斷，全面收攏並提升至標準字元處理層。
這套機制的創新在於將原本官方硬編碼、全域共享的靜態結構，大刀闊斧改為「動態實例化」架構，讓不同的業務中心在執行期各自擁有完全獨立的字元集實例，完美達成多客戶隔離。同時，字元集在初始化時會動態讀取外部的 Excel 難字對映表，將其與標準基礎字集融合成一體化的對照規格，專案從此只需呼叫標準 API 即可自動完成查表。最後，機制更設計了特製的混血擴充區塊，當遇到超出常規範圍的超大 Unicode 罕見字時，會自動分流至獨立的輔助對映中，兼顧了絕大多數常用字的原生高速查表效能，又賦予了系統處理超大難字的無限擴充彈性。
透過這場 15 分鐘的技術分享，聽眾將能掌握如何將一個僵化的底層元件，重構為具備高度彈性的動態資料驅動架構，徹底告別手動解析位元組與維護混亂編碼邏輯的痛苦。
寫 UI 很有趣，但每次修改一點就要等編譯，就一點都不有趣了！隨著 Compose Multiplatform 的出現，Kotlin 開發者已經能用宣告式語法打造跨平台 UI。但開發者對 UI 開發的期待，除了語法設計外，也希望能在開發過程中快速看見修改結果。雖然 Jetpack Compose 透過 @Preview Annotation 改善了部分預覽體驗，但遇到真實 App 狀態、Navigation、ViewModel 或跨平台 UI 時，仍很難完全取代實際跑起來的應用程式。
現在，JetBrains 團隊推出 Compose Hot Reload，讓開發者能在運作中的 Compose Multiplatform 應用裡修改 UI 程式碼，儲存後快速看到變化，並盡可能保留當前畫面與狀態。這場短講會快速介紹 Compose Hot Reload 的核心原理、安裝方式與工作流程，包含它如何透過 JetBrains Runtime 與 DCEVM，把修改後的程式碼載入既有應用程式。也會現場示範如何透過 Hot Reload 快速產製 UI，並說明當前適合使用的情境與限制。聽完後，聽眾將能理解 Compose Hot Reload 的優勢，以及如何把它帶進現有專案的 UI 開發流程。
Nullability annotations have been part of the Java ecosystem for years, but every library seems to have its own flavor—javax.annotation, JetBrains, Eclipse, Spring, and more. This fragmentation makes it difficult to share nullness information consistently across tools and libraries.
JSpecify aims to solve this by defining a standard, tool-agnostic way to express nullness in Java. As support from Java tooling continues to grow, many teams are beginning to consider migrating to JSpecify.
In this session, I'll introduce the motivation behind JSpecify, explain how it differs from legacy nullability annotations, and share practical lessons from migrating an existing Java application. We'll cover migration strategies, the tooling that can help automate the process, and a few surprising framework compatibility issues we encountered.
MySQL NDB Cluster是一個具有極致擴充力的分佈式資料庫,大部份的應用把它當成一般的關聯式資料庫,以MySQL Connector/J 透過MySQL server (mysqld) 取用存在data node的資料, 當您想要讓您的Java應用性能更上一層樓, 您的Java應用可以用ClusterJ API繞過MySQL Server直接取用data nodes的資料, 進而能使資料取用的速度提升數倍. 這場演講我將介紹Java應用如何使用ClusterJ,以及MySQL NDB Cluster的架構, 和展示ClusterJ所帶來的性能提升.
AI Agent 從 prompt demo 進入企業落地後，真正困難的問題不再只是如何寫 prompt，而是如何把模型、工具、資料、工作流、觀測性、權限與部署治理整合進既有系統。對許多 Java / Kotlin 團隊來說，答案不一定是把商業邏輯搬到 Python，而是在原本承載核心服務的 JVM stack 上建立可維運的 Agent 工具鏈。
本場分享將以 production agent 的三層架構切入：第一層是 integration layer，使用 Spring AI 將 ChatClient、tool calling、RAG、memory、observability、evaluation 與 MCP client / server 整合進 Spring Boot 的 dependency injection 與 auto-configuration 模型；第二層是 orchestration layer，比較 Embabel 與 Koog 如何將多步驟任務組織成 goal、action、planner、graph 或 workflow，而不是停留在單次 prompt 呼叫；第三層是 interop layer，說明 MCP 如何成為工具與資料的標準接法，以及 A2A 如何在需要時把外部 agent 作為 remote capability 納入 JVM 平台。
這場演講不會主張 Java 取代 Python，而是回答一個更實務的問題：當你的資料、交易流程、權限控管與部署平台本來就在 JVM 生態裡，如何在不重寫既有系統的前提下，把 Agent 變成可以測試、可以觀測、可以部署、可以治理的 production component。
聽眾將會看到一個以 Spring Boot / Spring AI 為主的 agent orchestrator 範例，搭配 MCP tool integration，並透過 Koog 或 Embabel 的 code walkthrough 比較不同 orchestration 風格。最後會以 A2A remote agent 作為跨 runtime 互通的收尾案例，說明企業環境如何同時容納 JVM agent、外部 agent 與雲端部署。
在 JVM 的後端世界中，Kotlin 憑藉著簡潔的語法與強大的協程（Coroutines）機制，已經成為許多團隊開發新服務的首選。
然而，面對後端框架的選擇，我們常常陷入糾結：該選擇歷史悠久、生態系最完整的 Spring Boot？還是主打雲原生、超快啟動速度與低記憶體佔用的 Quarkus？抑或是 JetBrains 親生、純 Kotlin 基因的輕量級 Ktor？
本議程將從 Kotlin 開發者的視角出發，深入探討這三個框架使用 Kotlin 開發時的各種差異。
無論你是正在考慮將 Java 專案轉移到 Kotlin，還是正在為微服務尋找最佳的後端架構，這場演講都將為你提供清晰、客觀且基於實戰的技術選型指南。
Java runs on the JVM, which brings great benefits: memory safety, type safety, and platform independence. However, Java has long been considered weak when it comes to the "outside world" — calling native libraries, controlling hardware, and optimizing at the CPU instruction level have all been pain points for Java developers.
Project Panama changes that. The FFM API (Foreign Function & Memory API), released as a standard feature in Java 22, introduces new abstractions such as MemorySegment and Linker, allowing native functions and off-heap memory to be accessed in a way that feels natural within the Java world. In this session, I will walk through a simple electronics demo to explain the advantages of the FFM API compared to the traditional JNI approach.
This session will also cover the Vector API, another output of Project Panama. By explicitly leveraging CPU SIMD instructions from Java, this API delivers significant performance gains in areas such as image processing and numerical computation. This session will also introduce Project Babylon, an OpenJDK project that aims to run Java on accelerators such as GPUs and FPGAs.
Java is now stepping out beyond the JVM. To boldly go where Java has never gone before.
Scala 的型別系統在 JVM 生態系中獨樹一幟，但也因為其強大的功能讓開發者時常不知道如何運用這個優勢去開發型別上更加安全的程式。
在這個 session 中，將會簡單介紹 Scala 型別系統，並利用其底層的推導邏輯打造一個型別安全的自動機，初步帶領開發者理解型別系統並開發的擁有進階型別安全的程式。
TDD 說起來好像是個很老的東西，大家都覺得很老，大家都覺得自己懂，大家都覺得現在好像不需要了，但事實是：大家其實都不知道他到底在幹嘛。
『在這個 AI 飆速的年代，已經不需要 TDD 了』這個立論你一定聽過，但你仔細想，在這個 AI 飆速的年代，別人跟你說不再需要的豈止是 TDD 而已？說老實話，如果今天公司跟你說不再需要你了，你也就點頭認同舉手同意？不會吧！？
TDD 的操作沒有什麼特別的，就只是大家熟知的『紅燈、綠燈、重構』。它的價值在於能夠快速暴露你自身對於需求理解、架構設計、設計成本的控管的不足。這件事，跟 AI 不 AI 沒有關係，AI 只是讓問題暴露得更快而已。
真正的問題在，當問題暴露出來擺在你眼前，不要說能不能解了，看不看得出來也許才是我們真正的瓶頸。
在 AI 飆速的年代，寫程式還需要嗎？架構還需要嗎？DDD 還需要嗎？程式易讀易改性還需要嗎？
也許到最後可以一句話總結：『人要比車兇』。
在這場工作坊中，與會者將與講者組成 Pair，我們將一起用 TDD 的方式，帶出從以前到現在你可能想都沒想過的設計問題。更棒的是，你不用帶電腦！讓我來當你的 Driver，一起來體驗，在 TDD + Pair Programming 的過程中，全程用力思考架構與設計問題是長什麼樣子。
Coding Agent 已經成為許多工程師的日常工具，但許多工程師會反問自己：「那還需要學習軟體工程嗎？怎樣子的進步在後 Coding Agent 時代還算是進步呢？」
本 talk 提出一條工程師在後 Coding Agent 時代的升級路徑，分為四個關卡：
- Level 1：IDE for agent — 先設置個 LSP，讓 agent 有 IDE 可以用吧。
- Level 2：Integration Test-Driven Development — 從 unit test 升級到 integration test，讓 agent 在更早的階段驗證更深層的行為。
- Level 3：EDD（Eval-Driven Development） — 傳統測試驗證「功能對不對」，EDD 驗證「agent 的行為對不對」。以實際開發經驗為例：cljfmt 格式化工具在調整縮排後，agent 的 str_replace 操作會因為空白字元不符而反覆失敗，最終整個檔案重寫——大量 token 浪費在一個可以被解決的結構性問題上。一個有效的 skill，能讓 agent 改用 S-expression 結構比對來取代文字比對，真正消除這個 behavioral gap，而不只是告訴 agent 應該小心格式。
- Level 4：Context Efficiency — AI 要完成一個任務，不需要讀整個 codebase，只需要讀「任務相關的那幾個檔案」——我們可以稱之為局部子圖（task-relevant subgraph）。這個子圖的大小，直接決定了 context 的消耗量。然而，局部子圖（task-relevant subgraph）的大小，由軟體架構決定，不由模型決定。
AI coding assistants can generate Java code in seconds, but code generation is the easy part. The harder questions remain: What should we build? Why should we build it? Which functional and technical requirements must the implementation satisfy? How do we review the result, and what evidence tells us it is ready?
This talk examines how AI tools are changing the software development life cycle for Java enterprise teams.
The talk emphasizes the importance of expressing both functional requirements—the behavior and outcomes the software must deliver—and technical requirements such as architecture, security, performance, compatibility, observability, and regulatory constraints. Without this context, faster code generation can simply produce the wrong system more quickly.
Attendees will also learn the main concepts behind modern AI development tools:
- Commands express repeatable engineering actions.
- Skills provide reusable domain and technical knowledge.
- Agents perform bounded tasks with a defined role and context.
- MCP Servers connect AI tools to trusted systems and project information.
Examples using tools such as Cursor AI, Claude Code, Codex, and GitHub Copilot will make these concepts concrete without prescribing a single workflow or product. The central theme is engineering discipline: treat generated code and agent instructions with a Zero Trust mindset, keep software engineers in the loop, and require traceable evidence before accepting a change.
Attendees will leave with a clearer understanding of how the Java SDLC is evolving, why well-defined requirements become even more important when working with AI, and how these tools can support engineers without replacing architectural judgment, review, or accountability.
The talk will be delivered in English.
金融軟體開發以嚴謹、流程固定（SA、SD、實作、整合測試、回歸測試）著稱，文件更是不可或缺的基石。在 Agent 世代，這種深厚的文件文化非但沒有過時，反而與主流的 SDD（Specification-Driven Development，規格驅動開發） 完美結合。
本分享將以自身後端團隊的實戰經驗出發，展示如何以 API-First 為溝通中樞，將傳統 SA/SD 文件轉化為機器可讀的規格契約。由於 LLM 模型本身是無狀態（Stateless）且伴隨幻覺風險，我們透過一套工程化的 Harness（開發治具） 嚴格控制開發流程；同時利用 Codex Skills 將團隊既有的架構規範與安全準則標準化。
透過 Multi-Agent 協作機制，我們將 SA、SD、PG、QA 角色虛擬化（Virtual Dev Team），為每個角色設定明確的任務目標與嚴格的交付邊界。本場 talk 將完整解析從系統設計、API 契約定義、程式自動生成、整合測試，到最終部署與 E2E 回歸測試的完整閉環。這套方法證明了：加強 SDD 與傳統開發方式不僅沒有衝突，反而是相輔相成，在大幅提升交付效率的同時，更能將人為失誤降至最低，實踐金融級的軟體工藝落地。
Java developers usually write source code and let javac and the JVM handle the rest. But the generated class file contains many interesting details: the constant pool, methods, attributes, bytecode instructions, stack-based execution, synthetic methods, and invokedynamic.
In this session, we will take a guided tour of Java class files using small Java programs and javap. We will start with the basic structure of a class file, including the magic number, version, constant pool, methods, and attributes. Then we will read simple bytecode instructions as stack-machine operations, so that attendees can understand how Java code is represented after compilation.
After building this foundation, we will look at invokedynamic, one of the most interesting bytecode instructions added to the JVM. We will examine how modern Java features such as string concatenation and lambdas are represented in class files, and what bootstrap methods and call sites roughly do behind the scenes.
The goal is not to memorize the JVM specification. The goal is to enjoy discovering what Java actually becomes after compilation. After this session, attendees should be able to inspect class files by themselves and use that knowledge as a foundation for understanding Java language features, JVM behavior, performance topics, and bytecode-based tools.
☕ Tea Time
"With AI, Code doesn't matter anymore." It's a seductive idea, and it's gaining believers: if specs and tests are the real source of truth and code is just a disposable artifact the model regenerates on demand, then technical debt stops being a problem. If the code has become impossible to change, just let AI rewrite it all from scratch. Clean architecture, naming, and separation of concerns have become yesterday's rituals — like punch cards.
This talk argues the opposite: internal quality matters more in an AI-driven workflow, not less. There are technical reasons why LLMs are more sensitive to well-structured code than humans are, and we'll look at examples drawn from real experience, alongside research papers that shed some light on the matter.
It's also a question of economics. If technical debt can be measured in the tokens — that is dollars — needed to work around it, then keeping it low directly saves money.
But there's a catch: "code quality" for an LLM is not exactly the same thing as what computing literature has traditionally called code quality. Modularization and good naming matter even more than before, but some classic "clean code" advice can actually worsen a model's performance. We'll look at where the two notions diverge, and how to improve your productivity scientifically — by measuring the effect of good structure and good instructions rather than assuming it.
Main Takeways:
Why LLMs are technically more sensitive to code structure than human readers
Which conventional "clean code" practices can backfire on a model, and why
How to measure and improve assistant productivity scientifically, rather than by gut feel
Kotlin 2.x 不只是一次版本更新，更代表 Kotlin 生態系邁入新的發展階段。從全新的 K2 Compiler、Context Parameters 到 Collection Literals，Kotlin 持續提升語言表達能力、開發效率與未來演進的可能性。這些改變不僅改善日常開發體驗，也為跨平台與新世代應用奠定重要基礎。
本次分享將從 Kotlin 2.x 最值得關注的語言革新開始，介紹 K2 Compiler 帶來的架構轉變，以及 Context Parameters 與 Collection Literals 如何讓程式碼更具可讀性與表達力。
除了語言本身的進化，我們也將進一步探討 Kotlin 在 AI 領域的最新布局，包括 Koog、MCP SDK 與 Agent Skills 等新興技術，了解 Kotlin 如何從一門現代化程式語言，逐步發展成支援 AI Agent 與智慧應用開發的平台。
透過本次分享，與會者將能掌握 Kotlin 2.x 的核心變革、理解 Kotlin 與 AI 生態的結合方向，並從中看見 Kotlin 的發展方向。
Quantum computing is no longer a distant concept—it’s an imminent challenge to today’s cryptographic standards. The shift to Post-Quantum Cryptography (PQC) is not optional; it’s inevitable. Yet, the practical steps for adapting existing applications to PQC, and the critical considerations for ensuring compatibility, remain largely unclear.
This session goes beyond theory. We’ll start with a concise overview of PQC fundamentals, then dive into real-world migration experiences—what worked, what didn’t, and why. Attendees will gain actionable best practices drawn from hands-on projects, offering guidance not only for those planning future migrations but also for developers designing new applications today.
If you’ve ever wondered, “Where do I start?” or “What pitfalls should I avoid?”, this talk will provide the answers—grounded in real-world experience and focused on practical success.
By the end of this session, participants will be able to:
- Understand the fundamentals of Post-Quantum Cryptography (PQC) and why early adoption is critical in the face of quantum computing threats.
- Identify key challenges and pitfalls encountered during real-world PQC migration projects.
- Apply proven best practices for adapting existing applications to PQC while maintaining security and performance.
- Develop a practical roadmap for integrating PQC into both legacy systems and new application designs.
在微服務架構下，跨服務流程往往伴隨重試、補償、狀態追蹤與人工介入等挑戰，開發者不得不撰寫大量流程控制程式，增加系統複雜度與維護成本。
本次分享將回顧流程引擎的演進，介紹 Workflow as Code 的設計理念，並以 Temporal 為例，說明 Durable Execution 如何簡化跨服務流程開發，分享多種應用模式，協助開發者建構更可靠且易於維護的分散式流程。