Goodbye Lightbend, Hello Akka - The JVM's Most Popular Actor Model Implementation Gets a New Identity - JVM Weekly vol. 109

Today, it’s a very "mountainous" edition.

1. Together-Java's "Modern Java" as a response to the challenges of the release train model

Sometimes I get the question, "Hey, Artur, what should be the first resource for learning Java?" The issue is... complicated. I learned the language from the legendary Thinking in Java by Bruce Eckel , but it's really hard to recommend that book now (sorry Bruce) -it deals with Java that is quite prehistoric by today's standards. On the other hand, an interesting question arises: which Java version should a beginner learn?

I know that readers of this newsletter are well aware of which version of Java we are currently using, but try asking your friends—you'll see that their answers might surprise you. Ever since Java transitioned to the Release Train model, individual releases have started to blur together.

This is how it looks for most people

To recap: The “release train” model for Java means releasing new versions every six months, regardless of whether all planned features are ready. Based on a predictable schedule, this model allows developers and companies to prepare for updates on pre-set dates. Releases always occur on specific, predetermined dates, and JEPs (JDK Enhancement Proposals) that aren’t completed simply roll over to the next release, just six months away.

We’ll soon share the list of what to expect—in this year’s case, the feature freeze will happen on December 5th. Think of it as an early Christmas gift.

BTW: Santa won’t be real this year, judging by Coca Cola’s AI-driven ad campaign that replaced him:

Although this model brings predictability and accelerates innovation, its downside is the difficulty programmers face in keeping up with new features. The six-month cycles mean users often lack the time to fully understand and implement the new additions. Moreover, skipping any intermediate release makes it hard to go back and catch up on features introduced there.

The ModernJava project was created to address this issue—a community initiative by Together-Java that I recently discovered. It aims to create a modern Java learning resource. The project presents the language as if its latest features—such as records, pattern matching, or concurrency-oriented tools like Project Loom—were always an integral part of Java. This way, both beginners and advanced programmers can learn modern design patterns and practices without the baggage of outdated conventions. This initiative emphasizes accessibility, practical examples, and a unified approach to learning the language, helping users efficiently acquire knowledge and utilize Java’s new features in their daily work.

Detailed contribution guidelines covering writing standards, book structure, and local editing environment configuration are available for those interested in joining the project. Thanks to the project's open nature, anyone can contribute to creating a modern and effective Java learning resource tailored to contemporary programming realities.

The result is, in my opinion, really good, and it’s a shame how few people have heard of it.

Although followers on GitHub are in their own unique league.

Speaking of modern Java—do you remember the days when Scala was supposed to be the "modern Java"? Well, hold on tight—there’s interesting news from its former creators.

---

2. Goodbye Lightbend, Hello Akka - The JVM's Most Popular Actor Model Gets a New Identity

A historic moment has arrived—Lightbend has officially changed its name to Akka, as announced by Tyler Jewell, company new CEO. This is a symbolic culmination of the 15-year evolution of the framework that revolutionized reactive programming in the JVM ecosystem by introducing the actor model inspired by Erlang.

Lightbend (or now Akka ?), previously known as Typesafe (just writing this sentence is overly complicated 😃), was founded in 2011 with a mission to support developers in creating modern, efficient, and scalable applications. Initially, it focused on the Scala programming language, combining object-oriented and functional programming features, which offered an innovative alternative to Java. Within the Scala ecosystem, the company developed tools like Play Framework (an MVC web framework) and Akka (a distributed systems framework based on the actor model). In subsequent years, it also introduced Lagom, a tool for building microservices based on Domain-Driven Design. The company was also a proponent of the Reactive Manifesto, a document defining modern application characteristics: responsiveness, scalability, flexibility, and fault tolerance.

This topic is personally close to me—my master’s thesis was based on the Reactive Manifesto, and I even started publishing in the field and almost began a PhD.

Never 🤷

In 2016, Typesafe changed its name to Lightbend, emphasizing its commitment to distributed and cloud-native systems. Now, the company has once again changed its name—this time to Akka—to better reflect its primary technology and product, the Akka platform, and to emphasize the company’s focus on developing and promoting this platform. The rebranding aims to strengthen the brand identity and make it easier for clients and the developer community to associate the company with its flagship product.

Fun fact: Akka is the name of a mountain in Lapland (which explains the project’s old logo).

