Friday, May 11, 2012

Oracle v. Google


By: S.S., Senior Security Engineer @ G2

If you're anything like me then you've been fascinated by the Oracle v. Google trial for the past few weeks, reading courtroom transcripts daily. If you haven't been following, you need to get up to speed on what has been happening - this trial has the potential for major impacts on everyone here.
The basic premise of the trial, at least in Phase 1, is that Oracle is claiming Google violated Java copyrights in Android. The basic claims Oracle is making is:
  • APIs are copyrightable, and they have legitimate copyright claims
  • 37 APIs from Java are implemented in Android and thus infringe on the copyright
  • There is some code in Android copied verbatim from Java, demonstrating that it was willful violation of copyright
  • Email traffic over the years indicates that Google knew it needed a license
  • Deviation from Java has caused fragmentation of Java and thus hurt Oracle.
Google's basic counter-argument:
  • Oracle can't make copyright claims to everything they're claiming, other parties have claims on some of it
  • Other projects, like Apache Harmony, effectively do the same thing as Android
  • A license is only needed if you want to validate against the TCK and call your software Java compatible
  • Sun was well aware of what Google was doing, and was supportive (remember - Oracle now owns Sun, thus Java)
  • Former Sun CEO says they didn't go after Google because they knew they didn't have grounds
  • What Android does falls under fair use
  • Android was developed in a clean room, but one of the subs apparently did copy some Java code despite being told not to use anything from Java. Oops, it has since been removed. And it was 9 lines.
The jury has reached a partial verdict, but more on that in a bit. What matters here is the idea that an API could be copyrighted. This case isn't about whether you can "use" the API - nobody is arguing that you can't write Java code that calls the things defined in the API. This is about whether you can do your own independent implementation of an existing API, or is the API protected such that you can't implement it?
If Oracle is right, and an API can be copyrighted, then this sequence of events could happen:
  1. I build a class that has a method called Add that takes 2 integer parameters A and B and returns the value of A + B
  2. I put a copyright on that class
  3. You implement a class with a method called Add that takes 2 integer parameters and returns the value of those parameters added
  4. You just violated my copyright - pay me lots of money
Seem crazy? Yeah, it is. The effects are so far-reaching that it is hard to comprehend. Here's a sampling of things that could be found in violation of copyright if Oracle is correct:
  • Samba, for implementing SMB
  • Jython, IronPython, and other other implementations of Python's API
  • Mono for implmenting C#/VB
  • Any web browser that implements Javascript
  • Any compiler, for daring to understand a language's API
  • C++, for extending C (maybe...) 
So it all seems completely wrong to everyone with a clue but Oracle, and they're obviously just looking for money. Now the question is whether or not the courts have a clue. Interestingly, the decision to this case is a mixture of the judge and the jury. Here's what the jury determined (paraphrased legalese):
  1. Has Oracle proven that Google infringed on the structure, sequence, and organization of the 37 APIs - YES
    1. Has Google proven that this infringement is fair use - TBD
  2. Has Oracle proven that Google infringed on the documentation of the 37 APIs - NO
  3. Has Oracle proven that Google has infringed on
    1. The rangeCheck method in 2 classes - YES (this was the copied code)
    2. Source code in some other files - NO
    3. Comments in a few files - NO
  4. Has Google proven that Sun/Oracle did things that reasonably led Google to believe that they did not need a license - YES
    1. Did Google rely on this to decide that they didn't need a license - NO (In other words, they had more reasons).
Both sides are publically claiming victory, but only the Google lawyers were laughing in court, while Oracle's lawyers were sad.
For question 3, the jury did decide that Google improperly copied some code. This is expected to be inconsequential. Oracle asked the judge for damages for that copied code. Here's the funny exchange:

Oracle: Separate damage calculation.
Judge: Do you want all their profits?
Oracle: No, Your Honor.
Judge: This borders on the ridiculous... Based on 9 lines of copying out of 15 million? That would ge a big, big stretch.

So Oracle probably shouldn't get their hopes up.
But what about question 1? The jury did find that Google infringed on the SSO of those 37 APIs, which is completely understandable - you can't have interoperability without using the same SSO. What the jury couldn't decide was if it was fair use, or in other words, is acceptable. Ultimately it doesn't matter too much that they couldn't decide, as the judge is going to make the bigger decision - can APIs be copyrighted or not?
During this trial a decision on a similar case came out of the EU, which declared that APIs could not be copyrighted. The judge in this case has read that decision and may follow it. Throughout this case it has looked like the judge is leaning toward the Google side, but maybe it is just him placing the burden of proof on Oracle. He certainly hasn't seemed terribly sympathetic to Oracle.
So who do you have in this case? If you like using computers, hope that Google wins...

No comments:

Post a Comment