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.
* 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.
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.
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 look forward to finding out what happens next.
Not sleeping through the dispute
but dreaming of the outcome