Programming-language migration and the staying power of Java

This article is based on JetBrains Research’s analysis of programming-language migration. The charts below are from that study but the interpretation below is mine.

Legacy inertia

– When devs move to a new "main language", Java comes in second place (after Python) despite a practically constant market share. In other words, the JVM ecosystem remains dominant, but with significant turnover.

– In addition, modern and more expressive languages such as Kotlin, Go, and Rust, occasionally imagined as replacements for "legacy Java", never actually displaced Java. Why wipe out a complete and mature ecosystem? Instead, they serve as niche additions to Java monoliths. Go for ease of use and low memory footprint in microservices and network infra, Rust for core services that require strict memory safety, Kotlin for Android (with cool improvements for Native/AOT/KMP), etc. These languages also see the largest transition back to Java, which reinforces the fact that Java remains the core platform they often support rather than replace.

Java/JVM is genuinely good, has seen massive improvements (virtual threads, pattern matching, sealed classes, ZGC), and will continue to improve with value objects (a preview of which landed in OpenJDK back in May!), the continuation of Project Loom, and more.

Much like how a now "graybeard" language like Lisp brought us concepts that modern devs take for granted, the standout features of today's hot new languages are steadily being absorbed by the JVM. Goroutines and Kotlin Coroutines inspiring Project Loom are just one example. Paul Graham's "Revenge of the Nerds" has transmuted into the unstoppable momentum of the safe corporate giant.

– Due to the explosion of AI and the concept of "LLM-friendly languages", Python is indeed the primary choice for devs moving to a new main language. BUT its overall net growth in total dev share is quite modest (roughly +0.76% of all devs, or +4% self-relative), and it has large turnover (Python devs most often switch to Java and Go). This shows, in my opinion, that it acts more as an industry-wide transit hub rather than a one-stop shop replacing your typical backend stack. A significant portion of this "switch" is likely driven by the massive increase in high-level orchestration of ML code, which will remain written in good old C++.

– Surprisingly, JS devs remain loyal to pure JS despite the (partially) LLM-driven TypeScript boom 🤔. Is it an identity issue where "TS is just JS with types", so only newcomers label themselves "TypeScripters"?

– Perhaps not as surprising, Rust has incredible mindshare and loyalty but tiny market share, accounting for just 2.1% of global switchers. The data shows basically 0% of C devs and 1% of C++ devs moved to Rust. It has impressive YoY growth, but still operates on a very different scale where much of that growth is driven by newcomers rather than veteran systems engineers seeking an alternative.

Makes me wonder how much of all the heated discussions around Rust vs C++/EverythingElse is actually grounded in real experience and knowledge of both sides...

The new "main languages" devs switch to

Weighted:

1. Python — 20.9%
2. Java — 16.1%
3. TypeScript — 13.5%
4. JavaScript — 10.5%
5. Other — 7.3%
6. Go — 7.0%
7. C# — 5.7%
8. C++ — 4.8%
9. Kotlin — 4.1%
10. C — 2.5%
11. PHP — 2.3%
12. Rust — 2.1%
13. SQL — 2.0%
14. HTML / CSS — 1.3%

Unweighted:

1. Python — 72%
2. Java — 60%
3. TypeScript — 39%
4. JavaScript — 34%
5. Other — 33%
6. Go — 22%
7. C++ — 17%
8. C# — 16%
9. PHP — 10%
10. Kotlin — 8%
11. C — 5%
12. HTML / CSS — 5%
13. Rust — 5%
14. SQL — 5%