Richard Gross on JAVAPRO International

Destructoring is the future of Javas Encapsulation

Tue, 26 May 2026 07:00:00 +0000

Encapsulation in Java has been broken since the Java Development Kit (JDK) 5. Objects should guarantee that their inner state matches what we cast into code, but at runtime any private and final state can be set from the outside to any value — bypassing any checks and asserts. This is possible through the Reflection Api, which allows to setAccessible any private field and then set the value of any final field. This specific use of the Reflection Api to mutate an immutable final field is called deep reflection.

Kotlin kontra Java - Part 3 - Language for Interop

Thu, 07 May 2026 07:00:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin? Why not both?

You can use any Java library you want in Kotlin, you can even co-write your software in both languages (e.g. one team I work with writes their JUnit tests in Kotlin, their main code in Java) and migrate to Kotlin or back to Java over time. Kotlin is designed with Java interoperability in mind, because JetBrains wanted to migrate their IDEs (IntelliJ IDEA, WebStorm, etc.) incrementally to the language. But how does that work? What does Kotlin do, so that interop to this degree becomes possible?

Kotlin kontra Java - Part 2 - MultiPlatform

Wed, 22 Apr 2026 07:45:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

You might have a preference based on the ecosystem — the tooling around it, who we can ask for help, and the libraries we can use — which we discussed in part 1 of this article series. Or you might have a preference based on the business modeling capabilities of Java or Kotlin, which we will show in part 3.

Kotlin kontra Java - Part 1 - Ecosystem

Thu, 16 Apr 2026 07:00:00 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

Kotlin is used by Amazon, Atlassian, Duolingo, Google, JetBrains, Meta, Netflix, Uber and many more. Java is used by, well, „more than 3 billion devices“. Which one provides the biggest benefit, which one can give us an edge, which one should we pick?

After 20 years of building systems in Java and 8 years of doing the same in Kotlin, I’ve seen Kotlin earn its reputation as a natural evolution of Java. Rightfully so. Much of what we need can be expressed very cleanly with little verbosity.

Map your Code - Master your Architecture

Tue, 21 Oct 2025 07:00:01 +0000

In projects with hundreds of thousands of lines, it is easy to lose track of code, architecture and quality. Are we still on the right track, are we blocking ourselves with internal dependencies, or are we already stuck? Software is immaterial; we cannot see how it is doing.

To know how our software is doing, we have systematically check if the mental models of the developers matches the written code. Spoiler, they do not, as software changes too fast to keep track, every developer has their own model and no one has the complete picture.

Fixing the Billion-Dollar Mistake

Thu, 07 Aug 2025 07:00:00 +0000

There are mistakes that are just costly. Then there is the null reference. A language feature that was added in 1965 “simply because it was so easy to implement”. Since then, null references have caused countless bugs, system crashes and security problems - and cost billions of dollars in maintenance and troubleshooting. It has been eliminated in many new programming languages and this article will show the practical ways to eliminate this language mistake even in Java.

A visual chronicle of the JDK's journey

Tue, 08 Jul 2025 07:00:01 +0000

The Java Development Kit (JDK) has undergone significant transformations since its inception. From it’s “write-once, run everywhere” beginnings, over the applet wars, through the first release of the OpenJDK to the new release cadence, that has kept us occupied for the last eight years already. In 30 years a lot has happened.

Most of that journey is chronicled only in, arguably, dry textual representation. The text tells us how many features were added, changed or, very seldomly, removed. It does not tell us what impact that had on the code. What were the key architectural changes, what were the refinements and how were the complexities of such a large code base handled?