I’ve been following the news breaking since yesterday as
a hacker news post
highlighted that an Android commit included OpenJDK files. This is amazing news and a huge step forward
for Java, its still unclear if this is just another move or the inkling of a settlement between Google and
Oracle but I’m very hopeful that this is indeed a settlement. So far Google wouldn’t comment on the
court case and
whether it was settled since its still ongoing.
Disclaimer: I worked at Sun/Oracle but had no internal knowledge of any of the things
discussed here. The information here is collected from public sources, my understanding of the mentality of
said companies & from our following the case at Codename One (we consulted IP lawyers quite a bit
when we started and this case was always on our mind).
I’ve read a lot of the comments in the reddit & hacker news threads and they seem to include a few upvotes
on comments that are just plainly wrong here is a brief FAQ/informational on these common misquotes.
Android will move to Hotspot/JIT
That’s unlikely. Java compatibility and compliance with OpenJDK doesn’t require that you use the JIT that ships
with it or any of its source code for that matter. Quite a few compliant implementations don’t.
While Hotspot will probably beat ART for anything other than startup time performance on mobile is quite
different than desktop performance. Battery life is more crucial than speed and I doubt hotspot is
optimized for that.
Swing/AWT/FX Will Finally Be Supported On Android
There is no indication of that and it seems very unlikely.
Google can be Java compliant by supporting a subset of Java and this is even easier thank to the modularity
changes in Java 9. Swing/AWT/FX compliance complicate this whole process to a completely different level.
Google Was At Fault
There were several claims like this e.g. Google copied code etc.
I don’t like the fact that Android isn’t Java compatible and forked, but I generally disagree with that statement.
It might have been wrong “morally” to fork Java, but I don’t think it was wrong legally.
In the discovery phase of the trial only one small method was shown to be a direct copy and the judge
dismissed that as ridiculous.
Google didn’t violate the trademarks of Java and the coffee cup which are an important tool to keep Java clean.
E.g. they never claimed that Android runs Java, it runs Android/Dalvik and now ART. It compiles Java source code
which is a big leap.
The claim is about copyrighting the API, that’s a problematic claim since Google did use a clean room implementation
of the public API’s. The supreme court effectively said that clean room implementations of public API’s are
That’s a pretty bad thing since copyright is implicit. Its owned even if the person publishing the material doesn’t
explicitly write that little (c) you see next to various types of work. So if you ever implemented an API you are
now effectively using copyrighted code!
Most programmers who understand this think that Google acted based on “fair use” which means they didn’t
actually violate the rights of the copyright holder.
Oracle is a greedy litigious company
Oracle does sue companies but generally larger companies that can afford this, I’m unaware of them suing
a startup or other small companies (feel free to correct me if I’m wrong here). It is far more profit driven than
Sun was. I really loved Sun and loved working there, I can’t say the same about Oracle…
But to be totally fair, Sun no longer exists in part because it was mismanaged and maybe not “greedy” enough.
Having a strong “landlord” for Java might be disturbing in some regards but it has its advantages. I think
anyone trying to show Oracle off as “evil” is plain wrong.
This is like the Microsoft Lawsuit
Microsoft was a Java licensee and took the code to create a non-compliant implementation. Google was
a licensee but the Android division was not. The fact that Google was a licensee for Java didn’t factor into
the trial to my non-lawyer knowledge.
This is about Java Compatibility
While Java compatibility is important and Google did do some damage there (not as much as the lawsuit did but
still), this wasn’t the reason for the case.
The lawsuit originally mentioned a 6bn USD figure for compensation and Google was willing to pay 100M USD
to settle… This was like most lawsuits are about money.
Its not necessarily bad to sue about money but this clearly cost more than it should have for both sides as
it hurt Java in the market and that hurt two of its biggest users (Oracle & Google). Sun used to make
a per device license fee for every J2ME phone sold, that was a huge bucket of money. I think Sun lost
that revenue stream because it just neglected to update J2ME for more than a decade and when it finally did it
was way too late.
Is This Good For Java?
Yes. Without a question!
Some claim the lawsuit should have been decisively won by Google, I think that would have been great because
as stated above I don’t think the copyright clause is good for the industry as a whole. But that ship has sailed
and now the best thing for Java is ending the hostility and unifying behind one standard Java so its great.
Furthermore, ending this hostility means Java proved its chops in court which is a huge milestone. Developers
often have the justify-able backlash when the legal system is involved choosing to go with a technology that’s
more open (e.g. WebAssembly). Technologies like that might have hidden elements that can be
sued over that we aren’t even aware of e.g. just using a GIF file was ground for legal action a few years ago…
This is problematic with more open standards as there isn’t a single “landlord” to carry the technology forward
in such a court case.
Java has seen quite a few days in court and one of the nice things about OpenJDK is that it includes a patent
license provision. This is rare and really valuable, if Google and Oracle settle over OpenJDK it pretty much means
we can all align behind it peacefully and litigation would become far less likely.
Furthermore, I think this would be great for Android as it will eventually move to a newer more modern version
of Java and might enjoy better tooling as a result. It would also mean that some optimizations that might have
been avoided by Android’s Runtime due to potential patent litigation might be applied to ART leading to
The reduced stress among Google developers about IP cleanliness could also boost the productivity at Google
and allow the Android developers to focus on building a better product.
What About Older Versions of Android?
For those we will be able to use something like retrolambda like we do in Codename One.
How Will This Affect Codename One?
Right now we tried to avoid OpenJDK code as much as possible with the same basic thought pattern Google
took of using a clean room implementation to protect ourselves from future IP claims.
We are following this closely, if this happens we’ll align ourselves to be compliant with CLDC 8 which is
a valid Java 8 subset. This shouldn’t require much works as we are already 50% there and
etc. should be trivial to move to that level of compliance.
This would hopefully give us a path to move forward in a way that would keep everyone happy.
This is great news for all Java developers everywhere!
Whether you work on Android, server, mobile or desktop!
This could be the start of the long anticipated “peace process” or at least a ceasefire between Google & Oracle.
This could allow us all to align behind one Java version eventually (taking into consideration the slow Android
update process). It could help bring Java back into vogue with some developers who considered the closed
nature of Java problematic.