The actor model, which forms the foundation of Akka, stems from research on concurrency and distributed systems conducted in the 1970s by Carl Hewitt and his collaborators. The model was designed to simplify building multithreaded and distributed systems by eliminating common problems like deadlocks, race conditions, or the need for manual thread synchronization. In the actor model, each computational unit (actor) operates independently, maintains its own state, and communicates with other actors solely through message passing. A key feature of this model is the absence of shared state, which eliminates the need for complex locking mechanisms. This model gained particular popularity thanks to its support in the Erlang language, originally developed for telecommunications networks.

Akka adapted the actor model to modern needs, offering developers tools for cluster management, concurrency, state storage, and stream processing. Over the years, additional subsystems were introduced—Akka Cluster enabled scaling systems across multiple nodes, and Akka Persistence added mechanisms for actors to persist their state, which was crucial for systems requiring reliability and fault tolerance.

With the rebranding, the company announced the launch of Akka 3. Traditional Akka offered powerful tools, but effectively using them required significant technical expertise and manual environment configuration. Developers had to manage clustering, data partitioning, and respond to system load changes on their own. The new version of Akka removes these difficulties by introducing its own runtime environment, which automates infrastructure management. Applications can now autonomously request resources, scale in response to load changes, and store state in ways reminiscent of in-memory databases. This approach relieves developers, allowing them to focus on building applications rather than managing the environment. The new Akka also offers portability across various cloud environments, multi-master replication, and formal SLA guarantees.

In summary, it’s akin to solutions like Confluent Cloud or Mongo Atlas. I’m rooting for it—although Akka has already had its attempts with Akka Serverless and Kalixa. Time will tell how this one turns out. Following the controversies over license changes, Akka has a lot to prove to the community.

And staying in the context of JVM languages (and projects named after mountains)...

3. Kotlin K2 Mode Stabilizes

This week, IntelliJ IDEA 2024.3 was released. We’ll cover it next week (I’ve already started working on a new Release Radar), but today I decided to take a closer look at one of its new features.

As Teodor Irkhin reports, IntelliJ IDEA 2024.3 introduces the stable version of K2 mode, concluding its Beta phase. The new mode significantly improves Kotlin code analysis stability, memory usage efficiency, and overall IDE performance. This is made possible by a completely rebuilt support architecture for Kotlin, which also supports new language features from Kotlin 2.1 (currently in RC) and future versions.

Here’s a small roadmap.

K2 mode operates independently of the Kotlin compiler version defined in the project’s build file, thanks to an internal implementation of the K2 Kotlin Compiler in IntelliJ IDEA. From version 2024.3 EAP 1, K2 mode is enabled by default, and as JetBrains boasts, 86% of developers who tried it continue to use it.

Although K2 mode brings significant improvements, some features, such as scratch file support for Kotlin and certain quick fixes and inspections, are still in progress. Additionally, some third-party plugins may not yet be fully compatible, but efforts are underway to address this.

You probably don’t need me to tell you that K2 is also a mountain, right?

In general, it’s a very "mountainous" edition.

To close the topic—do you use Kotlin scripting? I have to admit that while I always enjoyed scripting in Groovy (@Grab always in my heart), I’ve never been able to warm up to Kotlin’s way of scripting. Turns out I’m not alone.

In the article State of Kotlin Scripting 2024, Anton Yalyshev and Ilya Chernikov highlight this functionality’s role in the language ecosystem (it forms the basis for Kotlin Notebook, for instance) but also point out its limitations. Kotlin, as a compiled language, doesn’t always provide the typical experience of dedicated scripting languages, which has led to moderate interest in scripting in practice—users usually expect less ceremony. As a result, JetBrains decided to limit the number of actively developed technologies related to Kotlin Scripting.

This decision stems from the need to focus efforts on the most valuable applications of Kotlin scripts. The JetBrains team discontinued less popular experimental solutions, such as the Kotlin Scripting Compiler Plugin API, which didn’t gain significant adoption. However, core scripting tools, like the scripting API and Gradle Kotlin DSL integration, are still actively supported. The priority has shifted to simplifying and optimizing existing solutions, aiming to create something truly good for specific use cases rather than something merely average.

And what do you script these days? Personally, I’ve been using a mix of Bash and Google’s zx—highly recommended if you’re not averse to JavaScript.