Oracle America, Inc. v Google, Inc., No 9th Cir. 2013-1021, 1022 (5/9/2014)(http://cafc.uscourts.gov/images/stories/opinions-orders/13-1021.Opinion.5-7-2014.1.PDF)
Copyrightabilty of computer source code and data has been the subject of hundreds of cases over the years, but as the court in this case noted “application of copyright law in the computer context is often a difficult task.”
Background: Google purchased a mobile phone operating system (android) and needed applications to run on it. Many applications are written in the Java language – a language that allows a developer to write code and have it work on many different operating systems. However, in order for developers to easily run their Java applications, the method, class and package names should be identical so that they do not have to edit their source code for a different version of operating system. Google sought to license the Java code from Oracle, however, the parties could not reach a deal. Google then decided to write almost all of the functionality to reproduce a Java virtual machine (the code that does things with the data and objects passed to it from the main application) – except that it decided to use identically named and structured method, class and package names so that pre-existing Java programs would not have to be re-coded to work with Google’s replicated version. Oracle sued Google on patent and copyright claims; it lost on all patent claims in the lower court, leaving only the copyright claims.
The issue presented was whether computer code constituting class method and package names along with their associated structure were copyrightable. In this case, Google used 37 package names, which constituted 600 class definitions and approximately six thousand method descriptions. After a jury trial in which the jury deadlocked on fair use defense, the lower court held that such code elements constituted “short titles” and/or were merged with the idea they expressed, and hence, not copyrightable. The 9th Circuit reversed and held that the overall structure was a copyright, and Google literally reproduced it, thus infringing the copyright; however, it remanded for further proceedings to determine whether Goolge’s copying was a fair use.
First, the 9th Circuit overruled the lower court and held that Oracle’s Java method, class and package names were copyrightable as a taxonomy – that is, that even though independently each element was not copyrightable, their sequence, structure and organization constituted an original work of authorship: as expressed by the court “an original work—even one that serves a function—is entitled to copyright protection as long as the author had multiple ways to express the underlying idea. Section 102(b) does not … automatically deny copyright protection to elements of a computer program that are functional.” In summary, the 9th Circuit stated that “[W]e conclude that a set of commands to instruct a computer to carry out desired operations may contain expression that is eligible for copyright protection. […] We agree with Oracle that, under Ninth Circuit law, an original work—even one that serves a function—is entitled to copyright protection as long as the author had multiple ways to express the underlying idea. The use of the taxonomy here was not transformative because it served the same use as it did in the original work.” Thus, the ice/function of the software was not merged into its expression.
Google also argued that it had to copy the literal variable and class names so that its actual non infringing functional code could interoperate with the programs written for Java. The court held that while this argument might affect fair use, it was not relevant to copyrightability.
Finally, Google argued that its copying use was a fair use. Fair use is a mixed question of law and fact, however, “the Supreme Court has specifically recognized that, “[w]here the district court has found facts sufficient to evaluate each of the statutory factors, an appellate court ‘need not remand for further factfinding . . . [but] may conclude as a matter of law that [the challenged use] [does] not qualify as a fair use of the copyrighted work.’” Harper & Row Publishers, Inc. v. Nation Enters., 471 U.S. 539, 560 (1985).
The first factor in a fair use analysis is determining whether the purpose and character of the use, including whether such use is of a commercial nature or is for nonprofit educational purposes. 17 U.S.C. § 107(1). ” This factor involves two sub-issues: (1) “whether and to what extent the new work is transformative,” Campbell, 510 U.S. at 579 (citation and internal quotation marks omitted); and (2) whether the use serves a commercial purpose.”
Courts have described new works as “transformative” when “the works use copyrighted material for purposes distinct from the purpose of the original material.” Elvis Presley Enters., Inc. v. Passport Video, 349 F.3d 622, 629 (9th Cir. 2003). “A use is considered transformative only where a defendant changes a plaintiff’s copyrighted work or uses the plaintiff’s copyrighted work in a different context such that the plaintiff’s work is transformed into a new creation.” Perfect 10, Inc. v. Amazon.com, Inc., 508 F.3d 1146, 1165 (9th Cir. 2007).
Many of the other factors weighed in favor of Oracle, but Google argued that “Google contends, however, that, although it admittedly copied portions of the API packages and did so for what were purely commercial purposes, a reasonable juror still could find that: (1) Google’s use was transformative; (2) the Java API packages are entitled only to weak protection; (3) Google’s use was necessary to work within a language that had become an industry standard; and (4) the market impact on Oracle was not substantial.”
The court was unable to determine that enough facts had been ascertained to make the conclusion as a matter of law that Google’s copying was not fair use, and thus remanded for further proceedings.
Impact of case: The lower court decision was troubling in its determination that a sequence of commands arranged in a way could not be copyrightable merely because they were functional. At the same time, expanding copyright protection to functional elements has far reaching implication for control of many objects that otherwise would not be subject to copyright protection. The 9th Circuit at least reversed the no copyright finding. However it leaves in limbo whether the copying made by Google was fair use. This means that other operating and middleware code writers should first seek a license when using an application programming interface in their own implementation of the interface. Relying on solely fair use would be risky.
Article by Michael Oliver, Esq., Oliver & Grimsley, LLC