Tagged articles

22 articles

Page 1 of 1

May 22, 2026 · Fundamentals

Upgrade from Java 8: 8 Powerful Features in Java 21 You Should Know

The article examines why many projects still cling to Java 8 and demonstrates eight transformative Java 21 features—including records, sealed classes, pattern‑matching for instanceof, switch expressions, text blocks, virtual threads, structured concurrency, and enhanced APIs—showing code examples and the benefits they bring to performance, readability, and maintainability.

Javaenhanced-apisjava-21

0 likes · 11 min read

Upgrade from Java 8: 8 Powerful Features in Java 21 You Should Know

java1234

May 19, 2026 · Backend Development

Why JDK 26’s New Features Are a Game‑Changer for Your Projects

JDK 26 introduces a suite of impactful JEPs—including primitive type pattern matching, G1 GC throughput gains, AOT object caching for faster startup, built‑in PEM encoding, stricter final‑field handling, HTTP/3 support, LazyConstant, structured concurrency, and a mature Vector API—each backed by code examples and performance data to help developers modernize their Java applications.

Javaaot-cacheg1-gc

0 likes · 29 min read

Why JDK 26’s New Features Are a Game‑Changer for Your Projects

JakartaEE China Community

Apr 8, 2026 · Backend Development

From Reactive Streams to Virtual Threads: A Deep Dive

The article examines Project Loom's virtual threads, compares them with reactive streams, explores their underlying mechanisms, presents a direct‑style flow library (Jox) that combines both paradigms, and evaluates performance, backpressure, and error handling in Java concurrency.

JavaJoxProject Loom

0 likes · 22 min read

From Reactive Streams to Virtual Threads: A Deep Dive

MeowKitty Programming

Mar 19, 2026 · Backend Development

Java at 26: 6 Game‑Changing JDK 26 Upgrades That Outperform the Competition

Oracle’s JDK 26, a non‑LTS release, delivers dramatic gains—15% higher G1 GC throughput, up to 50% lower latency, 40‑60% memory reduction via Valhalla value classes, native HTTP/3 support, AOT cache for all GCs, and enhanced security—offering developers faster startup, lower costs, and safer code.

HTTP/3Java performancePost-Quantum Encryption

0 likes · 10 min read

Java at 26: 6 Game‑Changing JDK 26 Upgrades That Outperform the Competition

MeowKitty Programming

Mar 19, 2026 · Backend Development

Why JDK 26 Promises Up to 30% Faster Java with Half the Boilerplate

JDK 26, released on March 17, 2026, introduces structured concurrency, native HTTP/3, primitive‑type pattern matching, lazy constants, G1 GC sync improvements, AOT object caching, final‑field reflection limits and post‑quantum encryption, delivering up to 30% performance gains, 40% thread‑utilisation, and up to 70% code‑size reduction without requiring code changes or new dependencies.

HTTP/3JavaPost-Quantum Encryption

0 likes · 11 min read

Why JDK 26 Promises Up to 30% Faster Java with Half the Boilerplate

java1234

Jan 23, 2026 · Fundamentals

Why Java 25 Is a Game‑Changer: Simpler Syntax, Faster Performance, Modern Features

Java 25, the newest LTS release, introduces a suite of language and runtime enhancements—including primitive‑type pattern matching, module‑wide imports, a lightweight main method, richer records, structured concurrency, scoped values, a vector API, and security updates—that together make Java code more concise, safer, and higher‑performing for both newcomers and seasoned developers.

JEPJavaJava 25

0 likes · 11 min read

Why Java 25 Is a Game‑Changer: Simpler Syntax, Faster Performance, Modern Features

AndroidPub

Dec 25, 2025 · Fundamentals

13 Common Kotlin Coroutine Exception Scenarios and How to Fix Them

This article walks through thirteen typical Kotlin coroutine exception pitfalls, explains why errors propagate in structured concurrency, shows wrong and correct code patterns for launch, async, coroutineScope, supervisorScope, and other utilities, and provides concrete examples with outputs to help developers write robust coroutine code.

CoroutinesException HandlingKotlin

0 likes · 19 min read

13 Common Kotlin Coroutine Exception Scenarios and How to Fix Them

Java Tech Enthusiast

Nov 8, 2025 · Fundamentals

What’s New in Java 25? 15 Game‑Changing Features You Must Know

Java 25, the latest LTS release, introduces a suite of language and runtime enhancements—including pattern matching, module imports, lightweight main methods, record upgrades, structured concurrency, scoped values, vector APIs, compact object headers, generational Shenandoah GC, AOT optimizations, JFR improvements, and security updates—making Java more concise, safer, faster, and easier for both newcomers and seasoned developers.

JEPJava 25Record

0 likes · 10 min read

What’s New in Java 25? 15 Game‑Changing Features You Must Know

Java Companion

Oct 28, 2025 · Backend Development

Java 25 Released: New Features Make the Language More Concise, Efficient, and Modern

Java 25, the latest LTS release, introduces pattern matching for primitive types, module‑wide imports, a compact main method, enhanced records, structured concurrency, scoped and stable values, a vector API, compact object headers, generational Shenandoah GC, AOT optimizations, JFR improvements, security updates, and drops 32‑bit support, offering developers a more concise, safer, and higher‑performance platform.

JDK 25JEPJava

0 likes · 10 min read

Java 25 Released: New Features Make the Language More Concise, Efficient, and Modern

IT Services Circle

Sep 21, 2025 · Backend Development

Is JDK 25’s “Lightweight” Promise Just a Shortcut Parade?

The article reviews JDK 25, the latest LTS release, critiquing its superficial syntax shortcuts while highlighting the genuinely valuable additions of Structured Concurrency and Scoped Values, and examines JVM‑level improvements such as generational Shenandoah GC, ultimately questioning whether the release truly advances Java’s future.

Garbage CollectionJDK 25LTS

0 likes · 7 min read

Is JDK 25’s “Lightweight” Promise Just a Shortcut Parade?

Su San Talks Tech

Sep 16, 2025 · Fundamentals

What Makes Java 25 a Game‑Changer? Explore Its Groundbreaking Features

Java 25, the latest LTS release, introduces a suite of powerful new language and runtime features—including Scoped Values, compact source files, flexible constructors, module import declarations, a key‑derivation API, compact object headers, generational Shenandoah GC, structured concurrency, primitive pattern matching, and Stable Values—while also deprecating 32‑bit x86 support and enhancing JFR and the Vector API, offering developers both modern ergonomics and performance gains.

Compact Object HeaderJava 25Key Derivation Function

0 likes · 21 min read

What Makes Java 25 a Game‑Changer? Explore Its Groundbreaking Features

Big Data Technology Tribe

Jun 3, 2025 · Fundamentals

What’s New in JDK 24? Top Preview Features and How to Use Them

JDK 24 introduces a suite of preview enhancements—including a simplified main method, primitive type pattern matching, flexible constructors, scoped values, module import declarations, structured concurrency, and ahead‑of‑time class loading—that improve Java performance, readability, and developer productivity ahead of the upcoming JDK 25 LTS release.

JavaLanguage Enhancementsjdk24

0 likes · 11 min read

What’s New in JDK 24? Top Preview Features and How to Use Them

Su San Talks Tech

Mar 23, 2025 · Backend Development

What’s New in Java 24? Exploring Structured Concurrency, Shenandoah GC, and Stream Gatherers

Java 24 GA introduces 24 JEPs, including Structured Concurrency for safer parallelism, Shenandoah GC as a low‑pause collector, Stream Gatherers for custom stream operations, primitive pattern matching, virtual‑thread improvements, Unsafe warnings, and post‑quantum cryptography, all aimed at modernizing the platform.

Quantum Cryptographybackend-developmentjdk24

0 likes · 7 min read

What’s New in Java 24? Exploring Structured Concurrency, Shenandoah GC, and Stream Gatherers

DaTaobao Tech

Jan 6, 2025 · Backend Development

Java 21 LTS Features Overview and Practical Guide

This article walks readers through upgrading from Java 11 to the Java 21 LTS by explaining the six‑month release cadence, JEP process, and SDKman setup, then demonstrates practical code examples for twelve new features—including preview Unnamed Classes, String Templates, Scoped Values, Structured Concurrency, Vector API, Virtual Threads, and Generational ZGC—highlighting their motivations, benefits, and production considerations.

