IntelliJ IDEA
IntelliJ IDEA – the Leading Java and Kotlin IDE, by JetBrains
‘JEP Explained’ – a series of interviews on Java 23 features
Java 23 says HelloWorld!
Curious about what’s new and why it matters to you? If you’re looking to go beyond the basic syntax updates and dig into the bigger picture—complete with behind-the-scenes stories and the experiences of seasoned experts—this blog and our JEP Explained video series are just for you!
‘JEP Explained’ is a heartfelt collection of conversations with the Java architects and experts who helped bring these new features to life. These conversations dive into JDK Enhancement Proposals (JEPs), which are the key features planned for each JDK release. We’re here to help developers, teams, and anyone passionate about Java not just understand the new updates, but also how they can make a real difference in your everyday coding.
In this post, you’ll find a handy guide to all eleven interviews. Take your pick, dive in, and enjoy learning from the very people shaping Java’s future. Happy learning!
Full Interview Series Published
Here’s the complete list of published interviews, each with a link to the recording and a brief overview of the episode.
1. JEP 455 – Primitive Types in Patterns, instanceof, and switch
In the first episode of JEP Explained, we were privileged to interview Brian Goetz, Java language Architect with Oracle, Aggelos Biboudis, Principal Member Technical Staff, Oracle, and Tagir Valeev, Java Team Technical Lead, JetBrains on JEP 455.
Find out the bigger picture of why primitive data types are being added to pattern matching in Java, the finer details of these changes, and a quick demo on how to use them in your codebase.
Don’t miss the fun sections at the end, where all these experts try their luck with tongue twisters, clarify whether some statements are a myth or a fact, and the super fun section when they respond to statements by enacting emojis.
2. JEP 482 – Flexible Constructor Bodies
This episode of JEP Explained covers JEP 482, which proposes changes to constructors by relaxing the rules to make them more flexible. With this change, you will be able to execute statements before calling super() or this() in a constructor. This feature also allows you to initialize members of a derived class before calling the parent constructor.
In this episode, I interviewed Dr. Venkat Subramaniam, a prize winning author, one of the most popular and respected Java expert, long time professor, Java Champion, and organizer of the Dev2Next conference.
Dr. Venkat discussed and demonstrated the issues in our codebase without this feature, and how to address them using this feature.
Don’t miss the fun sections at the end, where Dr. Venkat tried his luck with tongue twisters, clarified whether some statements are fact or fiction, and the section when he responds to statements by enacting emojis.
3. JEP 477 – Implicitly Declared Classes and Instance Main Methods
Want to know why and how the ‘public static void main(String[])’ method signature is changing to ‘void main()’ while ‘System.out.println()’ is changing to ‘println()’?
In this episode of JEP Explained, I interviewed Ken Fogel about JEP 477. Ken is Department Chairperson Program Coordinator of the Computer Science Technology Program at Dawson College, Research Scholar in Residence at Dawson College, and professor with 21 years of experience teaching Java. Ken is also a Java Champion, Conference organizer for JConference, and JCP Executive Committee Member.
The goal of this JEP is to simplify getting started with Java for new Java developers. It does so by introducing simple yet significant changes, like changing the signature of the ‘main’ method from ‘public static void main(String[])’ to ‘void main()’, changing the need to use ‘System.out.println()’ to using ‘println()’, and much more.
In this interview, Ken talks about the relevance of these changes for new Java developers and how it will help those teaching “Java 101” to focus on the concepts that benefit beginners the most. Ken also talks about how the new feature can help students to stay focused on building strong computing and logic-building foundations and be introduced to new concepts in an incremental manner.
Don’t miss the fun sections at the end, where Ken tries his luck with tongue twisters (he aced it), and the section when he responds to statements by enacting emojis.
4. JEP 466 – Class-File API
As a Java developer, should you know all of the details of the Class-File API or do you just need a general understanding? What benefits does this API offer for parsing, generating, and transforming Java class files?
Find out in this episode of JEP Explained, where I interviewed Rafael Winterhalter about JEP 466. Rafael is a Java Champion, consultant, blogger, conference speaker, and author of Byte Buddy – a Runtime code generator for the Java virtual machine.
In the interview, Rafael talks about the relevance of the Class-File API; which applications, frameworks, or libraries would use it; and how the developers have been parsing, generating, and transforming source code files until now. He covers the different kinds of transformations that are available and how Byte Buddy, a file transformation tool he authored, works.
Rafael also talked about the benefits and drawbacks of the Class-File API, drawing on his hands-on experience with Byte Buddy.
Don’t miss the fun sections at the end, where Rafael tries his luck with tongue twisters (he aced it) and the section when he responds to statements by enacting emojis.
5. JEP 480 – Structured Concurrency
What if you could manage multiple threads as smaller parts of a main task, making them easier to debug and cancel in one go, without worrying about leaks or delays? With structured concurrency, you can. It introduces a new API to simplify concurrent programming, making it more reliable.
Find out more about this and more in this episode of JEP Explained, where I interviewed José Paumard about JEP 480. José is a Java Champion, author, speaker, developer advocate, oracle, former university professor, JUG leader, conference organizer, JavaOne Rockstar, and presenter of the JEP Cafe series on Java’s YouTube channel.
If you are interested, you can find more information on structured concurrency and virtual threads here.
José started the interview by discussing who this JEP is for and the benefits and shortcomings of structured concurrency. He then went on to highlight the essence of structured concurrency – how it makes it easy to debug, test, and observe concurrent applications. He also demonstrated structured concurrency using hands-on examples.
Don’t miss the fun segments at the end, where José tries his luck with tongue twisters, and the part when he responds to statements by enacting emojis.
In the last section, José mentioned a couple of unconferences. Here are the links to them if you are interested:
Jalapeño, Mexico
JChateau, France
JAlbas, Scotland
JCrete, Greece
6. JEP 467 – Markdown Documentation Comments
With “Markdown Documentation Comments”, you can write JavaDoc comments using Markdown, which is easier to write, read, and convert to HTML. If you prefer, you can still write the documentation comments using HTML and JavaDoc tags, or use a combination of Markdown and JavaDoc tags.
Learn more about “Markdown Documentation Comments” in this episode of JEP Explained, on JEP 467 with Jonathan Gibbons, owner of this JEP and Java SE Language Tools Team Lead at Oracle, and Dmitry Chuyko, Senior Architect at BellSoft and OpenJDK contributor.
Jonathan started this interview by addressing what this feature is about and why it was added. Dmitry talked about the relevance of documentation as a developer, explaining how often developers like him refer to the documentation comments to learn more about a library or an API.
On the face of it, a lot of developers would say that this is just Markdown. But Jonathan had other views. He shared why he thinks it’s not all down to Markdown’s quirks. Dmitry helped us understand the relevance of Javadoc documentation from the perspective of developers. He mentioned that developers often write Javadoc documentation to help their peers use codebases, libraries, and frameworks in the intended way. He also covered whether this feature should be relevant only to those developing libraries or APIs or to all developers in general.
Jonathan discussed the different variations of Markdown at length, detailing why the specific version is important and relevant. At the end, Jonathan covered the key considerations when converting between the HTML and Markdown documentation styles, with special attention paid to horizontal and vertical whitespaces and excessive HTML.
Don’t miss the fun segment at the end, where Jonathan and Dmitry tried their luck with tongue twisters and responded to statements by acting out emojis.
7. JEP 469 – Vector API (Eighth Incubator)
The Vector API, still in the incubation phase, is an API for vector computations that performs better than scalar computations.
Learn more about vector and scalar computations and the Vector API in this episode of JEP Explained, where I discussed JEP 469 with Zoran Sevarac, Founder and CEO of DeepNetts, a leader in deep learning and AI, co-author of JSR 381, and a Java Champion.
Zoran started by discussing what scalar and vector computations are. He talked about the prerequisites to understand this API in terms of the concepts and hardware that can run vector computations. He also examined the target audience of this feature – applications or developers that could benefit from vector computations and the Vector API.
After covering the Vector API basics, Zoran explored HotSpot’s auto-vectorization algorithm and how developers can use it, common Vector operations, and how long he has been using the Vector API at work.
Don’t miss the fun segment at the end, where Zoran tries his luck with tongue twisters and responds to statements by acting out emojis.
8. JEP 473 – Stream Gatherers
Stream Gatherers are being added to the Stream API to help you define custom intermediate operations on streams.
What are its design considerations, and how can it help application and library authors? Learn more about this feature in the latest episode of JEP Explained, where I discussed JEP 473 with Viktor Klang, Java Architect at Oracle, and Tagir Valeev, Java Team Technical Lead at JetBrains.
Viktor started this interview by discussing what it means to add custom intermediate operations via Gatherers and what pain points it addresses for developers.
Tagir is the creator of a Streams-based library, StreamEx. He mentioned that one of the main reasons for creating this library was the lack of support for more intermediate operations in the Streams API. He shared his experience of working with this library and its design decisions.
Adding functionality such as Gatherers requires very careful design considerations, since the Streams API is a popular Java library. Viktor talked about how long he and his team worked before finally adding Gatherers to the Streams API, the classes and interfaces being added to the Streams API to implement Gatherers, and concurrent/parallel and ordered/non-ordered gatherers.
Viktor also addressed a design question concerning how Gatherers work. He covered their functions, the initializer, integrator, combiner, and finisher, and how the design pattern is similar to stream processing. Vicktor talked about the value of built-in gatherers, primarily that they are easy to discover and get started with until developers need or want to create their own custom gatherers.
Viktor compared the design of Gatherers with that of Collectors and discussed the importance of submitting feedback on this feature to Oracle.
Don’t miss the fun segment at the end, where both Viktor and Tagir try their luck with tongue twisters and respond to statements by enacting emojis.
9. JEP 471 – Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal
Do you know that 79 of 87 methods in the sun.misc.Unsafe class are being marked as deprecated. How would this affect you as an application/ library or framework developer? What alternatives are available? Why were these methods even deprecated in the first place?
Find out more about this and more in this episode of JEP Explained, where I interviewed Ron Pressler, Technical Lead, OpenJDK, about JEP 471.
Ron started by answering questions on deprecation in general – the reasons why types, methods or variables are marked for deprecation, how they are identified, and how long they are marked for deprecation until they are finally removed.
Ron then went on to talk about the target audience for this JEP, which is relevant and important for all Java developers, not just library and framework developers. Ron talked about the replacement for the methods marked for depreciation in Unsafe, i.e. the VarHandle API (Java 9) and Foreign Function & Memory API (Java 22).
Ron also covered “Integrity by Default”, stating that this JEP (471) is part of this bigger idea. It is an interesting read that talks about how the Java language architect believes in preserving the integrity of Java, and how it would help both the developers and Java.
Finally, Ron discussed the roadmap of deprecating these methods – what happens next, how to provide feedback to the Oracle team on your experience of using this feature (or should I say not using it and using alternatives instead). 🙂
Don’t miss the fun segments at the end, where Ron tries his luck with tongue twisters, and the part when he responds to statements by enacting emojis.
10. JEP 474 – ZGC: Generational Mode by Default
With this JEP, the default mode of the ZGC, that is, the Z Garbage Collector, is now set to generational mode. Do you know what ZGC’s generational mode is and the benefits it offers? Learn more about garbage collectors in general and ZGC in particular in the latest episode of JEP Explained.
In this episode, I interviewed Monica Beckwith and Paul Bakker about JEP 476, which changes the default mode of the Z Garbage Collector to generational. Monica is a Java Champion, Speaker, Java Performance Engineer, and IC Leader of the JVM Group at Microsoft. Paul Bakker is a Software Engineer at Netflix. He is also a Java Champion, author of multiple published books, and a speaker.
Monica started this interview by discussing what ZGC is and what its generational and non-generational modes are.
Paul discussed the target audience for this JEP – is it only for Java Performance Engineers, JVM team leads, senior developers, or all Java developers?
Monica helped us understand more about garbage collectors in general by talking about what kind of applications would benefit from different garbage collectors, such as Serial, Parallel, Shenandoah, G1GC, or ZGC.
Paul talked about the hands-on usage of the ZGC with generational mode and how this has helped Netflix cut down heavily on resource usage, resulting in lower costs.
Tuning garbage collectors is quite tricky. Monica talked about settings that are used with garbage collectors and how to use them. Paul shared insights on how garbage collectors are fine-tuned at Netflix.
Towards the end, Monica shared her opinion and experience of deprecating options for fine-tuning garbage collectors, why this is done, how it impacts developers and organizations, and how they can find the best options for their garbage collectors.
Don’t miss the fun segment at the end, where both Monica and Paul try their luck with tongue twisters and respond to statements by “acting out” emojis.
11. JEP 476 – Module Import Declarations
Did you know that with “Module Import Declarations”, you can use a single statement, `import module java.base`, to import all of the packages that are exported by `java.base`, such as `java.util`, `java.io`, and many more? Isn’t that short and sweet?
Learn more about this feature and how it helps you reuse modular libraries in the latest episode of JEP Explained, where I discussed JEP 476 with GavinBierman, Programming Language Designer at Oracle.
Gavin started this interview by discussing what this JEP is all about, mentioning that the ability to import multiple packages from modules had been missing for a long time. It was interesting to learn that this JEP was co-developed with another one, “Implicitly Declared Classes and Instance Main Methods”. The phrase “co-developing JEPs” was coined by Gavin.
Gavin covered the differences between single-type import and type-import-on-demand declarations, explaining what they are and why individuals and organizations prefer one style over the other. He also talked about how the “Module Import Declarations” feature automatically imports on demand from transitive dependencies of modules. He covered ambiguous imports and how to deal with them, name ambiguity, and how to submit relevant feedback on this feature to the teams at OpenJDK.
Don’t miss the fun segment at the end, where Gavin tries his luck with tongue twisters, or the part when he responds to statements by enacting emojis.
Playlist of these video interviews
If you find these interviews interesting, don’t forget to bookmark the link to their playlist.
Summary
Through the JEP Explained interview series, we aim to not only help you understand and apply new Java features, but also explore the stories behind them, their relevance, and their significance. Our goal is to go beyond the syntax, providing you with insights from JEP owners, authors, and industry leaders who have hands-on experience with these innovations.
Happy watching and learning!
Subscribe to IntelliJ IDEA Blog updates
