As predicted here two weeks ago when the jury found that Google’s use of Java declaring code in the Android operating system was a fair use, the presiding judge has rejected Oracle’s motion for a judgment as a matter of law. Oracle argued that no reasonable jury could find against it, but the judge ruled that based on the law of fair use and the trial record, a jury reasonably could have found for either side on the fair use issue. Because the district court’s 20 page order applying fair use jurisprudence to the facts of this case likely will be the focus of Oracle’s inevitable appeal, it is worth examining in some detail.
Before diving into a discussion of the four statutory fair use factors, the district court explained that the jury reasonably could have found that Google’s copying of the declaring code of 37 of the 166 packages of the Java Application Program Interface (API) was justified by the objective of “inter-system consistency.” The Java API contains a library of thousands of pre-written Java source code programs for common functions. Each program is called a method. Each method contains a line of declaring code that specifies the method’s name and defines acceptable inputs and output. The method then contains implementing code that carries out the function. The methods are organized into a hierarchy of classes and packages, referred to as the API’s structure sequence and organization (SSO). Oracle conceded that copyright did not protect the Java language. However, Oracle claimed, and the Federal Circuit found, that copyright protected the declaring code and the SSO. The question before the jury was whether fair use allowed Google to copy the declaring code and the SSO.
The district court noted that for each of the thousands of methods that have been written for Java, the precise declaring code has been listed in books. “[T]he book duplicates all of the method declarations (organized by packages and classes) together with plain English explanations. A Java user can study the book and learn the exact method name and inputs needed to invoke a method for use in his or her own program.” The district court added that “all that the Java programmer need master are the declarations. The implementing code remains a ‘black box’ to the programmer.” The district court explained that “the declarations are ‘interfaces,’ meaning precise doorways to command access to the pre-written methods and their implementing code performing that actual work of the methods.”
With this background established, the district court reached the inter-system consistency point. Oracle conceded that Google was entitled to reorganize the functionality of the 37 re-implemented Java packages into a different SSO. However, had it done so, “then Java programmers, in order to use the Java system as well as the reorganized Android system, would have had to keep straight two different SSOs as they switched between the two systems for different projects.” The district court found that “our jury could reasonably have found that this incompatibility would have fomented confusion and error to the detriment of both Java-based systems and to the detriment of Java programmers at large.” The district court then provided the following analogy: “all typewriters use the same QWERTY keyboard—imagine the confusion and universal disservice of every typewriter maker had to scramble the keyboard.” The district court added that “since both systems presupposed the Java programming language in the first place, it was better for both to share the same SSO insofar as they offered the same functionalities, thus maintaining usage consistency across systems and avoiding cross-system confusion, just as all typewriter keyboards should use the QWERTY layout—or so our jury could reasonably have found.”
The same reasoning applied to the “wording” of each declaration. “To the extent a specification could be written in more than one way to carry out a given function, it was nevertheless better for all using the Java language to master a single specification rather than having to master, for the same function, different specifications, one for each system, with the attendant risk of error in switching between systems—or so our jury could reasonably have found.”
The district court emphasized that “inter-system consistency” is different from its analysis in 2012 relating to “interoperability” criticized by the Federal Circuit (and discussed in our previous posts here, here, here, and here about the Federal Circuit’s flawed decision). “The immediate point of cross-system consistency focuses on avoiding confusion between two systems, both of which are Java-based, not on one program written for one system being operable on the other, the point addressed by the Federal Circuit.”
The district court observed that the objective of “inter-system consistency” had significant bearing on the fair use analysis. In particular, with respect to the third factor, the amount used, “Google copied only so much declaring code as was necessary to maintain inter-system consistency. Google supplied its own code for the rest.”
Before discussing each of the four statutory fair use factors, the district court stated: “overall, avoiding cross-system babel promoted the progress of science and useful arts—or so our jury could reasonably have found.”
First Fair Use Factor: Purpose and Character of Use
Oracle’s challenge relating to the first fair use factor, the purpose and character of the use, centered on Google’s alleged bad faith. Oracle pointed to internal Google emails that suggested that Google believed that it needed to copy the Java API as an accelerant to bring Android to market quicker, and that it needed a license in order to copy Java.
The district court noted that Google presented evidence that many Google and Sun employees “understood that at least the declaring code and their SSO [structure, sequence, and organization] were free to use and re-implement, both as a matter of developer practice and because of the availability of independent implementations of the Java API enhanced the popularity of the Java programming language, which Sun promoted as free for all to use.” In particular, the district court observed that the testimony of Sun’s CEO at the time, Jonathan Schwartz, “supported Google’s view that a practice of duplicating declarations existed and the competition was on implementations.” Further, the jury could have understood the emails concerning the need for a license as referring to a license to use the entire Java system, including implementing code.
The district court ruled that in light of the evidence presented at the trial, “our jury could reasonably have concluded that Google’s use of parts of the Java API as an accelerant was undertaken based on a good faith belief that at least the declaring code and SSO were free to use (which it did use), while a license was necessary for the implementing code (which it did not use).” Relatedly, the jury reasonably could have found that “Google acted in good faith by duplicating only the declarations to 37 packages to maintain inter-system consistency in usage and by supplying its own implementing code.”
With respect to “transformativeness,” an issue courts weigh heavily in the fair use analysis, Oracle argued that no jury could reasonably have found Google’s use of the declaring code and SSO from 37 Java packages in Android “imbued the copyrighted works with new expression, meaning, or message.” This is because the copied code served the same function in Android as it did in Java: an interface for accessing methods in both systems.
The district court acknowledged that “the copied declarations serve the same function in both works” because they access methods with the same functions (albeit with different implementing code). Nonetheless, the district court found that “our jury could reasonably have found that (i) Google’s selection of 37 out of 166 Java API packages (ii) re-implemented with new implementing code adapted to the constrained operating environment of mobile smartphone devices with small batteries, and (iii) combined with brand new methods, classes, and packages written by Google for the mobile smartphone platform—all constituted a fresh context giving new expression, meaning or message for the duplicated code,” which was designed for desktop and laptop computers.
The district court stressed that “Android did not merely adopt the Java platform wholesale as part of a broader software platform without changes. Instead, it integrated selected elements, namely declarations from 37 packages to interface with all new implementing code optimized for mobile smartphones and added entirely new Java packages written by Google itself.” On this basis, “our jury could reasonably have concluded that Google’s use of the declaring code and SSO of 37 packages from the desktop platform in a full-stack, open-sourced mobile operating system for smartphones was transformative.”
Second Fair Use Factor: Nature of Work Used
Oracle argued that “because there were countless ways to name and organize the packages in Java and because Google could have used a completely new taxonomy in Android” the jury should have concluded that the process of designing APIs was highly creative and at the core of copyright’s protection. The district court acknowledged that such a conclusion would have been reasonable, “but our jury could reasonably have gone the other way and concluded that the declaring code was not highly creative.” In support of this position, the district court cited witnesses who “emphasized the functional role of the declaring lines of code and their SSO and minimized the ‘creative’ aspect.” The jury “could reasonably have found that, while declaring code and SSO were creative enough to qualify for copyright protection, functional considerations predominated in their design….”
Third Fair Use Factor: Amount Used
The district court noted that “the number of lines duplicated constituted a tiny fraction of one percent of the copyright works (and even less of Android, for that matter).” Moreover, “our jury could reasonably have found that Google duplicated the bare minimum of the 37 API packages, just enough to preserve inter-system consistency in usage, namely the declarations and their SSO only, and did not copy any of the implementing code….”
Fourth Fair Use Factor: Effect of Use on Market
The district court held that the jury could reasonably have found that the use of the declaring code in Android had no impact on the market for the Java API, which was designed for desktop and laptop computers. With respect to Java ME, designed for mobile applications, “our jury could reasonably have found that Java ME eventually declined in revenue just as predicted by Sun before Android was even released, meaning that Android had no further negative impact on Java ME beyond the tailspin already predicted by Sun.”
Additionally, before Android’s release, Sun had made all of the Java APIs available for free pursuant to a “lax” General Public License under the name OpenJDK. “This invited anyone to subset the API.” Further, “anyone could have duplicated, for commercial purposes, the very same 37 packages as wound up in Android with the very same SSO and done so without any fee, subject only to lenient ‘give-back’ conditions of the GPLv2+CE.” Accordingly, although Google didn’t acquire the 37 packages in this manner, “our jury could reasonably have found that Android’s impact on the market for the copyrighted works paralleled what Sun already expected via its OpenJDK.”
The district court concluded that in applying fair use as an “‘equitable rule of reason,’ our jury could reasonably have given weight to the fact that cross-system confusion would have resulted had Google scrambled the SSO and specifications. Java programmers and science and the useful arts were better served by a common set of command-type statements, just as all typists are better served by a common QWERTY keyboard.”
Oracle almost certainly will appeal this order to the Federal Circuit. But given how the district court meticulously found evidence in the record supporting the reasonableness of the jury’s fair use finding, it is hard to imagine that the Federal Circuit will reverse it.
 Oracle also conceded that 62 classes (and some of their methods) dispersed within three of the packages were necessary to write in Java. Oracle stipulated that it was fair use for Google to use these 62 classes.