It’s the start of 2019, that means that we’ve now accomplished the “20 Years of Java” celebrations. Indeed, although the notice about Java (and the HotJava browser, whichever didn’t relish quite the same success) was made openly on May 23rd, 1995, the first precise commute of the JDK was on January 23rd, 1996. You could fairly claim that Java is only now turning 20. There have been various retrospectives on Java, but I celebration what would be fascinating to look at is the frame of Java in its twentieth year.
It’s various to exactly measure the reputed of programming languages, but one of them in most cases accepted surveys is the TIOBE index. This tracks language allusion through a variety of search tool as well as Google Blogs, Wikipedia, and even YouTube. (In writing this avenue I learned something new, which is that TIOBE is actually a cipher for “The Importance Of Being Ernest,” the play by Oscar wide. Not sure what that has to execute with programming languages, but there you active.).
Looking back at the development over the last fifteen years Java has constantly been either number one or two. Java has scrambled for position with C, which was constantly the most famous before Java was sent (how things change: back in 1986 Lisp was digited two and Ada were number three). TIOBE has also just announced lofted that Java is their “Programming Language of the Year” for 2018. A great creation, especially as it was also given the accolade ten years ago.
As another measure of reputation, Oracle, again and again, likes to quote the fact that there are nine million Java developers in the world. If you want a giggle to check out this JAXenter article, which gives some details of how they got to this number. Careless of the analysis I think we can all concur there are precisely millions of Java developers over the world
The questioning to ask is why does Java endure to be so popular? I guess there is an amount of logic for this; let’s just peak four:
1. Backwards compatibility
Sun and finally Oracle have made big efforts to safeguard that code written for one adaptation of Java will continue to run consistently on newer versions. Although this hasn’t always been the case (affirmation in Java SE 1.4, inventory in Java SE 5) and it has consistently led to discharge that could have been better without rapport (generics) it is a very compelling feature for developers. There’s nothing worse than taking code that works and having to change it to make it work on a newer version of the stage. That’s just emaciated time.
To me, this is the big one. Considering at the TIOBE graph, there is an important upswing in Java popularity since October 2014, which is shortly subsequently the launch of JDK 8. JDK 8 was a big change for planner using Java because of the establishment of Lambda expressions and the streams API. Suddenly Java developers could determine things in a more practical way without holding to learn a whole new language like Scala. These lineaments also make it probably much easier to take benefits of multi-core/multiprocessor machines outwardly having to write lots of complicated and possibly error-prone multi-threaded code. With project Jigsaw expected for delivery in JDK 9, we’ll see modularity make huge business applications much easier to build, deploy and maintain. There are before plans for new language features, like value types, in JDK 10.
James Gosling has reported Java as a “blue collar” programming language. It was designed to avow developers to take their job done with the minimum of trouble, whilst still permissive developers to pick up someone else’s (or even their own) code at a coming after a date and understand what it’s assumed to do. Sure, you can write unreadable code in Java, just as you can in any language, but with better coding conventions it is most readable than many other languages.
With over twenty years and thousands of man-years of expansion, Java is a rock-solid platform that does on a level that can trial or even top that of native code (thanks to some of the optimisations finished by the JVM utilizing dynamic rather than static code analysis). Thought it comes to scalability, just glance at some of the immense enterprises using Java: Twitter (who moved off Ruby-on-Rails to the JVM because RoR wouldn’t scale), Spotify, Facebook, Salesforce, eBay and, of course, Oracle. Hadoop, Cassandra and Spark, the support of most big data projects, are either written in Java or Scala and drop on the JVM. If you need scalability and performance, Java and the JVM is an obvious choice.
I peek ahead to observing Java being awarded Programming Language of the Year in another ten years’ time.