If You Wrote Java in 2016, Here Are the Trends You Couldn't Have Missed
Last year was extremely exciting for the Java community—Java 9, Java EE, containers, microservices and more. Are you sure you haven't missed anything?
Join the DZone community and get the full member experience.Join For Free
There are a lot of trending topics when it comes to code, and trying to keep up with everything that’s going on is a full-time job on its own. If you’re wondering how to separate the wheat from the chaff, we’ve gone ahead and done the work for you.
In the following post, we’ll check out what was hot in 2016, and what’s about to get even hotter this year. Java-wise, of course. Get ready to code like it’s 2017.
Java 9, You’re So Fine You Blow My Mind
We opened the year with a bug in Java 6 that is about to turn into a feature in Java 9: sun.misc.Unsafe. This library is a collection of methods for performing low-level, unsafe operations. For example, using the allocate Instance method allows you to skip the object initialization phase or bypass security checks in a constructor.
Although Oracle thought about removing the Unsafe library altogether, the community was able to change their mind and turn it into a Java 9 feature.
That’s not the only time the community has spoke about possible changes in Java 9, or in future versions of Java as a whole. Earlier this year Brian Goetz, Java Language Architect at Oracle, published the survey results of JEP 286.
The proposal suggests introducing Local Variable Type Inference in future versions of Java, in order to simplify the writing of Java applications. The bottom line? 74% of developers want less verbosity, and to be able to declare variables without having to specify the associated type.
With a little over 200 days until Java 9 will be released (and we know, since we’re counting the days to its launch), we have plenty of time to dig through the different JEPs and find new and improved features. That’s how we came across JEP 266: More Concurrency Updates, that includes updates for CompletableFuture and the exciting java.util.concurrent.Flow class.
There’s no doubt Java 9 has been in the headlines during the past year, and it will keep on getting more and more focus as we enter 2017. Now all we have to do is wait and hope it won’t get delayed once again.
What About Java EE?
2016 has been a… meaningful year for Java Enterprise Edition, also known as Java EE. It’s always been a source of confusion in the worldwide Java community, since it’s built on top of Java SE. Officially, it’s “just” a specification with actual implementations available from Oracle (like the Glassfish reference implementation) and other vendors like Red Hat and IBM.
There are a lot of question marks revolving Java EE, that main one being “Has Oracle given up on enterprise software?” but a lethal blow for Java EE came from Gartner’s “Market Guide for Application Platforms” report. In it, Gartner stated that Java EE is built for an “obsolete model that no longer meets the needs of modern applications.” Ouch.
The Java EE community is saying that Gartner are not quite right, and it sparked the discussion once again around this edition. Java EE 8 is expected to be released in the first half of 2017, and our guess is that it’s too soon to eulogize it. But we’ll have to wait and see how and if Java EE will crumble.
There’s a Lot More to Java
Java is more than just Java 9, and there are a lot of trends you have to stay on top of. A good place to start is by going through the top 100 Java libraries in 2016, checking if there’s anything you might have missed out on during the past year.
Also, if libraries are your cup of Java, there are also some interesting Java libraries from Google (that are not Guava) and are worth checking out.
Following the educating line, there are some key elements you can only learn about as you get more experienced, and it’s good to be prepared to open your mind and… learn.
And if you’re looking for a challenge, there are plenty of projects that are worth your time. You have elegant problem solving, String manipulation, or even a Java music player to play around with and learn from. And of course, if you come across any problem or have questions, you have Stackoverflow. Here are seven of the best questions we found.
Fun little anecdote for you: can you guess how GitHub’s top Java projects use logs? Because we’ve analyzed 779,236 Java logging statements in 1,313 GitHub repositories to find out the answer: ERROR, WARN, or FATAL?
Putting Java in a Container
Containers are great for holding treats in that new year’s eve party, and they’re also pretty handy when it comes to managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access-rights.
There has been a lot of interest in Java containers. A single OverOps support chat a few months back piqued our interest in the combination of Alpine Linux and Docker Since then we see more and more of our users trying it out with their containers.
That’s why we’ve decided to check out Alpine Linux, an independent stripped down flavor of Linux that’s based on musl libc (pronounce ‘muscle’) and busybox. Apart from being lightweight, it’s also security oriented and uses grsec/Pax which is a security enhancement to the Linux kernel.
Docker is still one of the hottest tools in the industry. The company took the challenging task of shipping code and made it faster and easier, using containers. However, if you’re thinking about using Java on Docker you might have to re-think it, since it might lead to you breaking the (Java) law.
What About the DevOps?
We know what you’re thinking – here we go with the buzzwords. One of the most common topics we came across in 2016 was DevOps, with a variety of meanings and work methods. The main gist of it focuses on knowing what happens in a live application and being able to control it.
How can we do that? Through monitoring our production environment. Performance issues, errors, and exceptions happen all the time and we have to know what’s going on. But how can we see when and why certain issues happen? That’s where the concept of Observability comes in, to help us gain an in-depth view of the system and understand what exactly happened.
It’s part of the DevOps workflow, and in control theory, it’s a measure for how well internal states of a system can be inferred by knowledge of its external outputs. This is where another “buzzword” comes in: Instrumentation. It’s what allows us to gain insight about the application before it goes haywire on us and our users.
After we’ve established these cornerstones, it’s time to bring out the tools that will help us monitor our app’s performance. Once the application is up and running, we need to know if and when errors or exceptions are thrown. That’s why there are numerous error tracking tools in the market, and all you have to do is choose the right one for you.
Errors are not the only issues that need our attention, and the biggest challenge that remained in 2016 is dealing with log files. Everyone uses them to search and understand errors, crashes, and exceptions in their application. Some use the direct approach and sift through plain text log files, while others rely on log management tools to help them find the bug in the log-haystack.
Log Files STILL Suck in 2016
If you’re looking for a new way to debug your production errors and exceptions, OverOps (which had a makeover during 2016) gives you the complete source code and variable state across the entire call stack. Every parameter and every variable that was passed into a transaction or workflow that caused it to fail.
This and That
It’s becoming impossible to ignore the microservices trend. Some would say it’s just another unbearable buzzword, while others would recite the advantages of breaking down a monolith or take the contrarian approach and focus the negative aspects.
But any way you look at it, it seems like everyone is into microservices these days. Now you just have to be careful not to f*** anything up in production while you use it.
The serverless computing architecture has also been gaining attention during the past few years. The concept of serverless computing talks about deploying code, not servers. Instead of purchasing, managing and scaling servers, the cloud provider is the one handling the requests made to the VMs.
So you still need servers, but this new model takes the responsibility away from you. Or in other words, there’s no hassle in dealing with deployments onto servers or installed software of any kind. Basically, all you need is a managed cloud service and a computer.
And finally, even though they’ve been around for awhile, it feels like everyone is talking about artificial intelligence and machine learning. It’s no longer a secret reserved to scientists and researchers, with implementations in nearly any new emerging technology.
The recent buzz and evolvement around this field made it more accessible for non-researchers. Now you have easy access to the relevant algorithms and tools. You do have to know what you’re doing, but it’s a lot easier to enhance your applications with machine learning capabilities.
Shoutout to the Community
You gotta love the Java community. Not only do they affect future versions of the language, they keep on enriching us all with meetups, articles, and information about everything Java. 2016 has some pretty amazing conferences like JavaOne, QCon, and more great talks you can re-watch right now.
One of the main resources for learning about new things in software development is watching online talks and videos. It’s a great platform in which Java experts share their experience with us, without getting off the couch.
Or, if you’re not a video kind-of-person, going through Java decks will also keep you updated about what’s new and trending right now.
But peer support is relevant in every aspect of our work, and there’s a lot we can learn from those around us. One key feature is about being productive, since there’s always room for improvement. All we have to do is to be ready to take the advice and listen to whoever’s willing to speak.
Don’t Forget About Open Source
Another key element of the community is supporting and contributing to open source projects. As a matter of fact, we’ve launched the command line tool you’ve been waiting for (or not) – the Bullshifier. It’s used in order to test some of our monitoring capabilities over ridiculously large code bases, with transactions that go thousands of calls deep, over thousands of classes, and end up with exceptions.
There were a lot of topics and buzzwords that we came across during 2016. Some we already knew, some brand new that made us look at Java in a whole different way. Now we’re looking forward to 2017 with Java 9 in mind, and hope for some more new and amazing features, talks, projects and maybe even a new buzzword or 2.
What are your favorite Java features, talks or topics from 2016? We’d love to hear about them in the comments below.
Published at DZone with permission of Henn Idan, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.