Best of Java — March 2026

1. 1
   Article

   Hacker News·4w

   GitHub - hectorvent/floci: Light, fluffy, and always free - AWS Local Emulator

   Floci is a free, open-source local AWS emulator designed as a drop-in replacement for LocalStack Community Edition, which is sunsetting its free tier in March 2026. It requires no auth token, supports unlimited CI/CD usage, and starts in ~24ms with ~13 MiB idle memory. The Docker image is ~90 MB versus LocalStack's ~1 GB. Floci supports 20+ AWS services including API Gateway v2, Cognito, ElastiCache, RDS with IAM auth, DynamoDB Streams, and more — with 408/408 SDK tests passing. Setup is a single `docker compose up` and SDK integration requires only pointing the endpoint to localhost:4566.

   66

   2
2. 2
   Article

   InfoWorld·4w

   9 reasons Java is still great

   Java remains a dominant platform due to its governance model (JCP), the OpenJDK community, a rich open source ecosystem, and frameworks like Spring, Quarkus, Micronaut, and Helidon. Key technical milestones include virtual threads (Project Loom) enabling millions of concurrent requests, data-oriented programming features like records and pattern matching reducing verbosity, and Project Valhalla's value classes eliminating JVM memory overhead. Java is also evolving into an enterprise AI orchestration layer via tools like LangChain4j and Spring AI, positioning it as the platform for connecting LLMs to production business systems.

   33

   1
3. 3
   Video

   Telusko·4w

   Java 26: Finally fixing the 'final' lie

   Java 26 has been released with several notable updates. The headline change restricts the ability to mutate final variables via the Reflection API — previously a loophole that allowed frameworks to change constants. Java 26 now emits a warning when this is attempted, with a future default of 'deny' that will throw an error. Other updates include: removal of the long-deprecated Applet API, AOT object caching now available for any garbage collector (improving boot times), experimental HTTP/3 support via QUIC/UDP, and G1 garbage collector synchronization improvements. Java 25 remains the current LTS version.

   28
4. 4
   Article

   Foojay.io·4w

   foojay – a place for friends of OpenJDK

   BoxLang Spring Boot Starter lets Spring Boot 3 developers use BoxLang — a modern dynamic JVM language — as a view/templating engine with zero configuration. Add one dependency and write .bxm templates that have full access to HTTP scopes (url, form, cookie, request), auto-inject Spring Model attributes, and support hot-reload during development. BoxLangViewResolver integrates cleanly into Spring MVC's resolver chain alongside Thymeleaf or FreeMarker. Additional features include scheduled tasks, enterprise caching, and enhanced concurrency utilities. Requires Java 21+ and Spring Boot 3.4+.

   27
5. 5
   Article

   On Test Automation·6w

   Writing tests with Claude Code - part 1 - initial results

   An exploration of using Claude Code to generate API tests for a Spring Boot banking application, starting from scratch with only a prompt. Claude produced 23 passing tests in minutes, achieving 95% line coverage and 91% mutation coverage as measured by PITest. However, analysis revealed gaps: several critical code paths were missed (HTTP 500 handling, empty account list, boundary values), and 4 of the 23 tests (17%) were dead weight that didn't uniquely contribute to coverage. The author emphasizes that evaluating AI-generated tests requires domain knowledge, testing experience, and tools like mutation testing — simply accepting passing tests at face value risks a test suite full of holes.

   27

   1
6. 6
   Article

   Codemotion·3w

   Virtual Threads vs. Coroutines in 2026: Is Java Finally There?

   A preview of a Codemotion Madrid 2026 talk by JetBrains' Wout Werkman comparing Java's Virtual Threads (Project Loom, introduced in Java 21) with Kotlin's coroutines. The piece covers the history of Java's concurrency limitations, how Kotlin coroutines addressed them, and how Java responded with Virtual Threads, Scoped Values, and Structured Concurrency APIs. The central question is whether Java has finally closed the gap with Kotlin's long-standing concurrency model.

   50

   3
7. 7
   Video

   Stefan Mischook·5w

   Java in 2026: You’re Asking the Wrong Question

   Programming languages are just tools, and the real question for developers in 2026 isn't which language to learn but how to position yourself for the current wave of opportunity. Drawing on 30 years of experience, the author argues that fundamentals always matter, but the new leverage is the AI stack — frontier models, agentic implementations, and AI-augmented development workflows. Just as early web developers outpaced traditional thick-client developers in the 90s, today's early AI adopters will capture the most opportunity. The advice: master fundamentals first, then deeply learn the AI toolset rather than chasing specific frameworks or languages.

   24

   1
8. 8
   Article

   Mostly Nerdless·5w

   Java 26 is boring, and that's a good thing - Mostly nerdless

   Java 26 is a deliberately incremental release that prioritizes stability over flashy changes. The most impactful improvement is a 5-15% throughput gain in the G1 garbage collector with no code changes required. Other notable additions include AOT object caching support for any GC (improving microservice startup), HTTP/3 support in the standard HttpClient, deprecation warnings for final field mutation via reflection, and the final removal of the long-dead Applet API. Several features remain in preview (structured concurrency, primitive patterns, etc.) and are opt-in only. The post argues that Java's 'boring' nature—strong backward compatibility, evolutionary language changes, and steady runtime improvements—is a deliberate design philosophy that has kept it relevant for 30 years, while acknowledging gaps like missing string interpolation, null-safety, and built-in JSON support compared to Kotlin, C#, and others.

   24
9. 9
   Video

   Dan Vega·5w

   Building a Terminal UI for Spring Initializr with Java

   A developer built a terminal UI (TUI) for Spring Initializr using Java and the newly announced Tamboo UI framework. The tool replicates the Spring Initializr web experience in the terminal, with features like fuzzy dependency search, favorites, project exploration, and post-generation hooks that can automatically open an IDE (like IntelliJ) and launch Claude Code in the new project directory. The native executable is built with GraalVM for fast startup and low memory usage, and binaries for macOS, Windows, and Linux are distributed via GitHub releases.

   24

   1
10. 10
    Article

    Foojay.io·7w

    I Benchmarked Java on Single-Board Computers: Orange Pi 5 Ultra and Raspberry Pi 5 Lead the Pack

    A hands-on benchmark comparison of Java performance across multiple single-board computers including Orange Pi 5 Ultra, Raspberry Pi 5, Raspberry Pi 4, LattePanda IOTA, and several RISC-V boards. The author built a custom JBang-based benchmark runner using the Renaissance Benchmark Suite, covering seven workloads including actor concurrency, fork/join parallelism, and in-memory databases. Results show the Orange Pi 5 Ultra (ARM RK3588) leads among traditional SBCs, with Raspberry Pi 5 a close second. RISC-V boards (Orange Pi RV2, BeagleV-Fire, StarFive VisionFive 2 Lite) are viable but slower. The benchmark tool and an interactive dashboard are publicly available on GitHub.

    22
11. 11
    Article

    Collections·5w

    Project Detroit: Oracle's plan to embed Python and JavaScript runtimes inside the JVM

    Oracle announced Project Detroit at JavaOne, an initiative to embed V8 (JavaScript) and CPython (Python) runtimes directly inside the JVM process using the Foreign Function and Memory (FFM) API introduced in Java 22. Unlike previous approaches like Nashorn that reimplemented languages on the JVM, Project Detroit embeds the actual runtimes, enabling full compatibility with existing JS and Python ecosystems, better performance, and heap isolation for security. The project will be proposed as an official OpenJDK project and implements the javax.script API. Originally proposed in 2018 and abandoned, it was revived due to the FFM API's maturity and growing demand for Python AI library access from Java. Other JavaOne announcements include Java 26 with HTTP/3 support, Helidon joining OpenJDK, and highlights of Java's AI ecosystem including Langchain4j and Spring AI.

    20

    1
12. 12
    Article

    JetBrains·4w

    Core JavaScript and TypeScript Features Will Be Free in IntelliJ IDEA

    JetBrains is making core JavaScript, TypeScript, HTML, and CSS features free in IntelliJ IDEA starting with v2026.1. Previously restricted to Ultimate subscribers, the free tier will now include syntax highlighting, code completion, import management, basic React support, code navigation, refactorings, quality inspections, and integrated tooling for Prettier, ESLint, Vite, and NPM scripts. Advanced features like dedicated debuggers, test runners, and full framework support (Angular, Vue) remain part of the Ultimate subscription, which offers a 30-day free trial.

    20
13. 13
    Article

    JetBrains·5w

    Java 26 in IntelliJ IDEA

    Java 26 was released on March 17, 2026, delivering ten JEPs with five finalized. There are no new stable language features, but notable additions include HTTP/3 support in the HTTP Client API, AOT cache improvements for any garbage collector (Project Leyden), G1 GC throughput improvements, warnings for deep reflection on final fields, and removal of the Applet API. Preview features include primitive types in patterns (fourth preview), lazy constants (formerly stable values), structured concurrency, and PEM encoding/decoding. The Vector API continues as an incubator feature. IntelliJ IDEA 2026.1 supports all Java 26 features from day one, including new inspections, debugger improvements for virtual threads in structured concurrency, and tooling for lazy constants. A JetBrains contributor also added min/max default methods to java.util.Comparator in the JDK.

    17