Backend DevelopmentJDK LTSJVM

0 likes · 16 min read

Java 21 LTS Features Overview and Practical Guide

21CTO

Dec 6, 2024 · Backend Development

What’s New in JDK 24? 24 Features Shaping the Future of Java

JDK 24, slated for a March 2025 release, introduces over twenty‑four enhancements—including a fourth preview of structured concurrency, quantum‑resistant cryptography, and a compact object header—while being a non‑LTS release that builds on the capabilities of JDK 23 and sets the stage for JDK 25.

Backend DevelopmentJDK 24Java

0 likes · 13 min read

What’s New in JDK 24? 24 Features Shaping the Future of Java

21CTO

Aug 15, 2024 · Backend Development

What’s New in JDK 23? A Deep Dive into Upcoming Java Features

JDK 23, the next non‑LTS release of the Java platform slated for September 17, introduces a suite of preview features—including scoped values, structured concurrency, flexible constructor bodies, implicit class and instance methods, module import declarations, Markdown Javadoc, vector API enhancements, and a default generational ZGC mode—while deprecating sun.misc.Unsafe memory‑access methods.

JDK 23JavaScoped Values

0 likes · 11 min read

What’s New in JDK 23? A Deep Dive into Upcoming Java Features

Ctrip Technology

Mar 8, 2024 · Backend Development

Design and Implementation of Ctrip Flight Order Itinerary System: Architecture, Sharding, Caching, and Structured Concurrency

The article presents a comprehensive case study of Ctrip's flight order itinerary system, detailing its background challenges, design goals, modular architecture, data aggregation strategies, sharding and Redis caching optimizations, and the adoption of Java structured concurrency to achieve high performance, reliability, and scalability.

CachingPerformance OptimizationSharding

0 likes · 13 min read

Design and Implementation of Ctrip Flight Order Itinerary System: Architecture, Sharding, Caching, and Structured Concurrency

Spring Full-Stack Practical Cases

Nov 3, 2023 · Backend Development

Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency

This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.

JavaSpring BootThread Pools

0 likes · 15 min read

Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency

Programmer DD

Sep 22, 2022 · Backend Development

What’s New in JDK 19? Explore 7 Preview Features Boosting Java Performance

JDK 19 introduces seven preview JEPs—including Record Patterns, a Linux/RISC‑V port, the Foreign Function & Memory API, Virtual Threads, the Vector API, Pattern Matching for switch, and Structured Concurrency—offering developers powerful new tools to write more efficient, modern Java code.

foreign function APIjdk19preview features

0 likes · 6 min read

What’s New in JDK 19? Explore 7 Preview Features Boosting Java Performance

Tencent Cloud Developer

Jul 7, 2022 · Backend Development

libunifex Structured Concurrency Implementation Analysis

The article thoroughly examines libunifex’s structured concurrency implementation, detailing its DSL‑based execution framework and the three core components—Sender Factory, Sender Adapter, and Receiver—through examples like just(), then(), and sync_wait(), and explains how these pieces combine to build asynchronous pipelines.

Async ExecutionC++CPO

0 likes · 14 min read

libunifex Structured Concurrency Implementation Analysis

WeChat Client Technology Team

Oct 21, 2021 · Fundamentals

Why We Built Our Own C++ Coroutine Framework and How It Boosts Development Efficiency

This article explains the motivation behind creating the C++ coroutine framework "owl" for the cross‑platform WeChat client, compares callback, promise, and coroutine approaches with code examples, and details its design choices such as stackful coroutines, single‑thread scheduling, structured concurrency, and performance characteristics.

AsynchronousCFramework

0 likes · 19 min read

Why We Built Our Own C++ Coroutine Framework and How It Boosts Development Efficiency

High Availability Architecture

Feb 20, 2020 · Fundamentals

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples

This article introduces the challenges of traditional concurrency, explains the structured concurrency paradigm, surveys its history and implementations across languages, and provides a detailed Rust example using the task_scope library with Scope, CancelScope, timeout handling, nested scopes, and a practical Happy Eyeballs exercise.

asynchronous programmingcancellationconcurrency

0 likes · 12 min read

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples