r/java

Cabe automatically adds null-checks to your classes based on JSpecify annotations.

The new version fixes compatibility issues with the configuration cache in Gradle 9.6+.

For details, check the documentation and the project GitHub page.

https://openjdk.org/jeps/539

https://m.slashdot.org/story/455546

Hi there,

After creating a plugin for my personal use I thought about uploading it to the plugins repository, you perhaps already guessed from the title that it supports both gradle and maven so no more different plugins, additionally it also looks into your checkstyle versions if you use one. Here is the link.

https://plugins.jetbrains.com/plugin/32489-dependency-scout/

JVMCI will be removed in Java 27: https://bugs.openjdk.org/browse/JDK-8382582

It was used by GraalVM to hook the Graal compiler as a JIT compiler for OpenJDK.
Now that it's gone, it's not clear how GraalVM will work? Would it still be possible to use the Graal compiler instead of C2 or would it only be usable for AOT (native image) and polyglot?

I'm trying to validate whether this is a real problem that other Java developers face, or whether it's just something specific to my setup.

A while ago I was working on a project where I regularly had around 9 spring boot microservices running locally, along with Activemq and elasticsearch.

Quite a few times I'd hit a point where few services (very often Elasticsearch) simply wouldn't start because the machine was running out of memory. My usual soln was to manually lower the -Xmx of some services, restart them, and keep experimenting until everything fit.

It made me wonder:

- How common is this for people working with multiple JVM services locally?

- Do you just accept it and restart services with different heap sizes?

- Do you have fixed -Xmx values checked into your projects?

- Do you use Docker resource limits or just buy more RAM?

- Have you ever had to stop one service just to start another?

I'm also curious about production.

When services begin running into memory pressure:

- How do you usually detect whether it's a genuine memory leak or just increased load?

- How often do you end up changing heap sizes?

- Is this mostly handled by Kubernetes/VPA/manual tuning, or is it still a fairly manual process?

The reason I'm asking is that I've been experimenting with an idea for a tool that continuously watches JVM heap usage, tries to distinguish memory leak from normal load, and could automatically rebalance heap allocations (or restart a JVM with a better heap size when necessary) instead of requiring manual tuning.

I'm not trying to promote anything I'm still in the research stage and genuinely want to know whether I'm solving a real problem or one that only I experienced.

I'd really appreciate hearing how people currently deal with this in both local development and production.

Hey, this post tries to explain how Kronotop handles connections and integrates Java virtual threads with Netty.

Apple has transitioned its hardware platform to AArch64, and is thus phasing out its support for x64. Oracle engineers will thus stop maintaining the macOS/x64 port as of JDK 27. Maintaining the port is a significant undertaking and no clear long-term maintenance commitment for the port has been identified.