11 August 2026

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.

 

7 August 2026

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 

31 May 2026

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%. 

26 April 2026

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... 

17 April 2026

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

22 March 2026

Java 26 released

Java 26 adds HTTP/3 support to the HttpClientApi.

Other features here

20 February 2026

How to let AI use a debugger

An interesting read from foojay.io:

Java contains a text base debugger.

As AI also is text based Bruno Borges added a skill to his AI to use the debugger and debug a program.

Check it out!