In 2016, Java turned 21. According to the Tiobe index, Java is still the most popular language. Whether you like Java or not, the fact that a language leads the pace for such a long time is pretty amazing.
My most popular tweet of 2016 was this one:
One of the reasons why Java is still great is because the JDK team thinks very hard about long-term consequences of design changes.
I really think this is one of the not-so-hidden reasons for the success of Java. There is a thin line between not innovating and innovating too fast. The Java language, and by extension the Java platform, clearly stays on that line. Granted, the difference between the Java language and the Java platform allows for some margins. The Java Platform allows for other, new, experimental languages to be developed. Some of those languages become successful by themselves, others gain less critical mass. But in most cases, those new JVM languages learned the Java core developers something about the possibilities of the Java platform, and about the wishes/trends in the developer community.
At the JavaOne conference in 1999, Java was sort of divided into three parts: Java SE, Java ME, and Java EE. While the distinction between those parts is often artificial, it makes it easy to discuss the state of the different parts of Java.
Java 8 was released in 2014, and it was picked up very fast by a large number of developers. We saw a number of great books, tutorials, and articles on the new features of Java 8. Functional programming is hot today, and the Java language allows developers to take advantage of functional programming.
Unless something really strange happens, 2017 will be the year of Java 9. It took a long time and a number of delays to get this release ready, but I think that's reasonable. First of all, it is not easy to envision a modularity system that developers are willing to work with for the next decade or so. Secondly, even after this became clear, there were a huge number of small and large hurdles that needed to be overcome before the JVM worked with the new module system — while providing most of the backward compatibility developers wanted. Actually, it is nothing less than amazing that most of the design decisions made by James Gosling and his team when they created the Java language in the early 90s are still very much valid.
Mixing new paradigms with older, mature concepts is never an easy task. When Java 9 is released later this year, I don't expect a big revolution from day one. Developers will gradually move from a classpath-based deployment to a modular system. The JVM will be future-proof once again, and that is the important part.
The past year was rather turbulent for the server-side Java continent. Ironically, the unexplained slowdown of Oracle's work on the Java EE 8 specifications, in the end, triggered a number of initiatives. While the year started as a boring, stagnating time, it ended with lots of activity, coding, and collaboration.
The Java EE 8 release is now scheduled for the end of this year, shortly followed by the Java EE 9 release. The Java EE 8 release will fix some loose ends, and it will contain a number of important new JSR's that will make the daily life of a Java EE developer much easier (e.g. JSON-B).
One of the terms that was used most often in 2016 was, without doubt "microservices." Unfortunately, it is used as a marketing term as well, and that makes discussions often harder. The MicroProfile initiative is a very interesting move by some vendors and luminaries in the Java server-side space, and they are really doing great things with Java on the server side. The Spring framework is also a valid option for creating microservices, and there are already many companies and organizations using this in production.
It is interesting to see how the Java server-side market, which is often described as slow or inert, is embracing "new" concepts like microservices. Since server-side Java dominates the enterprise market, this is really great news. I like the fact that at least three big and (more or less) open initiatives are working on how to integrate the microservices concept into their stack. Many great enterprise developers are contributing to one or more of those initiatives. I sincerely hope that the communication lines between Java EE, MicroProfile, and Spring will be used a lot in 2017. It is great to have multiple initiatives, as this gives developers and companies a choice. But interoperability is another keyword in our industry, hence communication is important as well.
Originally, this Java platform was developed with mobile or embedded devices in mind. This idea is often shadowed by the success of Java on the server side. Also, in the past, there were major issues for running Java on resource-constrained devices. Today, the situation is changing. Mobile and embedded devices are becoming more powerful, and thanks to standardization, it is now easier to extend the Java Write Once Run Anywhere idea to mobile and embedded.
This is an area I am currently involved in, and with Gluon, we are working very hard to have and maintain first-class support for Java on mobile and embedded devices. While the technology is now mostly in place, the business model is the next to tackle. Combining mobile/embdedded functionality with cloud systems is very important, as it allows the value created by billions of small devices to be analyzed and used in enterprise systems. That is the core of my daily work at Gluon today, and I really believe this will be boosting in 2017.
Even after more than 20 years, it is still very exciting to be a Java developer. There are simply so many opportunities where Java can make the difference. And on top of that, the Java ecosystem is very much alive, and it allows developers to participate and shape the future.