
U.S. Supreme Court Denies Google's Request to Appeal Oracle API Case - spiralpolitik
http://www.supremecourt.gov/Search.aspx?FileName=/docketfiles%5C14-410.htm
======
grellas
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](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.

------
Beltiras
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.

~~~
rayiner
I don't think those who "understand the issue" must necessarily agree with the
lower court. I've been coding since I was 13 and I agree with the Fed. Cir.
here. The concrete Java declarations that make up an API are a protectable
work of authorship. The abstract operations they describe are not.

E.g. POSIX C headers are protectable. But Lisp FFI declarations that compile
down to the same ABI do not infringe because they targets the unprotectable
method of operation, and do not copy the protectable textual description of
those operations.

I think a lot of coders want the lower court to be right for pragmatic
reasons. I totally appreciate those pragmatic arguments, but they're not based
on having a better technical understanding of the issue.

~~~
cfallin
> E.g. POSIX C headers are protectable. But Lisp FFI declarations that compile
> down to the same ABI do not infringe

This distinction does have a certain clarity to it, but isn't there a certain
sense in which there's "only one way" to describe an API for a given language?
"int foo(int a, int b)" is hard to write another way; perhaps I can rename the
parameters.

(Your Lisp FFI example sidesteps this issue because API declarations in
different languages will, of course, look different.)

In other words, I think there may be an "information content" argument. If the
abstract operations are not copyrightable, and there is only one obvious way
to write down the API's function prototypes in (e.g.) Java or C, does the
source code really carry additional copyrightable value?

~~~
pcwalton
I wonder whether, for example, Java's "double sinh(double x)" from
java.lang.Math could be found to be infringing on the pre-existing "double
sinh(double x)" from math.h. The API is literally textually equivalent, right
down to the variable names, despite the language being different.

(I'm genuinely curious what case law now considers the line to be; this isn't
a rhetorical question.)

~~~
rayiner
Infringement requires copying, not just text equivalence. If the C programmer
was "writing C" and the Java programmer was "writing Java" there is probably
no infringement because there is no copying.

~~~
pcwalton
Thanks, that's helpful.

(java.lang.Math is awfully similar to math.h; I actually wonder if,
historically, there _was_ copying.)

~~~
jacobolus
Historically, almost everything in computing is a copy of a copy of a copy,
usually ultimately leading to some pseudocode in an academic journal
somewhere. If everyone along the line asserted their copyright, the whole
field would collapse.

------
andrewguenther
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.

~~~
Oletros
One 9 lines function, nothing more was copied.

The only other thing were 7 test files that were not part of the
implementation

~~~
spinlock
So you admit that there was copying. /s

But, in all seriousness, the 9 lines + 7 files are damning. It also shows that
the engineers who implemented Google's project had been tainted by exposure to
Java.

~~~
NeutronBoy
> But, in all seriousness, the 9 lines + 7 files are damning. It also shows
> that the engineers who implemented Google's project had been tainted by
> exposure to Java.

I think that's one of the key points. How can you claim a clean-room
implementation, when there are (small) portions that have been directly
copied? It weakens the case for the rest of the code.

~~~
Zigurd
Android uses code from Apache Harmony for many basic Java classes. If any code
was copied from Java 6, it would have happened in the Harmony project.

Android's use of Java also ends in the toolchain. Android never used a
Java(tm) runtime, nor Java bytecode in the runtime. by the time an app hits a
device, it's in Dalvik bytecode and either interpreted/JIT-compiled by the
Dalvik runtime or pre-compiled to the target system ISA for the ART runtime.

------
hahainternet
Could someone more knowledgeable on the relevant legal issues add some
comment? This seems remarkably bad for the industry in general.

~~~
spiralpolitik
We need to wait for the lower court to decide if Google's use fell under "fair
use". If it doesn't then it is bad news.

~~~
justinlardinois
Specifically the district court. The case made it to a federal appeals court,
which ruled that APIs are copyrightable (the district court had ruled they
were not), and then remanded* the case back to the district court to decide if
Google's fair use defense was valid. Google appealed the federal court
decision to the Supreme Court, which decided to not hear the case.

*Appeals courts in the United States do not rule on the facts of a particular case; they only decide if the lower courts properly applied the law. This doctrine is either by law or tradition, depending on the particular appeals court. When an appeals court overturns a legal decision made by a lower court, it typically remands the case back to the lower court to clarify any facts necessary to resolve the case.

~~~
dragonwriter
> Google appealed the federal court decision to the Supreme Court

The _appeals_ court decision -- both the district court and the appeals court
are federal courts.

> Appeals courts in the United States do not rule on the facts of a particular
> case

That's not always true; matters of fact _can_ be appealed, and there are
different standards of review on appeal for different _kinds_ of fact
question, however, appeals courts generally _prefer_ not to reach fact
questions, _particularly_ if the appeal was over a question of law and not
specifically on the fact question, and appeals courts generally do not answer
questions -- particularly fact or mixed fact/law questions -- that have not
been addressed by the court below, as is often the case where the appeals
court reverses a finding of law of the lower court, which then makes relevant
a fact question that the lower court did not answer because it would have been
irrelevant under the lower court's view of the law.

------
bane
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.

~~~
gnoway
Are you sure that's a good idea? You might inadvertently implement someone
elses's API that way.

~~~
dragonwriter
Inadvertent similarity is only an issue with patents, not copyrights.

~~~
justinlardinois
That's not true. Inadvertent similarity can still be copyright infringement.
Sam Smith's "Stay with Me" is a good recent example.

~~~
dragonwriter
> Inadvertent similarity can still be copyright infringement.

No, it can't. Copyright violation requires an actual copy or derivative work,
not independent works that have coincidental similarity.

> Sam Smith's "Stay with Me" is a good recent example.

Its an example of something where _one party_ claimed copyright infringement,
_the other party_ claimed inadvertent similarity, and the facts were never
resolved because the two parties reached an undisclosed settlement.

It is not an example of something both _actually_ being copyright infringement
while also _actually_ being inadvertent similarity.

------
Negative1
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?

~~~
rayiner
I think Oracle has a "thin" copyright here--the literal Java declarations.
Expressing the APIs in Scala (or Clojure) and compiling down to whatever they
compile down to these days shouldn't infringe.

------
remarkEon
Lower court ruling, if anyone is interested. Makes for some intriguing
reading.

[http://cases.justia.com/federal/appellate-
courts/cafc/13-102...](http://cases.justia.com/federal/appellate-
courts/cafc/13-1021/13-1021-2014-05-09.pdf)

------
SomeStupidPoint
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?

~~~
andrewguenther
I'm not quite sure what you are trying to draw a parallel to here. What does
this final report represent?

------
bcg1
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.

~~~
carussell
> Couldn't Google just comply with the license and re-release their code under
> GPL with linking exception like the original standard library?

Yes.

Alternatively, .NET is licensed under Google's preferred permissive license
these days.

Neither of these will happen, however.

------
erlich
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.

~~~
gnoway
Would this be enough though? As I understand it the issue is that Dalvik
implements large portions of the Java API so that developers can write Java
and run on Android without Android actually providing a Java VM. So
introducing a new language to run on the same VM doesn't work. If anything it
reinforces how similar Dalvik is to the JVM.

And that's what's really terrible about this, because before you could provide
a clean-room reverse-engineered implementation of something and that would be
OK. If I'm understanding this decision correctly, you can't do that anymore;
if this were the law 40 years ago then there would never have been an "IBM
Compatible" and who knows what consumer computing would look like today.

~~~
cwyers
The ruling says that APIs are copyrightable. It does not say that Google is
infringing, yet -- the court has yet to rule on whether or not Google's use of
the Java APIs falls under a fair use exception. The argument being advanced,
as I understand it, is that Google's use of the APIs does not qualify for fair
use because it was not being used to create an implementation of the JVM, but
because it was being used to create a different runtime (Dalvik) which uses
some of the Java APIs but is NOT an attempt to be compatible with the JVM. So
it is possible to rule that Google infringed upon Oracle's copyrights without
ruling that something like the IBM-compatible PC infringing.

~~~
pyre
So are they claiming that it infringes copyright if your implementation is a
superset or a subset of the original implementation, but if it is an exact
implementation, then it's not copyright infringement?

How would that work with (e.g.) beta versions of something that was aiming for
100% compatibility, but had not achieved it yet? Are you prevented from
releasing until you reach 100% compatibility?

Does this prevent MS-style "embrace, extend, extinguish?"

~~~
wtallis
> So are they claiming that it infringes copyright if your implementation is a
> superset or a subset of the original implementation, but if it is an exact
> implementation, then it's not copyright infringement?

They're claiming that any of the above would require an API license, and that
a license (requiring GPL for the implementation) was granted only to the
latter, so a subset would be unauthorized infringement.

~~~
pyre
But when you start creating an implementation, it ends up being a subset while
it is a work in progress. Are you stating that works in progress are
infringing, until they become "magically" not infringing at the point where
they reach parity?

Does Mono infringe on Microsoft's .NET API because it has always lagged behind
the official .NET API, even though the goal of the project is to achieve
compatibility?

~~~
wtallis
.NET isn't relevant because Microsoft isn't trying to control it with the same
kind of licensing terms that Oracle's using to try to ensure that anybody
else's Java implementation adheres to their standards.

------
justonepost
Google can still win this on fair use.

~~~
spinlock
I hope that's the ultimate outcome. I'd be OK if we allow copyrighting of APIs
as long as using those APIs falls under fair-use.

~~~
AnimalMuppet
It would kind of defeat the point of publishing an API, wouldn't it? "Here's
my API, but you can't use it without violating my copyright." Well, then, you
might as well not have published it.

But the issue here is actually _re-implementing_ the API, not _calling_ it.
The court could rule that an API could be copyrighted (and therefore freely
called, but not freely re-implemented). The result would be that an API
becomes a one-way interface. You couldn't have multiple competing
implementations, you could only have one. That's still a big change for the
software landscape...

~~~
wtallis
How would APIs involving callbacks work? Would they need special license
acrobatics to authorize you to implement a callback of the necessary form as
specified by the copyrighted API?

------
vfclists
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

~~~
andrewguenther
Because Oracle has ownership of the Java's APIs in this case? Sun really has
nothing to do with any of this.

~~~
wtallis
Well, Sun does matter a bit when it comes to questions of what license terms
were or were not offered and with what motivations. If there's any doubt about
what Sun actually did back when they were independent, then Oracle is somewhat
constrained by what _Sun_ was trying to do (Open source Java), not what Oracle
is trying to do (close Java while leaving only a GPL implementation open-
source).

------
culo
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.

[1] [https://github.com/mashape/kong](https://github.com/mashape/kong)

~~~
spiralpolitik
I'd go further and add that the API should be under some governance framework
so that a single entity cannot make unilateral changes to the API.

