Preview Feature

Let’s talk about Java 21 and have a sneak-peek into Java 22, and things like: Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java. To name a few changes:

• Virtual Threads (and some traps),
• Pattern Matching and Record Patterns,
• Structured Concurrency,
• String Templates,
• Stream Gatherers,
• changes around main() method,
• what’s gone and what will be gone,
• and other things. If you find them interesting, let’s dive deep together into new interesting stuff!

This talk has been given for Silesia JUG only, no recording.

Hey, there are two major Java versions released every year! We don’t have to wait 3 years or so for new features anymore. Isn’t that cool? 😉

Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java.

To name a few changes:

Hey, there are two major Java versions released every year! We don’t have to wait 3 years or so for new features anymore. Isn’t that cool? 😉

Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java.

To name a few changes:

When I have time to talk about Java for more than one hour, it’s a Deep Dive (I call it “What’s new and noteworthy?”) When I have less than forty minutes, we can barely touch the surface, hence it’s called then “Surfing Modern Java”. Anything in between, like regular-size talk, is more than surfing, but less than deep dive, hence “Sailing Modern Java”.

For such a talk I usually cover one or two latest releases, sometimes mentioning what’s ahead of us, trying to sneak in as many code demos as I can.

Hey, there are two major Java versions released every year! We don’t have to wait 3 years or so for new features anymore. Isn’t that cool? 😉

Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java.

To name a few changes:

Another (half a) year has passed, another major Java™ version has been released. Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java. We’re going to cover:

• Records, where and how to use them, apart from DTO/VO
• Pattern matching with instanceof A.K.A. Smart casting
• Sealed classes, new dimension of types extensibility (for inheritance)
• Warnings from Jigsaw (–illegal-access strikes back!)
• And Valhalla (for value-based classes abuse)
• Talking to native stuff from Panama
• and more.

All visualised in actual code, not just slides.

Another (half a) year has passed, another major Java™ version has been released. Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the rules of the game. That’s a good reason to check out what’s new in Java. We’re going to cover:

• Records, where and how to use them, apart from DTO/VO
• Pattern matching with instanceof A.K.A. Smart casting
• Sealed classes, new dimension of types extensibility (for inheritance)
• Warnings from Jigsaw (–illegal-access strikes back!)
• And Valhalla (for value-based classes abuse)
• Talking to native stuff from Panama
• and more.

All visualised in actual code, not just slides.

In the dark ages, we had to wait for 3-4 years to see the new Java version with some new features. Now there are two major releases every year! Can we benefit from the new features before the next LTS release?

We don’t have to wait 3 years or so for new features any more. Isn’t that cool? 😉 So… you’d like to check what has happened since Java 11? Record types? Switch expressions? Pattern matching? No more NPE? String blocks? New functions in APIs? What are the Shenandoah and ZGC about? AppCDS to speed up spin-off?

Another (half a) year has passed, another major Java™ version has been released. Java was supposed “to be slow”. However, Java turns out to evolve so fast, that next releases aren’t just version bumps, but might significantly change the game rules. That’s a good reason for another deep dive in Java. We’re going to cover:

• Production ready GCs: ZGC and Shenandoah, if you don’t like ice ages
• Text blocks, which make Strings easy to declare also for non-liners
• Pattern matching with instanceof A.K.A. Smart casting
• Records, where and how to use them, apart from DTO/VO
• Sealed classes, new dimension of types visibility (for inheritance)
• Hidden classes, which are so hidden, that they can’t even use themselves
• Foreign memory access, for some off-the-heap data
• Helpful NPE messages, which make chasing nulls easier than ever

And of course removed, deprecated and tuned stuff (bye bye Nashorn). All visualised in actual code, not just slides.

Java 14 brought Records as one of the preview features. For many it was reasonable to say “no more JavaBeans code generation” or “Lombok is dead”. Is that really the case? What one can do with records and what can’t? What about reflection and serialization?