In a landmark decision concerning the copyrightability of computer software, on May 9, 2014, the U.S. Federal Circuit Court of Appeals held that Oracle, Inc. is entitled to copyright protection for 37 Java application programming interface (API) packages used by Google, Inc. in Android, the world’s most widely used mobile operating system. The Federal Circuit overturned a May 2012 district court decision holding that the API packages are a “command structure, a system or method of operation” and therefore not entitled to copyright protection under the Copyright Act.
Acknowledging that “the application of copyright law in the computer context often presents a difficult task,” the Federal Circuit held that the aspects of the API packages copied by Google are copyrightable because they are “original” and “creative” and “could have been written and organized in any number of ways and still have achieved the same functions.” According to the court, the Copyright Act “does not bar the packages from copyright protection just because they also perform a function.” The court remanded for retrial of Google’s fair use defense.
The Federal Circuit’s decision is a victory for Oracle and others in the software industry who believe that copyright protection is important to provide developers with financial incentive to innovate. On the other side are open source advocates and others who view copyright protection for software like the Java APIs as a significant impediment to software interoperability and innovation. As argued by the Computer & Communications Industry Association in its amicus brief: “The United States and over 40 other countries have recognized that permitting copyright law to impede interoperability would harm legitimate competition in the computer industry and impair the growth of the Internet economy.” The ruling will further the debate over the future of copyright protection in the technology and software industries.
API packages include “ready-to-use” programs that perform common computer functions. API packages are shortcuts that allow programmers to use the prewritten code to build certain functions into their programs without the need to write code for these functions from scratch. Java API packages are broken into “classes” that include specific “methods” — the code for the common functions — and variables and other elements on which the methods operate. By the district court’s analogy: “Oracle’s collection of API packages is like a library, each class is like a book on the shelf, and each method is like a how-to chapter in a book.”
Oracle and Google conducted negotiations for the use of the Java platform in Android. These discussions broke down because Google was unwilling to make its programs compatible with the Java platform.
Google then used Java to write its own implementation of the Java API functions that were key to mobile devices. The Android platform includes 168 API packages. For 37 of these packages, Google copied the declaring source code (7,000 lines) from the corresponding 37 Java API packages “verbatim,” including the “elaborately organized taxonomy of all the names of methods, classes, interfaces, and packages,” known as the “structure, sequence, and organization” (or SSO) of these packages. With only a couple of exceptions, Google wrote its own implementing code. Three of the 37 API packages are considered “core” packages that are required by programmers “to make any worthwhile use of the language.”
Google released Android in 2007. Although the Android platform is written in the Java programming language, Android generally is not Java compatible, and apps written for one platform will not work on the other.
The Trial Court Proceedings
Trial in the U.S. District Court for the Northern District of California took place during the spring of 2012. The parties agreed that the district court would decide copyrightability, and the jury was instructed to assume that the SSO of the 37 API packages was copyrightable. The jury also was instructed that Google admitted copying the declaring code for these APIs verbatim. On May 7, 2012, the jury returned a verdict of copyright infringement against Google. The jury hung on Google’s fair use defense.
On May 31, 2012, the district court held that the copied elements of the 37 Java API packages, including the declaring code and SSO, were not copyrightable. The parties appealed.1
The Federal Circuit Decision
Oracle argued that the Java API packages are copyrightable because they are expressive and could have been written and organized in a number of different ways to achieve the same functions. Oracle also argued that the district court erred in finding the declaring code uncopyrightable based on the “merger” and “short phrases” doctrines. Oracle further argued that the district court erred in holding that the SSO was an unprotectable “method of operation” under Section 102(b) of the Copyright Act and by invoking Google’s “interoperability” concerns.
The Federal Circuit agreed with Oracle on each point.
Copyrightability of the Declaring Code
The merger doctrine. The “merger” doctrine “provides that, when there are a limited number of ways to express an idea, the idea is said to ‘merge’ with its expression and the expression becomes unprotectable.” The Federal Circuit held that the merger doctrine was inapplicable because it was a defense to infringement, not a bar to copyrightability.
The court also held that the merger doctrine did not apply because “[t]he evidence showed that Oracle had ‘unlimited options as to the selection and arrangement of the 7000 lines of code Google copied.”
The district court erred in focusing the “merger” inquiry on the options available to Google at the time of copying. The Federal Circuit held that “copyrightability and the scope of protectable activity are to be evaluated at the time of creation, not at the time of infringement.” Google could have written its own declaring code (along with the implementing code it wrote) to achieve the same results and, under these circumstances, the expression selected by Sun/Oracle “simply does not merge with the idea being expressed.”
Short phrases. The Federal Circuit agreed with the district court that “words and short phrases such as names, titles and slogans” are not copyrightable, but held that “the relevant question for copyrightability purposes is not whether the work at issue contains short phrases — as literary works often do — but, rather, whether those phrases are creative.”
Oracle was not seeking copyright protection for a single short phrase or word. Rather, the declaring code comprised 7,000 lines “and Google’s own ‘Java guru’ conceded that there can be ‘creativity and artistry even in a single method declaration.’” The Federal Circuit held that the declaring code contained “protectable expression that was entitled to copyright protection” because Sun/Oracle “‘exercised creativity in the selection and arrangement’ of the method declarations when it created the API packages and wrote the relevant declaring code[.]”
Scènes à Faire. The Federal Circuit noted that, under the scènes à faire doctrine, “expressive elements of a work of authorship are not entitled to protection against infringement if they are standard, stock, or common to a topic, or if they necessarily follow from a common theme or setting.” In the computer context, the scènes à faire doctrine precludes protection for program elements that are dictated by external factors like “mechanical specifications of the computer” or “widely accepted programming practices within the computer industry.”
The court held that Google was not protected by the scènes à faire doctrine because (like the merger doctrine) it is a defense to infringement, not a bar to copyrightability. The evidence also showed that “the groupings and code chosen for the 37 Java API packages were [not] driven by external factors or premised on features that were either commonplace or essential to the idea being expressed.” Finally, like merger, scènes à faire focuses on the circumstances at the time of creation, not the time of copying. It was therefore irrelevant that programmers may have become “accustomed to and comfortable using the groupings in the Java API packages.”
Copyrightability of the SSO of the 37 Java APIs
The SSO of the Java API packages was admittedly “original and creative.” The district court relied on the U.S. Court of Appeals for the First Circuit’s decision in Lotus v. Borland in holding that Section 102(b) precluded copyright protection because the SSO was a “system or method of operation.”
The Federal Circuit held that Lotus was factually distinguishable because, unlike Google, the defendant in Lotus did not copy any code underlying the “menu command hierarchy” at issue in that case. Also, the commands at issue in Lotus were not “creative” and they were “essential to operating” the system.
The Federal Circuit also held that Lotus was inconsistent with Ninth Circuit precedent recognizing that the SSO of a computer program “is eligible for copyright protection where it qualifies as an expression of an idea, rather than the idea itself.” The “hard and fast rule set down in Lotus” — i.e., that “elements which perform a function can never be copyrightable” — also is contrary to the “abstraction-filtration-comparison” analysis endorsed by the Ninth Circuit.
The Federal Circuit held that the district court’s conclusion that the admittedly expressive SSO was not copyrightable because it was “functional” effectively gutted congressional intent to provide copyright protection to computer programs. All computer programs are “functional.” Indeed, the Copyright Act specifically defines a “computer program” as “a set of statements or instructions to be used … to bring about a certain result.” The Ninth Circuit nonetheless has held that computer programs are copyrightable.
The court held that “Section 102(b) does not bar the packages from copyright protection just because they also perform functions.” 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.” Section 102(b) “codifies the idea/expression dichotomy” and it is “intended to make clear that the expression adopted by the programmer is the copyrightable element in a computer program.” Thus, even if an element directs a computer to perform a function, the copyrightability issue turns on “whether it contains any separable expression entitled to protection.”
Although the Java “package-class-method” organizational structure was not copyrightable, the Federal Circuit held that copyright protection is available for the “particular way of naming and organizing each of the 37 API packages.” Google and others are free to use the Java language and the “package-class-method” structure without fear of infringement so long as they did not “employ the precise phrasing or structure chosen by Oracle to flesh out the substance of its packages — the details and arrangements of the prose.” Because the SSO is “original and creative,” and the declaring code “could have been written and organized in any number of ways and still have achieved the same functions,” the court held that Section 102(b) was not a bar to copyrightability.
The court rejected Google’s “interoperability” arguments was irrelevant to the copyrightability issue, and distinguished the Ninth Circuit’s decisions in Sega Enterprises v. Accolade, Inc. and Sony Computer Entertainment, Inc. v. Connectix, Corp. on the grounds that those cases focused on fair use, not copyrightability. The Federal Circuit also rejected Google’s argument that Sega and Sony “created an ‘interoperability exception’ to copyrightability” because copyrightability focuses on the choices available at the time the program was created and there was no evidence that Oracle created the Java API packages at issue “to meet compatibility requirements of other pre-existing programs.” Google’s later desire that its software be “interoperable” with aspects of the Java platform has no bearing on whether Oracle’s software is copyrightable.2
Finally, the court rejected Google’s argument “that it was entitled to copy the Java API packages because they had become the effective industry standard.” The court was not presented with any authority holding that “copyrighted works lose protection when they become popular.”
“Fair use” is an affirmative defense to copyright infringement. The Federal Circuit sympathized with Oracle’s argument that “Google knowingly and illicitly copied a creative work to further its own commercial purposes, did so verbatim, and did so to the detriment of Oracle’s market position.” The court nonetheless held that “due respect for the limit of our appellate function requires that we remand the fair use question for a new trial” for three main reasons:
Although it was “undisputed that Google’s use of the API packages is commercial,” there were material fact disputes concerning whether Google’s use is “transformative.” A work is “transformative” if it “adds something new, with a further purpose and different character” from the copied work. The more transformative a work is, the less other factors — such as commercialism — will weigh against a fair use finding.
Although not pertinent to the copyrightability issue, Google’s arguments concerning the functional aspects of the packages and its desire to achieve commercial “interoperability” may be relevant to a fair use issue, particularly as to the three “core” API packages.
Material facts were in dispute concerning “market impact” in light of Oracle’s failure to successfully develop its own smartphone platform using Java technology, despite Oracle’s licensing efforts in the mobile and smartphone markets. The lack of market impact caused by a copy on the original work weights strongly in favor of fair use.
The Oracle v. Google saga is far from over. The broad copyright protection provided by the Federal Circuit is at odds with other circuit precedent, including the First Circuit’s decision in Lotus Dev. Corp. v. Borland Int’l, Inc., 49 F.3d 807 (1st Cir. 1995), aff’d without opinion by an equally divided court, 516 U.S. 233 (1996).
Moreover, as noted by the court, there is significant authority suggesting that software should only be protected under patent law, not copyright law (although it also notes the significant contrary authority). Based on the circuit split and the difficulty and importance of the underlying issues, it is likely that Google will seek rehearing en banc, as well as Supreme Court review if necessary. Finally, as the court notes in its fair use discussion, Google’s ultimate liability for copyright infringement is far from certain. Among other things, Google’s “interoperability” defense and the alleged lack of market impact on Oracle may support a finding of fair use, particularly as relates to the three “core” Java APIs.
1 The appeal was to the Federal Circuit because of the patent issues in the case. The copyright issues were governed, however, by U.S. Court of Appeals for the Ninth Circuit law.
2 The court also felt that Google’s “interoperability” argument was “confusing” since Android was designed not to be compatible with the Java platform.