Just as LinuxCon ended, Oracle announced that it has filed suit for patent and copyright infringement against Google for its implementation of Android; as an Oracle spokesperson said, “In developing Android, Google knowingly, directly and repeatedly infringed Oracle’s Java-related intellectual property. This lawsuit seeks appropriate remedies for their infringement … Android (including without limitation the Dalvik VM and the Android software development kit) and devices that operate Android infringe one or more claims of each of United States Patents Nos. 6,125,447; 6,192,476; 5,966,702; 7,426,720; RE38,104; 6,910,205; and 6,061,520.” (some more details in the copy of Oracle complaint). Apart from the slight cowardice of waiting after LinuxCon for announcing it, the use of the Boies Schiller legal team (the same of SCO) would be ironic on its own (someone already is calling the company SCOracle).
The patent claims are:
- Protection domains to provide security in a computer system
- Controlling access to a resource
- Method and apparatus for pre-processing and packaging class files
- System and method for dynamic preloading of classes through memory space cloning of a master runtime system process
- Method and apparatus for resolving data references in generated code
- Interpreting functions utilizing a hybrid of virtual and native machine
- Method and system for performing static initialization
Let’s skip the patent analysis for a moment, and let’s focus on the reasons behind this. Clearly, it is a move typical of mature industries: when a competitor is running past you, you try to put a wrench in its engine. That is a typical move, and one of the examples of why doing things by the book in this modern, collaborative world is wrong. Not only that, but I believe that previous actions by Sun made this threat clearly useless – even dangerous.
Let’s clear the table from the actual patent claims: the patent themselves are quite broad, and quite generic; a good example of what should not be patented (the security domain one is a good example; look at the sheet 5 and you will find the illuminating flowchart with the representation of: do you have the rights to do it? if yes, do it, if no, do nothing. How brilliant). Also, Dalvik implementation is quite different from the old JRE one, and I have strong suspicions that the actual Dalvik method is substantially different. But, that is not important. I believe that there are two main points that Oracle should have checked before filing the complaint (but, given the use of Schiller&Boies, I believe that they have still to learn from the SCO debacle): first of all, Dalvik is not Java and Google never claimed any form of Java compatibility. Second, there is a protection for patents as well, just hidden in recent history.
On the first point: in the complaint, Oracle claims that “The Android operating system software “stack” consists of Java applications running on a Java-based object-oriented application framework, and core libraries running on a “Dalvik” virtual machine (VM) that features just-in-time (JIT) compilation”. On copyrights, Oracle claims that “Without consent, authorization, approval, or license, Google knowingly, willingly, and unlawfully copied, prepared, published, and distributed Oracle America’s copyrighted work, portions thereof, or derivative works and continues to do so. Google’s Android infringes Oracle America’s copyrights in Java and Google is not licensed to do so … users of Android, including device manufacturers, must obtain and use copyrightable portions of the Java platform or works derived therefrom to manufacture and use functioning Android devices. Such use is not licensed. Google has thus induced, caused, and materially contributed to the infringing acts of others by encouraging, inducing, allowing and assisting others to use, copy, and distribute Oracle America’s copyrightable works, and works derived therefrom.”
Well, it is wrong. Wrong because Google did not copied Java – and actually never mention Java anywhere. In fact, the Android SDK produced Dalvik (not Java) bytecodes, and the decoding and execution pattern is quite different (and one of the reasons why older implementations of Dalvik were so slow – they were made to conserve memory bandwidth, that is quite limited in cell phone chipsets). The thing that Google did was to “copy” (or – for a better word – inspire) the Java language; but as the recent SAS-vs-WPS lawsuit found, “copyright in computer programs does not protect programming languages from being copied”. So, unless Oracle can find pieces of documentation that were verbatim lifted from the Sun one, I believe that the copyright part is quite weak.
As for patents, a little reminder: while copyright covers specific representations (a page of source code, an Harry Potter book, a music composition), software patents cover implementations of ideas, and if the patent is broad enough, all possible implementation of an algorithm (let’s skip for the moment the folly of giving monopoly protection on ideas. You already know how I think about it); so, if in any way Oracle had, now or in the past, given full access to those patents through a licensing that is transferable, Google is somehow protected there as well. And – guess what? That really happened! Sun released the entire Java JDK under the GPLv2+classpath exception; granting with that release full rights of use and redistribution of the IPR assigned on what was released. This is different from the TCK specification, that Google wisely never licensed; because the TCK license requires for the patents to be transferred to limit the development to enhancements or modifications to the basic JDK as released by Sun.
But, you would say, Dalvik is independent from OpenJDK, so patents are not transferred there. So, include the code that is touched by the patents from the OpenJDK within Dalvik – compile it, and make a connecting shim, include it in a way that is GPLv2 compatible. The idea (just an idea! and IANAL of course..) is that through the release of the GPL code Sun gave an implicit license to embedded patents that is connected with the code itself. So, if it is possible to create an aggregate entity of the Dalvik and OpenJDK code, the Dalvik one would become a derivative of the GPL license, and would obtain the same patent protection as well. That would be a good use of the GPL, don’t you think?
What will be the result of the lawsuit? First of all, the open source credibility of Oracle, already damaged by the OpenSolaris affair, is now destroyed. It is a pity – they have lots of good people there, both internal and through the Sun acquisition; after all, they are among the 10 largest contributors to the Linux kernel. That is something that will be very difficult to recover.
Second, Google now has a free, quite important gift: the attention has been moved from their recent net neutrality blunder, and they are again the David of the situation. I could not imagine a better gift.
Third, with this lawsuit Oracle basically announced the world that Java in mobile is dead. This was actually something that most people already knew – but seeing it in writing is always reassuring.
Update: Miguel de Icaza claims that “The Java specification patent grant patent grant seems to be only valid as long as you have a fully conformant implementation”, but that applies only to the Standard Implementation of Java, not OpenJDK. Sorry Miguel – nice try. More luck next time.
Update 2: cleaned the language on the phrase on patents, ideas and implementation that was badly worded.ù
Update 3: clarified the Dalvik+OpenJDK idea.
#1 by Andreas Kuckartz - August 13th, 2010 at 11:59
Can you please substantiate the statement that distributing the GPL2 binaries without linking and using them will transfer patent protection?
#2 by cdaffara - August 13th, 2010 at 12:57
It was quite badly worded. The point is that by releasing OpenJDK under the GPL2, Sun granted an implicit IPR license for its relevant patents; as such, any combined artefact that is derived from the OpenJDK code will get the same kind of protection. I have changed the wording in the text as well, to make it clearer. (by the way: I think that the patents are quite weak on their own, at least the first three that I read through. I doubt that they will stand to a deeper scrutiny.)
#3 by Vuk - August 13th, 2010 at 16:30
Not a big deal though but it’s not SPSS v WPS it’s SAS v WPS…
#4 by steve - August 13th, 2010 at 19:06
Google does not use the OpenJDK libraries. It uses the ones from Apache Harmony.
And Dalvik is basically derived from Apache’s implementation of the VM, too.
So Oracle basically says that the Apache foundation, which is _the_ creator of some of the most important Java libraries, servers, frameworks stole from them.
#5 by Tom - August 13th, 2010 at 19:09
Related:
“This is truly a perversion of the open source spirit.”
After 4 years of contributing to OpenSolaris his code flies by:
http://sstallion.blogspot.com/2010/08/opensolaris-is-dead.html
#6 by Matt - August 13th, 2010 at 21:57
questionable patents. hmm.
#7 by Nadav - August 14th, 2010 at 08:31
From a high-level point of view, I think that this battle between Oracle and Google is not about the java compiler or mobile devices. I get the idea that somehow Google’s map-reduce threatens Oracle’s database business. Very few people need a big database when they can store their data in googl’es big-table.
#8 by jakoja - August 15th, 2010 at 06:54
This situation (created by Google) killing Java
Google should participate in JDK7 and using this
#9 by S - August 16th, 2010 at 09:00
The patent grants only come if you are compliant, but the only way to demonstrate compliance is to pass the test kit, the JCK. Sun refused to give the apache the JCK to verify their clean room implementation of the specification unless they restricted use of their implementation to classic laptop/desktop/server systems (see: http://www.apache.org/jcp/sunopenletter.html ). Therefore Harmony, a clean room implementation of the specification, hasn’t been granted the patents. However, it is not clear that the Java Community Program gave sun the right to withhold the license or add extra restrictions, so the lawyers may be looking at that issue.
#10 by cdaffara - August 16th, 2010 at 19:10
In fact I was referring not to the J2SE patent grant, that does not apply to Android, but to the implicit patent license given when releasing OpenJDK.
#11 by Kevin Purcell - August 17th, 2010 at 00:24
You say: “Well, it is wrong. Wrong because Google did not copied Java – and actually never mention Java anywhere. In fact, the Android SDK produced Dalvik (not Java) bytecodes, and the decoding and execution pattern is quite different (and one of the reasons why older implementations of Dalvik were so slow – they were made to conserve memory bandwidth, that is quite limited in cell phone chipsets).”
Java is mentioned in the documentation but just as the “Java Programming Language” as in the name of the book that specifies it independently of the class libraries.
More importantly, I think part of the complication that many people have ignored (included yourself) is the toolchain used to build Android SDK “apps” does include the Sun/Oracle javac compiler.
The JDK must be installed to build Android applications.
The .class files output by the Sun javac compiler are then “translated” or “cross-compiled” by the dx application to Dalvik VM bytecodes in a .dex file which has the same functionality as a class file but the bytecode is Dalvik bytecode and the format is different. The Dalvik VM then executes those .dex files in the context of Google’s Apache Harmony derived class library (which of course is also in .dex form).
An important question is exactly where do Oracle see a copyright violation? Remember this part is not trademark or patent violations.
Is it in this toolchain? But Google doesn’t distribute the JDK so it’s not there.
Is it in the content output by javac that is then converted by dx? Does that mean that Oracle claims some copyright on the .class files any developer makes because they contain something included by the javac or it’s runtime? That seems like a very odd claim for a compiler especially a GPLed one (see below)
Does Oracle somehow believe that developers can’t manipulate the .class files that they generate with the JDK? How can they do that without a EULA or other contract which Google never signed. The GPL 2 which has covered the JDK since 17 November 2006 is not a EULA (it’s a distribution license) which explicitly states “Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted …”.
I’m still not seeing where the copyright violation is (unless it’s something trivial in the documentation).
#12 by Me, myself and I - August 28th, 2010 at 00:38
I briefly looked at the patents. I guess Google will invalidate all of them in separate cases by presenting prior art even before the Oracle vs. Google case gets going.
#13 by eduardo drake - September 2nd, 2010 at 06:25
For a detailed claim analysis, check out the upcoming webinar: Will Oracle’s Java Patents Take Down Google’s Android Platform? See http://www.sunlightresearch.com for details and registration information.
#14 by fax2email - July 19th, 2011 at 08:13
Is it in the content output by javac that is then converted by dx? Does that mean that Oracle claims some copyright on the .class files any developer makes because they contain something included by the javac or it’s runtime?