Major changes in Kotlin's leadership: Roman Elizarov departs from JetBrains

1. Interview with Brian Goetz on the past, present and future of Java.

Interviews are among my most favourite types of material, which, thankfully, due to the popularity of podcasts, are now more common than ever. They allow different perspectives to come together, even when the host serves mainly as a ‘proxy’ for the questions of the listeners. That form (especially when the interview is well conducted) make it more difficult to hide the weaker sides of solutions being discussed or argumentations – especially when compared to written texts. These tend to be filtered through the prism of a single creator and it’s very easy to get away with uncomfortable questions…. because, you know, there are no questions.

Of course, if these interviews are well-run and the journalists do their job

Today, I wanted to start with an interview with Brian Goetz from the official Java channel. In this video, he delves into various aspects of the language and rationalises some decisions. He starts by discussing the naming convention for getters and setters in Java records, suggesting a shift away from the outdated Java Bean convention. As the conversation progresses, Goetz talks about the benefits of non-mutability, emphasizing the pitfalls of relying too much on state mutation. The discussion also includes the potential of Union types in Java, the challenges they can pose, and the delicate balance of including exceptions in the Stream API.

In the second segment of the interview, Goetz delves into advanced Java concepts and forthcoming features. He talks about the possibility of automating method wrapping and delegation, hinting that this is under consideration for future Java versions. A significant part of the interview also revolves around the equilibrium between the risks and benefits of the new Preview features, on the example of the ongoing Project Valhalla. Wrapping up the interview, Goetz discusses the potential for implementing a native data table structure in Java. This would enable entry into domains heavily dominated by solutions like Python’s Pandas and NumPy. He also expresses optimism about Java’s future significance in game development and education.

It just short summary – I strongly suggest you go through the whole thing, which shows distinctive viewpoint of the individual responsible for developing a considerable portion of Java:

2. Significant shifts in Kotlin’s leadership: Roman Elizarov leaves JetBrains

In the Kotlin universe, Roman Elizarov, the project lead, announced his departure from JetBrains on a Friday afternoon due to personal reasons. This also marked the end of his contributions to the language. He expressed his gratitude for the chance to work on Kotlin and his deep appreciation for the Kotlin community through a series of farewell tweets.

We discovered who will be guiding the language’s future – Mikhail Zarechenskiy, who previously worked behind the scenes at JetBrains, is set to become the lead designer for Kotlin. Significant team changes also include Hadi Hariri, known to many as the Co-host of the Talking Kotlin podcast. He will now assume more responsibilities beyond promotional activities and his participation in KotlinConf. Additionally, the other Talking Kotlin host, Sebastian Aigner, will take on a more significant role at the Kotlin Foundation, especially in supporting the wider Kotlin ecosystem’s initiatives. Egor Tolstoy will continue to lead the team from the Product Management side.

I would like to take this opportunity to sincerely thank Roman Elizarov for the significant impact he has had on my career. His publications were what introduced me to the realm of JVM Runtime and the design of programming languages. In a way, he can be considered the ‘godfather’ of this newsletter.

I’m sure Roman Elizarov isn’t reading this, but as he moves on to his next ventures, I wish him only the best 🙇.

3. Release Radar

Helidon 4.0

Helidon 4 has officially launched, marking its position as the first microservices framework to utilize virtual threads. The primary alteration accompanying this release is the substitution of Netta with a fresh server implementation named Níma. Níma is engineered to fully leverage Java 21 virtual threads, enabling each request to operate on a dedicated virtual thread. This streamlines the execution of blocking operations and offers a high degree of concurrency, thereby negating the necessity for intricate asynchronous code. This enhances performance, particularly (as per the framework creators’ own assertion) in Helidon MP. It also signifies that we have witnessed the debut of the first framework that necessitates Java 21 to function… launched merely a month ago.

Helidon SE, the core set of APIs for Helidon, also has undergone significant changes. The introduction of virtual threads has led to a transition from asynchronous APIs to blocking APIs. This shift simplifies the code, making it easier to write, maintain, and comprehend – hinting at what might be in store for the entire JVM ecosystem in the future. However, those using Helidon 3 SE will need to significantly modify their code to accommodate the updated APIs. While this might necessitate some initial effort, the potential gains in performance and code simplicity appear to be well worth it. The official upgrade guide offers advice on transitioning applications to the updated Helidon 4 SE.

The most recent version of Helidon now includes support for MicroProfile 6.0. Along with this release, there is also an official update guide specifically for Helidon 4 MP. This guide is designed to assist users in understanding the updates and facilitating a seamless transition.

The entire matter is recent (the news came out just yesterday), and we will likely dedicate some space to it in the future – once we’ve evaluated the effectiveness of the new approach in practice.

Don’t worry Netty, we still have you in our hearts.

And as we’ve previously discussed the topic of Microprofile…

Microprofile 6.1

MicroProfile has announced the launch of MicroProfile 6.1. This updated version is fully compatible with Jakarta EE 10 Core Profile. No new APIs were introduced in this release, but there were slight enhancements to the MicroProfile Configuration, Metrics, and Telemetry. The following graphic provides a comprehensive list of modifications.

MicroProfile 6.1 requires Java SE 11. If you’re interested in giving it a shot today, Open Liberty 23.0.0.10-beta is the initial compatible implementation. This is, however, for the most courageous.

Official Java Extension for Visual Studio Code from Oracle

