Java 25 quick wins

Here are some simple improvements that Java 25 brings to your everyday code.

Hello World simplified

Since the release of the C programming language, printing "Hello world!" is the first task a programmer does in a language. And Java did not shine at this:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

We tell our students it's magical incantation that they'll have to live with for a while and that all will become clear in due time.

At last Java 25 brings this down to the essentials:

void main() {
    IO.println("Hello, World!");
}

If I'm counting well, we go down from 89 characters to 40 characters,  That's less than half of the code. Additionally the code is more intuitive to understand.

 

This feature is called compact source files. The above improvement uses

• a launchable main method. The method automatically resides in a top level class in the unnamed package
• A new Input/Output class 

Less imports

void main() {
  List<String> ducklings = List.of("Huey", "Dewey", "Louis");
  IO.print("Hello " + ducklings);
}

We're all used to not having to import java.lang.String because Java automatically imports java.lang.*.

Java now automatically imports the java.base module.

Importing a module implies importing all public top level classes and interfaces in packages exported by that module.

The top level packages are defined in the module definitions, which exist since Java 9.

One of the packages exported by the java.base is java.util.*. Hence we do not need

import java.util.List;

for the code above to run anymore.

Additionally a program can now import modules without having to be a module itself, 

making modules more accessible to developers who never dabbled with them themselves.

You import modules (here java.util.desktop) using

import module java.util.desktop;

More flexible constructor bodies

You can now put safe statements before the first call to this(...) or super(...). Safe statements are anything that does not refer (implicitlyu or explicitly) to this.

 

IntelliJ 2026.2 highlights

• logpoints: extend logging breakpoints. They put your logging statements in the IDE (allowing you to put logging in code you do not own). And they allow you to navigate from an execution log to the code producing the log, even if the logging was done from a println in code!
• better dependency completpion  for tools like gradle (finally!)
• Spring Security Inlays for MVC endpoints allowing you to examine appliccable rules and thest them.
• More git conflict resolution proposals
• Better docker)compose.yml support, including the state of running containers 
• typescript 7 support 

Headroom optimizes your AI token use

Headroom is open source software that anaylises the tokens you send to AI and tries to reduce their verbosity before sending them to your AI provider.

Headroom claims to reduce your token consumption by 60-95%. 

OpenAI claims it can decompile binaries

In a move to counter Anthrophic Mythos ApenAI claims it can generate the source code for binaries, with GPT-5.4-Cyber.

Of course, just like Mythos, it is only given to selected companies. 

So... from now on, all software is implicitly open source. 

more... 

windows equivalents for popular unix commands

Some Windows cmd equivalents for common Unix commands and settings for my onw reference

unix	cmd	powershell
echo $variable	echo %variable%	$variable $env:variable //environment variable
~	%USERPROFILE%	$env:USERPROFILE
variable=value	%variable%=value	$variable=value
cp source target	copy source target
cp -r source target	xcopy source target /e/h
find -name '*.txt'	dir /s *.txt
grep text	findstr text
ls -a	dir /a
rm file	del file
rm -rf directory	rmdir /s /q directory
which command	where command	(gcm command).Path

Java 26 released

Java 26 adds HTTP/3 support to the HttpClientApi.

Other features here