14. 14
    Article

    Quarkus·7w

    Quarkus has great performance – and we have new evidence

    The Quarkus team published a new transparent, reproducible benchmark comparing Quarkus and Spring Boot performance. Results show Quarkus handles 2.7x more transactions per second (19,255 vs 7,238 tps), starts 2.3x faster, and uses half the memory. The benchmark addresses past shortcomings: outdated data, missing throughput metrics, and lack of reproducibility. The team open-sourced the benchmark code, invited Spring Boot community input to ensure fairness, and explored questions like virtual threads impact (+6k tps for all frameworks) and Spring Boot 3 vs 4 differences. The post also clarifies that while Quarkus JVM mode outperforms alternatives across all metrics, native compilation does cut throughput in half (though startup and memory improve dramatically), making native mode best suited for frequently restarted or low-workload applications.

    17

    1
15. 15
    Article

    Foojay.io·4w

    How to Use Java as a Scripting Language

    Modern Java has evolved into a viable scripting language, eliminating traditional barriers like manual compilation and verbose boilerplate. Since Java 11, the `java` launcher can run source files directly without `javac`. Java 22 extended this to multi-file programs. Java 25 introduces Compact Source Files and Instance Main Methods, reducing boilerplate to a simple `void main()`. Shebang support lets Java files run as native CLI scripts. JBang further enhances this by handling dependency management (no Maven/Gradle needed), IDE integration, and GraalVM native binary export. Picocli integrates with JBang to build professional CLI tools with typed argument parsing and auto-generated help. Together, these features make Java a practical, maintainable alternative to Bash or Python for automation scripts.

    25

    2
16. 16
    Article

    Piotr Minkowski TechBlog·4w

    Speed up Java Startup with Spring Boot and Project Leyden

    Project Leyden is an experimental OpenJDK initiative that uses Ahead-of-Time (AOT) compilation caching to speed up Java application startup. Using the early access build (EA2, based on JDK 26), you can generate an AOT cache with the -XX:AOTCacheOutput flag on first run, then reuse it with -XX:AOTCache on subsequent runs. Tests with two Spring Boot apps (one using H2+Liquibase, another using Redis) show roughly 40% faster startup times. While promising, the gains are comparable to CRaC and still fall short of GraalVM native image. The key advantage is that Leyden is intended to eventually ship as part of the standard OpenJDK distribution.

    13

    1
17. 17
    Article

    JetBrains·5w

    IntelliJ IDEA 2025.3.4 is Out!

    IntelliJ IDEA 2025.3.4 has been released, bringing full support for Java 26 as the headline feature. The update also includes several bug fixes: a fix for HTTP requests accidentally triggering other requests in the same file, improved local changes refresh in large Perforce projects, and a correction for the Dependencies tab when using Analyze Cyclic Dependencies. The update is available via the IDE itself, Toolbox App, snaps, or direct download.

    11
18. 18
    Article

    JetBrains·5w

    Koog Comes to Java: The Enterprise AI Agent Framework From JetBrains

    JetBrains has launched Koog for Java, bringing its AI agent framework to the JVM with a fully idiomatic Java API. The framework lets Java teams build AI agents directly in existing backends without Python microservices. Key features include multiple workflow strategies (functional, graph-based, and GOAP planning), Spring Boot integration, support for major LLM providers (OpenAI, Anthropic, Google, DeepSeek, Ollama), fault-tolerant persistence (Postgres, S3, disk) that resumes from the exact failure point, OpenTelemetry observability with Langfuse and W&B Weave support, history compression to manage token costs, and fine-grained Java thread pool control via ExecutorService configuration.

    10

    1
19. 19
    Article

    Inside Java·7w

    HTTP Client Updates in Java 26 – Inside.java

    Java 26 (releasing March 17th) brings several updates to the java.net.http.HttpClient. The headline addition is HTTP/3 support via JEP 517, with HTTP/2 remaining the default. Four strategies are outlined for handling HTTP/3 connectivity: optimistic HTTP/3-first, parallel HTTP/3 and HTTP/2 requests, pessimistic HTTP/2-first with ALT_SVC discovery, and HTTP/3-only mode. Other changes include a new BodyPublishers.ofFileChannel() method for uploading file regions, a fix for SSLParameters signature schemes being ignored during TLS handshake, an extended request timeout that now covers response body consumption, removal of Content-Length headers on non-POST/PUT requests without a body (per RFC9110), a NoSuchFileException to FileNotFoundException mapping fix, and a Max-Age cookie attribute precedence fix per RFC 6265.

    10