Since Oracle took over Java from Sun in 2009 their management of the Java software suite and custodianship of the programming language has been met with mixed reactions. About half of Java users are generally supportive and the other half seem to be critical. Traditionally the language is extended via new “versions” of the JDK and today Oracle is planning the 8th version of the Java language.
Java 8 is scheduled for release in the summer of 2013 and will include the final components of some of the features that were planned for Java 7 – namely their Rich Internet Application package “JavaFX” and “Project Coin” – and some new features such as language support for Collections and Lambda expressions.
Now it seems that Lambdas will be the interesting part. This feature is the only one of the two originally planned headline packages for Java 8 that is actually going ahead – the other being Project Jigsaw which is now planned for Java 9.
We’ll look at Lambdas in a moment, but so that you have a full overview of what we are talking about lets just look at Project Jigsaw quickly. This feature is planned to enable you to write “Modular applications” in JSE, which should make Java more scaleable and enable you to write Java applications onto small embedded devices like smart phones and tablets (I suppose to compete with Android, J2ME, Objective-C and the like). The reason for kicking this into the long grass is purportedly to ensure that version 8 is released as bug free as possible.
So on the face of it, it looks like Java 8 is going to be a bit of a damp squib. Ambitions have been scaled back and only one new feature is being released. What are they going to release that is going to be new?
Lambda expressions and PlayStation 3
Innovation in hardware has continued down the route of increasing performance by parallelizing computations across “several cores”, moving from a world of single core processors or a multi core world. Remember the fuss about Playstation 3? That was Sony’s move from a single core processor to a multi-core.
Today the corporate world of programming is starting to catch up on that technical lag and a demand has begun for a language that better utilises the performance potential of a multi-core environment.
Enter Lambda expressions and functional programming.
Lambda expressions, or anonymous functions, is a way of writing code that is functionally based. By adding Lambda expressions into the Java suite Oracle is looking to bring into their tent the functional features so far available on JVM with Scala and Clojure. Giving their clients a language platform that is more compatible than the existing JVM variants and utilises the increased performance of a multi-core environment.
Is this new?
Well it is for Oracle’s Java suite. Very new in fact. But in terms of programming, .Net adopted Lambda expressions 5 years ago in 2007 (as a feature of C# 4.0). F#, Lisp, Scala and Clojure already exist and are widely used. Oracle is actually playing catch up here, not breaking new territory.
Language vs platform
At this point it is useful to come back to the divide between the Java programming language and the Java software suite – interestingly Microsoft makes the distinction easier by calling the former C# and the latter .Net whereas with Java its just “Java”. Unlike Microsoft Java has a massive community building Open Source frameworks and features, adding a rich and sizeable driving force behind the language’s development. Oracle owns the software suite but not the language, and it’s from this Open Source space that much of the new functionality of Java has been developed. So Spring and Hibernate are both from the Open Source community, not Oracle. Since 2009 Oracle has “progressed” Java by adopting / absorbing these innovations, so EBJ3 is their version of Spring and JPA is their version of Hibernate.
So what is new with Java 8?
Developers already had access to functional features with Scala – an object oriented language with closures. And they can already write applications on embedded devices using android or J2ME or Objective-C (the point of Project Jigsaw).
Anything?
Well the Lambdas is going to be very well received by Oracle’s big corporate clients. Small companies that use Java have probably already adopted a functional language if they wanted to exploit a multi-core infrastructure, the big players however are less likely to have done so because they are much more risk adverse and for them it makes sense to wait until you get an “official” version that is supported by Oracle.
But to everybody else, Oracle is spending a lot of time and effort standardising what already exits, instead of inventing new features they are consolidating the Java position.
I think the question is not,“Can Oracle keep the Java train on the tracks?” but “Where are those tracks leading?”
By absorbing the advances made by the open source community Oracle is taking Java down a track that will eventually look like this: Oracle don’t own the Java language, but they do provide support for it. By writing each JDK they also determine what features will be compatible with “their” software platform, and it doesn’t take a genius to see that before long they can exclude Open Source features that they now have a version of (JPA and EJB3 for example) and withdraw support for technologies they don’t own. Effectively dictating what is going to be compatible with their platform and what isn’t, finally asserting the ability to control the Java world they purchased in 2009.
Fine, that’s what corporations do – make money from stuff they own – but in doing so surely they are going to push out the Open Source community which is what defines Java from C# and that has for the last 3 years been the only driving force for innovation?
Is Oracle going to crash their own train?
Not quite. I suspect that they will continue to fudge things, potentially pushing out the little companies, continuing to lose support in the OS world but ultimately not withdrawing support for the legacy JDKs because too many big companies (such as the Investment Banks) rely upon OS technologies like Spring and out-dated JDKs like 1.5 and their business is too integral to the income Oracle makes on Java. And Lambdas in Java 8 will be popular with their big fee earners. So we will see increased the capitalisation from ownership… but not world domination.
Martin Jee's blog 
Interesting stuff.
I think there is a distinction between Java— which has evolved considerably since it’s inception— and the JVM. Even if Java were to diminish: which many think it will the JVM still remains quite dominant. If you squint you can see that the JVM is more in keeping with Oracle’s business. Where databases are a general store used across industries the JVM is a general execution environment that’s embeddable most places. There’s a lot of money to be made out of JVMs look at Azul: Oracle have begun efforts to fork the JVM and add comercial features.
Against this backdrop Java isn’t disappearing, but some of it’s developers might migrate to other languages. But given the tooling and runtime support these languages will probably be on the JVM as the platform is offering: JIT, good concurrency features/abstraction away from multicore, increasingly stronger GC and a platform that improves in performance every generation.
This means even if development slows on your present system, upgrading the VM can give you performance improvements, better utilisation of cores. That’s before leveraging the offerings from the rest of the open-source community.
I’m not sure I get the point about excluding opensource: as far as I remember Gavin King was involved in JPA and Hibernate is Jboss’ implementation of the specification. Sun did the same build language APIs based on a few established open-source projects. What they are likely to do is make money out of support and additional features (like better GC) that allow the platform to scale.
Martin
Oracle is the steward of the Java platform, responsible for making sure that it remains commercially viable. As far as Hibernate and Spring Framework goes, there is a standards body, originally created by Sun Microsystems in 1997/1998 that brings all those companies, individuals and experts together to set up the specification standards for application framework.
Standards are very important, it means that companies and everyone else can avoid vendor lock-in. Companies like standards, because they can claim their product adher to the standard. The effect of standards is paramount in the IT industry, just look at the C++ standard or the JavaScript language standards, or how about HTML 5 and web platform standards and the browser battle incompatibility wars.
Oracle only took over Sun Microsystems in 2010, so in 3 years it manage to move Java to release 7, whereas it was blocked for several years since 2006 when the last Java release was 6 (Mustang). It had to do with Apache Harmony and licensing of the Java Tool Compatible Kit to Apache, and eventually lend to the Google versus Oracle lawsuit, which probably will have long term affects on the IT industry. An API cannot be copyrighted according to USA Law 2012, and Google won that case. Morally, Google, I feel that stood on Sun Microsystem’s toes with the Android innovation and perhaps there should have been some licensing and shaking of hands. Still it is history now.
Standards are going very important to save business money in the future for cloud computing. Going forward into the Cloud where, now, there are no great standards (yet) and Java moving to the cloud which is even longer off in the distance, means that business customers want the choice to move their applications from cloud vendor to another, if not to save electricity and provisioning costs, but to reduce that risk and be more risk adverse. In the world with standards, this will only benefit Amazon and VMWare and the businesses will have no choice to be vendor locked-in simply because there are currently the market leaders.
With Java server side, the standards and standard body largely exists, so we are guilty of sitting comfortably on the stuff that does work now. However, there thing out there are innovating and not yet worth standardising like MongoDB, Cassandra, Hadoop, Neo4JS and only time will tell. Oracle just has to keep pushing us along, listening to the forefront, and if business does not want to upgrade and live with legacy systems because they are scare to change, well that is then their business, let the rest of us move on.
More on Oracle and JavaOne on my report http://www.xenonique.co.uk/blog/?p=779
haha, Interesting topic Martin.
Regarding oracle and java, I was one of the most pessimistic of Oracle’s acquisition of Sun. Damn, I loved those Sun days. I actually thought of opening Moon MacroSystems Inc… see my blog article on this two years ago.
http://cameotutorials.blogspot.co.uk/2010/08/is-oracle-sinking-java-boat-please.html
But fast forward to 2012 and my views are completely changed.
1. The work they have done with JavaFX is completely unparralled. Its only a matter of time before you begin looking for JavaFX experts. look at the reception the technology receives at java conferences and you know something is right about the technology. At least you don’t have to try too hard to be able to use it.i even see above poster (peter_pilgrim) writing things about it on twitter a lot of the time.
2. On project Jigsaw, the problem is that, the JVM itself is too big such that, and modularisation will have a significant impact. Coupled with that is the fact that java itself is interpreted so there is a performance hit. The last thing you want is sitting down looking for classes to load when you should be crunching numbers. All the bad press the Garbage collector gets is fundamentally because the JVM takes some time out to do some homework. Any jigsawing will only at to this lack of determinism and predicatability so the reengineering has to be done correctly and there is no point rushing it. After all, If true modularisation is what you are looking for, OSGi provides that to some extent. I have worked with OSGi and trust me, its problems are worse that the problem it tries to solve. Even uptill now, OSGi cannot effectively load classes dynamically…one of its main selling point. We tried to use it on a production system to do dynamic updates without restart…For any intensive system…it just chokes…and you must restart…
3 However oracle’s approach at the moment to inprove the standard java API by improving the Utility classes will pay of big time. Forexample, today any decently sized project is normally consumed with large dependencies and libraries which is itself a nightmare to manage. Maven solves that to some extent but that is not perfect. These days, you can’t even do a build unless you have an internet connection. providing a more richer API is therefore a good logical a mordern API is a better bet. fork/Join + closures and you don’t need most of the in memory mapreduce frameowrks like Gridgain and the others.
In conclusion, i think the track Oracle is taking is Logical and good. Sun was good at doing cool but sometimes too cool can cost you. They spent more time fiddling with too many Ideas..(project Wonderland come to mind) and that is what brought them down. The .NET camp is different because their Steward maintains a very tight control over what gets in after listening to all the stakeholders and I think that is what oracle is doing which is effectively filtering the good from the nice to haves..;)