Oracle has launched official Java extensions for Visual Studio Code, indicating the increasing popularity of Visual Studio Code as a substitute for traditional IDEs. Despite Java having specialized IDEs (like Intellij), a considerable number of Java developers, including students and those for whom Java is a non-main language, favor VS Code today. To give a personal example – in my situation, it also serves as a Swiss Army Knife.

The initial version comes with features like autocomplete, error highlighting, debugging support, and compatibility with Gradle and Maven projects. But, there’s more going on behind the scenes. This is because the foundation of this extension to VS Code is a language server that interacts with the IDE through the Language Server Protocol. Oracle’s Java language server is based on the one used in the Apache Netbeans project and utilizes the javac compiler from the OpenJDK JDK. This ensures quick support for new JDK features in VS Code. Moreover, while the language server’s development will persist under the Apache NetBeans project, the extension to VS Code will be a part of a distinct open source project.

For those who are unaware, the Language Server Protocol (LSP) is a standardized protocol used for communication between development tools (like development environments or IDEs) and language servers. These servers provide language-specific functions such as code completion, error checking, and refactoring. With the help of LSPs, tools can support various programming languages without the need to implement language-specific functionality. Moreover, a single language server can be utilized across multiple tools. This presents a significant opportunity for new IDEs and Code Editors, as they don’t have to build all their support from scratch.

For those who don’t already know – that green in the middle is the sainted Atom from GitHub.

PS: I hold this topic dear as we are working at my firm, VirtusLab, on a language server for Scala – Metals.

WildFly 30

WildFly 30 has also been released. Despite the official recommendation still being JDK 17 or 11, a substantial portion of this release has been devoted to integration with Java SE 21. The most recent version successfully passes both Jakarta EE 10 Core Profile and Microprofile certification tests on this release. As the focus on JDK 21 intensifies, it’s expected that WildFly 30 might be the final version to support JDK 11.

Additionally, the arrival of WildFly 30 brought about a change in license from Lesser General Public License 2.1 to Apache Software License 2.0, wrapping a long-standing journey. The shift from Lesser General Public License 2.1 (LGPL 2.1) to Apache Software License 2.0 (ASL 2.0) signifies the transition from a ‘weak’ copyleft license to a more lenient one. While LGPL 2.1 permits bundling with proprietary software, it demands that alterations to the licensed software be released under the same LGPL 2.1 license. On the other hand, ASL 2.0 allows users to freely use, modify, and distribute the software, even incorporating it into proprietary projects, without any obligation to disclose modifications or derivative works. However, it’s crucial to mention that WildFly utilizes several component libraries under various open-source licenses, and the license change only applies to some of them.

Eclipse Temurin JDK 21

We have at last seen the release of the variant JDK 21 by the Eclipse Foundation, the successor to the former AdoptOpenJDK. I believe many individuals have been anticipating this news.

Intriguing is the topic of the over one month delay in comparison to other versions. Despite the OpenJDK 21 GA source code undergoing testing and verification, the official Temurin 21 release experienced delays due to the newly introduced Java 21 TCK testing license agreement, which came into effect just before the OpenJDK 21 GA. Consequently, the Eclipse Foundation had to meticulously review and approve this updated agreement. For a while, only early access versions were accessible, which were not advised for production use. However, by October 9, 2023, Adoptium had obtained the Java Technology Compatibility Kit (TCK) for Java 21, guaranteeing its adherence to the Java specification. The TCK testing took a while to complete, but we now have the final version.

And finally, two interesting webpages.

https://rss.xlit.app/updates – I recently discovered a Twitter account and its associated RSS feed that enables you to stay updated with the latest JEPs, all developed by Alireza Ghasemi. While it’s not groundbreaking, it’s a useful tool if you want to ensure you don’t miss out on any new content – it lets you monitor the list from as early as the Draft stage.

awesomejava.resamvi.io is associated with community-curated Awesome lists, which gather the most crucial tools for developers or other intriguing material. These lists are so abundant that meta-lists, such as Awesome Awesome (nearing 300,000 stars on GitHub), or the demand for alternative browsing methods have been established. One such instance is awesomejava.resamvi.io. It houses the official Java edition of an awesome list, but with a unique twist – each category is sorted based on the number of ‘stars’. Many people consider this an important factor (and not the worst proxy for decision-making), so if you’ve been exploring ‘awesome lists’ until now, consider giving this new presentation of ideas a try.

PS: Although it’s slightly off-topic, I would also suggest checking out system-design-101, a fresh collection of resources from ByteByteGo. It’s truly excellent, particularly for those who need a quick review before job interviews, and IMHO for more that only that.

And finally, some personal impressions from recent travels.

Both Geecon and EclipseCon were remarkable events that I plan to attend next year. I had the opportunity to meet numerous amazing individuals and view our ecosystem from a unique angle. I also found out that the German Java community, iJUG, has been regularly releasing a physical paper magazine ‘Java aktuell’ since 2010.

Decidedly a very cool addition to my collection of Java-related gadgets.

PS3: I’ve rekindled my old love for laptop stickers. I have no regrets.

If you’re interested in the highlights of EclipseCon, Ivar Grimstad, a Developer Advocate for Jakarta EE, shared his thoughts here. He also posted a more detailed account on his blog. Regrettably, I couldn’t find any detailed lessons learned from GeeCon Prague, and I was only able to attend the second day due to my plane being delayed by nearly 5 hours…

And with this bittersweet sentiment, I bid you farewell! I look forward to seeing you in the upcoming edition, hopefully on a more consistent basis.

Major changes in Kotlin’s leadership: Roman Elizarov departs from JetBrains – JVM Weekly vol. 152