Having watched Oracle v. Google closely from the outset of the litigation more than 20 months ago, I can say that at least the trial serves to satisfy my curiosity. None of the material that has shown up is entirely surprising, but this trial adds many pieces to the puzzle. So far, this has been the case especially in connection with the fact that Google knew at all stages of Android development about the legal risks it was taking. For example, there isn't just one Lindholm email but a whole collection that spans a period of more than five years, a fact that neither his evasive testimony nor his victory signs in the courtroom can change.
In that pile of Lindholm emails I found one part that was not written by Lindholm himself but by Andy Rubin. It appears in one of the Lindholm emails as a result of the automatic insertion that most email clients are configured to make if the user hits the "reply" button. Since Rubin wrote this between two Lindholm emails dated December 20, 2005, the date of this email is also known. Here's the email (click to enlarge or read the text again below, reformatted without the greater-than signs indicating that it was a quote):
Andy Rubin wrote:
My reasoning is that either a) we'll partner with Sun as contemplated in our recent discussions or b) we'll take a license. I think a clean-room implementation is unlikely because of the team[']s prior knowledge, and it would be uncharacteristically aggressive of us to position ourselves against the industry.
The only thing we give up is a little leverage in the discussions where the threat of a clean-room implementation is of some value.
The above email appears on page 15 of this PDF document.
The term "clean-room implementation" refers to the development of a Java virtual machine that doesn't make use of any of the original Java code. The expression "develop in a clean room" goes beyond the notion of just "writing from scratch" or "starting on a green field". The word "clean" means that this development must be entirely independent. One can rewrite code from scratch, but if it's based on a recollection of existing code, that's not "clean".
The "prior knowledge" of Java on the part of Google's Android development team was clearly an issue, and Rubin knew that they were unlikely to steer clear of intellectual property infringement. One of Oracle's opening slides also pointed to the fact that some key Googlers previously worked on Java while they were at Sun:
At the time, Rubin didn't say "APIs aren't copyrightable" or "this is fair use". If there are no IP issues, it's still a "clean room". It only gets unclean if there's an infringement of sorts.
The word "clean" isn't a question of whether something is 90%, 95%, 99% or maybe 99.99% clean. It's binary. It's clean or it's not. Android's implementation of Java is not:
Google literally copied material from at least 12 source files (with or without the use of a recompiler).
- An entire API function, TimSort rangeCheck, may be small compared to such large and complex software systems as Android and Java, but it's large enough that two people would hardly write up the same code for this purpose by mere coincidence. One of Oracle's slides points to Google engineer Joshua Bloch's testimony (on which I already reported more than seven months ago):
"Q. BY MR. JACOBS: Do you have a recollection of accessing Sun code while you were working on TimSort?
A. I don't have a recollection, but I'm perfectly willing to believe that I did. You know, I think the similarity of the signature, the fact that, you know, the three arguments are in the same order and have the same name, you know, is a strong indication that it is likely that I did."
Even if Google had developed a "clean-room implementation" of Java, some essential intellectual property would always have to be licensed, and in order to be eligible for such a license, an implementation needs to be fully compatible with the Java standard. Also, Google's implementation of Android contains code from the (unlicensed) Apache Harmony project, but to the extent that such code contains any infringements, Google is fully liable. That said, the parts of the code that Google developed itself weren't written in a "clean room".
There's still going to be quite some talk about Google's management decisions and internal processes. Former Google CEO Eric Schmidt and Andy Rubin are on the list of Oracle's next ten trial witnesses. But this isn't just about how Google knowingly and willingly used Java without the license it needed. A particularly outcome-determinative issue is the copyrightability of the 37 APIs at issue in this case, and the judge asked the parties a number of questions relevant to that issue. The answers are due today at 3 PM local time. In my next blog post on Oracle v. Google I'm going to (finally) get to the important question of API copyrightability. I will also review and comment on the parties' answers to Judge Alsup's copyrightability-related questions.
If you'd like to be updated on the smartphone patent disputes and other intellectual property matters I cover, please subscribe to my RSS feed (in the right-hand column) and/or follow me on Twitter @FOSSpatents and Google+.
Share with other professionals via LinkedIn: