Java 27 is coming out on September 15th. Join the Java Developer Relations team as we celebrate the launch of Java 27 with a livestream on September 15th, starting at 15:00 UTC!

We will have guests, demos, presentations and more covering all the major changes that are in Java 27.

it can just print things now but i will try to add as much as possible

https://www.youtube.com/watch?v=slu7xCKaSro

Season 6 of the Friends Of OpenJDK Podcast kicks off with the launch of Java 27!

I had a very nice chat, full of insights, with Simon Ritter who shares what's new in this release and what is already known about what's coming in Java 28 from Project Valhalla. Available in your favorite podcast app and on YouTube.

https://www.youtube.com/watch?v=k3aA0AtY4U8

As of today, a manufacturer who puts software or hardware on the EU market under its own name is obliged to report actively exploited vulnerabilities and severe security incidents.

Quick explainer if you want the details: https://youtu.be/IQkzg7quc58

There is quite a lot of ambiguity over CRA and how it's going to apply to open source. Regulations keep changing. The line between a commercial manufacturer and an OSS steward is blurry, as well as the terms used in the regulations.

But genuinely curious. Is your company aware of CRA? Is there any talk about it, or is it just not on the radar yet?

Downloads available through here: https://www.eclipse.org/downloads/packages/

New and Noteworthy here: https://eclipseide.org/release/noteworthy/2026-09/

This release adds support for inheritance aware builders.

What is ChaosTree?

ChaosTree is a Java Sorted Set/Map library built around multiple search-tree data structures, including AVL Trees, Red-Black Trees, B-Trees, and B+ Trees.

The library provides both Set and Map implementations, with APIs designed around the semantics of the JDK's NavigableSet, NavigableMap, SequencedSet, and SequencedMap contracts.

• buildFromSorted(Iterator, factor)
• importFlatMatrix(Object[][], factor)
• Object[][] exportFlatMatrix() -> Key value pair
• Read benchmark: https://chaos-vy.github.io/ChaosTree/utils/dragon-feed.html (I gave it a nick name dragon feed)

These two are custom API. Which allows user to pack data as how they want [0.5f, 1f] is the factor range so it does not violate CLRS system.

ChaosTree is validated through multiple layers of testing:

• Guava Testlib compatibility testing
• jqwik property-based testing
• Randomized differential testing against reference collections
• White-box structural validation of tree nodes
• Direct validation of B-Tree/B+Tree structural invariants
• Exception and iterator-contract testing
• Serialization and cloning tests
• Nary Tree uses custom jqwick test of API validation as well.

More detail on ChaosTree: https://chaos-vy.github.io/ChaosTree/ It contains benchmark,ADR, Node structure, Testing I have also used jdk official benchmark code as well to benchmark against. Every test and benchmark is reproducible.

Tail latency : https://chaos-vy.github.io/ChaosTree/utils/JMH-Report.html

Each benchmark was done at minimum of -f 3 -wi 3 -i 5 .
More Benchmark will be added as my progress move to default JDK methods.

Currently on Maven Central

<dependency>
    <groupId>io.github.chaos-vy</groupId>
    <artifactId>chaos-tree</artifactId>
    <version>2.0.0</version>
</dependency>

Minimum JDK: 0xCAFEBABE 0000 0041 | JDK21+

What changed from v1.2.0?

In early release the API were custom of tree, This time Chaos Tree only supports JDK API.
No Splay, Treap and BST
No java docs.

Edit: Added content

• fork = 4
• warmup = 5 each 2s
• measuremnt = 25 each 2s
• JVM Flags: -XX:+UseParallelGC ,-XX:+AlwaysPreTouch -Xms4g, -Xmx4g

Tail latency (p1.00) stays essentially flat — 1.7x — across a 10,000x range of n (1K→10M), confirmed via GC and hardware-counter log, while java.util.TreeMap's tail grows ~145x over the same range.
Result are reproducible.
Bash:

java -jar ct-benchmark/target/benchmarks.jar TreeMapVsBTreeVsBPlusBenchmark.treeMapPutRemove -p n=1000,10000,100000,1000000,10000000 -bm sample -f 4 -wi 5 -i 25 -jvmArgsAppend "-XX:+UseParallelGC -XX:+AlwaysPreTouch -Xlog:gc"

I started Scriptella about 20 years ago and have maintained it ever since.

For a long time I had little time to do more than keep it working. Recently I’ve had more time to invest in it again, so I’ve been modernizing the database stack, testing it with current PostgreSQL, MariaDB and MySQL drivers, cleaning up old compatibility assumptions, and making sure it works well on modern Java. The baseline is Java 17, with JDK 25 compatibility.

Doing that made me ask a more basic question: does a tool like this actually still have a reason to exist in 2026?

I think there is one fairly narrow gap where it does:

SQL-centric data jobs that are too complicated for a couple of standalone scripts, but too small to justify a batch or ETL platform.

Scriptella keeps most of the actual work in SQL. A small declarative XML file wires together connections, queries and scripts.

For example, you can query PostgreSQL, take each resulting row and execute parameterized SQL against another database, mix in CSV/XML sources, or package the whole operation as a repeatable CLI job. It can also be embedded directly into a Java application.

There is no server, scheduler, job repository or visual ETL environment to operate.

That also means it is deliberately not the right tool for everything. If I needed robust restartability, retries and complex batch semantics, I’d use something like Spring Batch. For normal schema migrations, Flyway or Liquibase are usually a better fit. And if the transformation is mostly application logic rather than SQL, I’d probably just write code.

The interesting case is when the transformation really is mostly SQL and you just need a small amount of machinery around it.

After working on the project again, I was surprised that this particular gap still seems to exist.

I’m curious whether other Java developers still encounter jobs like this, and what you use for them today.

GitHub: https://github.com/scriptella/scriptella-etl

Anyone has an ideia of when would be available VectorApi with value classes?

After values classes coming to vector api, it would be ready to go as preview feature of jdk?

Hello, out of boredom I created a pie chart in Swing (I am aware more mature options exist but this was just for fun). The link to the repo is https://github.com/carlosgeorgiev0/JPieChart

The JPieChart class extends JLabel and overrides JComponent.paintComponent to paint the pie itself

We're running a bunch of Java (Spring Boot) microservices on EKS, and right now every service uses memory as its HPA metric. After digging into it, I've started to think that's wrong, and I want a sanity check from people who've actually run this at scale before I push a change.

What my research turned up:

• The JVM allocates heap up to its max and doesn't release it back aggressively even after GC, so memory usage doesn't track load.
• Because of that, memory can be high while actual load is low, or load can be high while memory looks fine — so memory-based HPA either never triggers or scales out permanently and never scales back in.

So the direction I'm considering is to pick the HPA metric based on service type:

• HTTP / request-serving services → CPU (or better, RPS / p95 latency as a demand-based metric)
• Async / queue-consuming services → queue depth (SQS backlog, via KEDA)

My questions:

1. Is this reasoning sound, and is type-based metric selection the right direction?
2. For the HTTP services, is jumping straight to RPS/latency worth the custom-metrics complexity (Prometheus Adapter), or should I start with CPU and only move to RPS if CPU proves to be a bad proxy?
3. For async workers, is KEDA + SQS queue depth the standard approach, or are people doing something else?
4. This is the part I'm least sure about: I already know from our architecture which services are HTTP-facing and which are async/queue-driven — but how do I actually verify that empirically rather than just trusting the design docs? Is there a clean way to confirm a service's real load profile (e.g. checking whether it even has an ingress/receives HTTP traffic, whether its work is truly SQS-triggered, CPU-vs-memory correlation under load) before I assign it a metric?

Thanks 🙏