U.S. Supreme Court Denies Google's Request to Appeal Oracle API Case
A few thoughts:
1. This is a denial of a petition for writ of certiorari, which is a fancy legal term for a request that the U.S. Supreme Court exercise its discretionary jurisdiction to consider the appeal. This means that the court can hear it or not, as it deems fit, and only if it sees some really pressing reason to do so.
2. The above standard is very tough to meet and only the rare case will do so.
3. Here, Google had prevailed on the copyright claims at the trial level because the trial judge, rather than applying precedents mechanically, had rather bravely attempted to synthesize a byzantine body of law through what I believe was a brilliant synthesis of copyright law as applied to software interfaces that allowed him to conclude that APIs were not copyrightable (see my earlier assessment here: https://news.ycombinator.com/item?id=4050490#up_4051761). On appeal to the Federal Circuit, however, the court rejected this attempted synthesis and applied conventional precedents to conclude that APIs were indeed subject to copyright protection. Even in doing so, the Federal Circuit did not grant judgment for Oracle but instead sent the case back to the trial court to determine if Google could prevail on its defense that its mirroring of the java APIs was a fair use of otherwise protectable code and therefore not infringing.
4. In exercising its discretion whether to hear an appeal of this type, the Supreme Court considers not only the importance of the issues raised by the appeal but further considers whether such issues are ripe for determination by the highest court of the land. What that means is that the court is not interested in addressing questions that may prove academic to the litigants in the case. It is interested only in resolving cases in which the issue it is being asked to resolve is critical to the outcome of the case. Here, that standard was not met. Why? Because the appeal is from a case that Google has not yet lost. Should Google have the case tried on remand, and prevail on its fair use argument such as to win definitively on the copyright issues, then there is no need for it to obtain a determination that APIs are not copyrightable at all. In such a case, that latter issue becomes moot. Thus, in denying Google's writ, the Supreme Court may well have concluded that it is simply premature to take up the API issues until all of them have been first finally decided by the lower courts.
5. The other major fact to note here is that a denial of this sort of writ by the Supreme Court has no legal significance in terms of ruling on the merits of the claims presented. The denial simply means that the court is not interested in taking up those issues at this time. It is entirely possible that the case could be tried in the lower court, that Google could lose on all copyright issues in that trial, that Google could appeal once again, that the Supreme Court would eventually grant a future writ to hear these very issues, and that the Supreme Court could rule in Google's favor that APIs are not copyrightable at all.
6. Having lost on the copyright issue before the Federal Circuit, Google has a pretty tough fight before it in this case. For the same reasons, though, that Judge Alsup had originally concluded that copyright law should not even protect APIs, it has a potentially compelling fair use argument to make and may therefore win on that issue. If it does not, it can once again appeal to the Supreme Court for redress. That would be a long shot, but it is possible.
7. The only thing certain about this case now is that a long, drawn out legal battle will follow before anything is definitely decided. The issues are important for our tech age and, in this case and otherwise in the federal courts, only time will tell whether Judge Alsup's original synthesis (or some variation) favoring freer interface use or the Federal Circuit's maximalist IP views will ultimately prevail.
The original judge in lower court actually taught himself coding to understand the case and came to the conclusion that APIs were not subject to copyrights (ie. he understood the issue). How the appellate court could come to a different conclusion is utterly beyond me.
Unfortunately this was a terrible case to have been the first of its kind (in the US). There was much more at play here than API copyright. Google didn't just copy the Java APIs, but it took the syntax as well. Oracle also presented evidence that Google had directly copied implementation of a few API functions, which Google actually admitted was true, but claimed it to be negligible. While all of these claims were examined separately, all of them combined made it much harder for any individual victory.
Could someone more knowledgeable on the relevant legal issues add some comment? This seems remarkably bad for the industry in general.
As a result, I've decided to write a perl script that generates random APIs in some API-space, compress the new API and then store it all as blobs to disk while simultaneously filing for a copyright on all of these APIs.
Out of curiosity (and as an exercise), what if Google decided to convert all the Java code and APIs to Scala (assuming they had permission from Typesafe)? Would that still be infringement considering they are using the JVM (Dalvik or ART) but not actual Java code? Doesn't even Scala use (or transcompile to) Java code which could be infringement?
Lower court ruling, if anyone is interested. Makes for some intriguing reading.
http://cases.justia.com/federal/appellate-courts/cafc/13-102...
Here's a question:
The ruling found that APIs form a substantive body of work, similar to something like a play. However, if I took a play and used a computer to detect the sentence boundaries based on punctuation and randomly permuted the sentences, then wrote a book about what happened when I said random subsets of those sentences in random order to a set of undergrads, I'd be considered to be doing derivative work, even if I listed every sentence of the original work, as long as I substantially commented on each sentence in the context of my experiment.
In the context of APIs, isn't it possible to automate the performance of this experiment and writing of subsequent report?
Couldn't Google just comply with the license and re-release their code under GPL with linking exception like the original standard library? Maybe pay a fine but at least Android survives.
They should have just paid the vig to Oracle and been done with it, instead they have a knock-down-drag-out and end up with a precedent that damages all software development everywhere. All involved are acting like a bunch of jerks.
What are the implications if Google loses?
Is Google going to switch to another language for Android development? Apple has already showed it is possible.
undefined
Google can still win this on fair use.
Why do you guys talk about Oracle as though Oracle created Java? Sun created Java. worked to gain greater control over it and was bought out by Oracle.
A lot of us here don't identify Java with Oracle, we just regard Oracle as "a great vampire squid wrapped around the face of Java ecosystem and the software industry, relentlessly jamming its blood funnel into anything that smells like money*
LOL
That's why we need more open source under MIT license in the API space.
Fast growing OSS projects like KONG [1] for API management or Strongloop are a way to avoid to invest in technologies that are not fully open or usable under the right license.