So that's it. Three days, 2.000 Developers from 20 countries, over 140 speakers from around the world, and one outstanding beautiful city. It is for the first time, when Devoxx Poland (previously known as 33rd Degree), one of the most recognizable European Java Conference took place in Krakow, the city of the polish kings, and one of the most important places in whole polish history. It took place from Monday to Wednesday last week in the ICE Conference Center, which is located directly by the Vistula river, with beautiful view over the Wawel Royal Castle.
Now it's time to write some short summary. Below is my personal list of conclusions and analysis about the current state of Java industry and where it is going to, based on that what I've heard and seen during the conference.
1. The rise of Microservices
You might say - "yep, of course". It is obvious for everyone who is following the development of Java & Web Ecosystem that microservices are the hottest and fancies "new" "technology" of the year 2015. I counted that around 10 talks (from around 100 full-time presentations) were completely dedicated to them. Another couple or so discussed tools emerged to make them easier to monitor, deploy and deal with them. And nearly every other talk mentioned them.
I think we are in the peak phase. I remember two years ago at GeeCON 2013 as I saw the first talk about it. Now it explodes, and you could hear at Devoxx everything about it: from theory and principles, through architecture, best practices, tools supporting it, monitoring, devops, to live coding demos. Most of this talks were very enthusiastic about it, although in the next few months I expect some more skeptical or at least balanced talks. There was actually one like this.
2. Reactive and Resilient by default
The second most important topic at Devoxx was the resiliency and reactive programming, together with durability, asynchronous programming, circuit breaking and back pressure, which are all actually strongly connected with microservices.
Conclusion from the talks I have seen is quite obvious: if something can crash, it eventually will, most probably in the worst moment. That is why resiliency and recovery mechanisms are so important and should be not only a feature, but a must, especially in the era of microservices.
The application (or actually the whole container or server) should be able to crash at any time and the supervisor should take care of it. The other parts of the system should be able to continue their operation normally almost as if nothing had happened, circuit-breaking the failed system and using fall-back mechanisms, providing some simplified data from other sources. And as soon the failed part of the system has been recovered, it should automatically back to normal.
3. Functional Programming breaks (slowly) though
Third most popular and still very hot topic is functional programming (or rather, a soft of FP). Thank to lambda expressions, streams API, CompletableFutur, (semi)closures and tools like RxJava programmers slowly adopt more and more functional concepts and start to think of computation rather as a pipeline processing of immutable data instead of thinking of it as a mutating of objects' state.
Furthermore, more and more developers found it increasingly important to write the code in such a way that there is no mutable state, including code at the method-level. I guess this is also a side-effect of using the IoC Containers, where many objects are simply the global singletons, and introducing the state in it would case a serious performance problems and bugs.
4. Java 8 throttles the rise of the new languages
Two, three years ago, if you attend a Java conference, one of the most important thing which would be discussed was "Is the Scala/Groovy/xyz the next Java?" or "What are the Java alternatives". You won't here it anymore. In some cases you would hear that Scala/Groovy/xyz is better for implementing some kind of stuff like mathematical computations or data pipeline processing or so. Or that some languages are better at concurrency and parallelism. Or that some languages are better for writing tests.
But there is no more doubt that Java will be soon replaced by other languages whatsoever, because with Java 8 and many (especially "reactive") mature libraries Java is simply good enough for most cases. At least for now.
5. Java-Community focus on backend
They all moved out to their own separate conferences, because no one doubts anymore that anyone can be a good Java (Backend) Developer, a good JS-Frontend Developer and Mobile Developer at once. There are simple to many problems to solve on the "Backend"-Side, so one has to focus on Java-Code and (probably not so long and more) on "Data".
6. Big Data and NoSQL are here
Big Data and NoSQL were of course present, but it is not the same "Big Data" and the same NoSQL which it was for 3-4 years. Today we are not talking about what it is, what is the theory, etc. Today it is obvious for everyone, that there is nothing like "Big Data" and "NoSQL" databases.
There are only databases which better scale and handle some particular amount and type of data in particular circumstances. That's it, and the only thing we should do is learn how to recognize which data better fit to be stored in database X or Y, and how to use it properly. And the conference showed exactly this, that there are no SQL and NoSQL databases, but only that handle better data of the given characteristic.
There are simply databases which doing one thing better than another, for example better handle transactions and relations between data, or scale very well but support no relations, or maybe are design to store and query text documents or graphs of objects.
7. Spring is all what you need
It was probably for the first time I didn't see any talk about alternative approach to Spring-Based Technologies (Java EE excluding).
This year there was nothing about any new or old frameworks. No Play Framework, dropwizard. No other smaller fancy technologies like RatPack or Spark Framework. Nothing. Zero. It has been always at least a couple talks about different frameworks and alternative approaches. Not this time. There wasn't even Grails.
The same applies for the data-persistence solutions like ORMs for instance.
No new features in Hibernate, JPA. Nothing about jOOQ or myBatis/iBatis. Now it's all about Spring Data. There is Spring Data JPA, Spring Data MongoDB. Spring Data Neo4J, Cassandra, Redis, Elasticsearch, any more. There are also Spring solutions for Big Data - Spring XD and for the microservices aka cloud stuff - Spring Cloud.
Spring is the only thing which you seems to need. Thus I'm waiting for the "Spring Developer" job titles instead of "Java Developer", just like "SharePoint Developer" or "Liferay Developer" already.
Despite of many new buzzwords and "new" technologies, there was not technological revolution, not even close. Maybe microservices will revolutionize the way we are designing systems but they will do it not because they are a revolutionary technology, but rather by combining many other technologies together instead of introducing something what is really new.
I think it might be true that the Java Industry and the IT world in general is in the inflection point. New technologies aren't a game-changer and every new technology needs more and more time to spread across the industry, so it feels like a little bit stagnant.
I have such a feeling that we have now a little bit time to catch our breath, right after the Cloud, Mobile, Big Data, Asynchronous, Functional and DevOps era and to prepare ourselves for the Next Big Thing, which is probably waiting for us around the corner and will pop up in the least expected moment.