Oracle v Google: are certain elements of the Java platform entitled to copyright protection?

With so much happening in the field of IP, even the
best-organised of IP blogs is hard-pressed to cover all the major issues
that arise around the world. The IPKat and Merpel do their best, but
are always grateful to receive a little outside assistance from time to
time.  Here's a guest post, brought to you courtesy of fellow blogger, tweeter and IP enthusiast Thomas Dubuisson (right),
for which this Kat is particularly grateful since -- while he has
mastered the concept of the API, he blushingly confesses that he had
never previously spotted the term "declaring code".  Anyway, this is
what Thomas tells us about a larger than life dispute that is rumbling
through the courts in the US but which many readers from outside that
jurisdiction may not yet have had the chance to reflect upon:

It is difficult for
even the most soundly-sleeping feline to remain unconscious of the recent Google
petition
for writ of certiorari. This case is particularly interesting because
it involves many spicy ingredients: a smartphone IP dispute between two tech
giants (Google and Oracle), a lot of money at stake, a potential fair use
exception, and copyright law in the computer context. 

As things stand,
this is by no means a new case. The main question at issue is whether
Google
infringed Oracle’s patents and copyrights by copying Oracle-owned Java
APIs in Android (Google’s mobile operating system) without
authorization.  As is known, many software developers use the
Java language, as well as Oracle’s API packages, to write apps for
smartphones
and other devices that we daily use. This saga started four years ago in
August
2010, when Oracle filed a complaint for copyright and patent
infringement and a
demand for jury trial. Oracle claimed (and stills claims) copyright
protection
with respect to both 

*  literal elements
of its API packages—thousands of highly creative and original lines of declaring
source code [“declaring
code” being the “expression that identifies the prewritten function” and commands
the computer to execute the associated “implementing code”, which gives the
computer the step-by-step instructions for carrying out the declared function] that
Google copied verbatim and  

*  non-literal
elements—the structure, sequence, and organisation of each of the 37 (of the
166) Java packages,
i.e. shortcuts allowing programmers
to use a prewritten code to build certain functions into their own programs,
rather than write their own code to perform
those functions from scratch of computer source code, which Google generally replicated when it developed the Android
platform.

For those who are unfamiliar with computer
programming (like this author), an application programming interface (API),
simply expressed, is a set of commands, protocols, and specifications that
allow applications to communicate with each other. For instance, YouTube provides several APIs and tools that let you
integrate YouTube into your website, mobile app or device. 

The case was assigned to Judge William Alsup (Northern District of
California) who ruled that APIs
are not subject to copyright. The Judge said, among other things, that (i) declaring
code was not protectable and that (ii) although the overall structure of
Oracle’s API packages was creative, original, and “resembles a taxonomy”, it was
nonetheless “a command structure, a system or method of operation that is not
entitled to copyright protection under Section 102(b) of the Copyright Act”. He
also emphasized that, “[o]f the 166 Java packages, 129 were not violated in
any way”, concluding that 

“Google and the
public were and remain free to write their own implementations to carry out
exactly the same functions of all methods in question, using exactly the same
method specifications and names. Therefore, at the method level …  Google has violated no copyright, it being
undisputed that Google’s implementations are different”. 

On the patent
infringement issue, the jury found no infringement (the patent claims were not
at issue in the appeal). 

On 9 May 2014 Oracle
appealed the ruling to the U.S. Court of Appeals for the Federal Circuit, which
reversed the decision. In its view 

* Oracle was not seeking copyright protection
for a specific short phrase or word, but instead for 7,000 lines of declaration
code. The Judge stated that because “Oracle “exercised creativity in the
selection and arrangement” of the method declarations when it created the API
packages and wrote the relevant declaring code, they contain protectable
expression that is entitled to copyright protection”;

*  the "structure, sequence and
organization" of an API was copyright protected. The problem with the
district court’s approach is that computer programs are all designed to
accomplish some task and therefore, by definition, functional.  Additionally, the statutory definition of “computer
program” acknowledges that they function “to bring about a certain result” (17
U.S.C. § 101) and are therefore entitled
to copyright protection as long as the author had multiple ways to
express the underlying idea. Moreover, Google designed many of its own API
packages from scratch, and thus could have designed its own corresponding 37
API packages if it wanted to do so (ibid.) which, the opinion notes,
"Google chose not to do". However, the Court left the possibility
that Google might have a fair use defence.

On October 6,
2014, Google filed a petition asking the U.S. Supreme Court to review the
Federal Circuit's appellate ruling holding Oracle's asserted Java API declaring
code to be copyright-protected. On December 9, 2014, Oracle responded
to Google asking the Supreme Court to reject the case.

Not sleeping through the dispute
but dreaming of the outcome

In conclusion, this
dispute is all about the threshold question of what is protectable copyright
subject matter and, consequently, what constitutes an infringing activity. Oracle
pushes for a fair and “well-deserved” copyright protection, whereas Google prefer
a conceptions that allows for interoperability/ compatibility and re-use to make
it easier for programmers to write for Android. The U.S. Supreme Court may hear
the case, or refuse to do so and remit it to the district court for a retrial
on "fair use".  We loo