In May, the United States Court of Appeals for the Federal Circuit issued a decision in Oracle America, Inc. v. Google, Inc., holding that certain aspects of Oracle’s Java software were copyrightable. The case dealt with several different pieces of code alleged to be infringed, but of particular interest is the appellate court’s analysis of the copyrightability of 37 packages of application programming interfaces, “API packages,” and of the verbatim copying by Google of nine lines of Java code.
No Small Amount of Software Can Be Copied Without Risking Infringement
One of the items that Google was alleged to have infringed upon was Oracle’s copyright in nine lines of code that made up a discrete function in the Android program. The district court found that the two engineers that had originally written the Java code later worked for Google and contributed the nine lines of code to the Android platform.
Google argued that its verbatim copying of those nine lines of code was too insignificant to amount to infringement on its own. To put it in perspective, the copied code was only nine lines out of 2,800,000 (approximately .000321% of the code) in the various Java packages at issue (a subset of the entire Java platform, of which it would be a far smaller percentage).
However, the appellate court rejected that argument, stating that there is no “minimum number of lines of code that must be copied before a court can find infringement.” This may prove to be very useful to software developers contending that a third party has copied their code, and very frustrating to defendants accused of copying a few lines of code in a much larger program. If there is no copying too small to be infringing, it may make it much easier for copyright holders to bring a cognizable claim asserting that a small amount of code was copied by a third party.
Structure, Sequence and Organization of Code Can Be Protected
A major issue in the case was whether Google had infringed Oracle’s copyright by copying the “declaring source code” and the “structure, sequence and organization” (SSO) of the 37 API packages. Essentially the API packages are code that allows computers to execute common tasks and communicate with each other. The “declaring code” is the language that identifies the pre-written function – namely, it’s the code used by the programmer to call up the API and to command the computer to execute associated “implementing code,” which carries the more detailed instructions for the specific function.
Google developed the Android platform, which included 168 API packages, and had its own implementing code. However, as part of the 168 API Packages, Google used 37 API packages that corresponded to the existing JAVA API packages. The district court provided the analogy that “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.” In total, Google copied about 7,000 lines of declaring source code from the corresponding 37 Java API packages including the “elaborately organized taxonomy of all the names of methods, classes, interfaces, and packages.”
This system of taxonomy was referred to by the court as the “structure, sequence and organization” (SSO) of the 37 API packages. Software, by its nature, conflates the distinction between words and function. This appears to be the root of the dispute between Oracle and Google with regard to the 37 API packages. In broad strokes, one of Google’s arguments was that the simple commonplace words used to create these 37 API packages that identify and trigger each specific function are precluded from copyright protection as “functional” or an unprotectable “system.” Under Section 102(b) of the Copyright Act, copyright does not extend to any “system” or “method of operation.” Essentially, among other arguments, Google asserted that because this code was a language already known by programmers, which served the utilitarian feature of calling up the implementing code and allowing the programs to communicate with each other, it should not be subject to copyright.
The court, however, disagreed with Google and held this “structure, sequence and organization” of the 37 API packages was copyrightable. The court reasoned that because “the SSO is original and creative, and that the declaring code could have been written and organized in any number of ways and still have achieved the same functions, we conclude that [the Copyright Act] does not bar the packages from copyright protection just because they also perform functions.”
The appellate court sent the case back to the trial court to determine whether Google’s use was nonetheless allowed as fair use. It will be interesting to see how this plays out. The Federal Circuit’s decision is a very strong decision in favor of copyright protection for software. It may still be that Google is able to assert a successful fair use defense with regard to the 37 API packages. Even if it is, though, this decision will make it easier for copyright holders to assert claims of infringement arising out of software, more easily get the case before a jury (and past summary judgment), and force defendants to rely on a fact-intensive fair use defense. It may also slow the adoption of standardized APIs, since a developer is more likely to be able to assert that its APIs are proprietary and cannot be used by another entity. In the near term, this ruling is likely to cause more litigation asserting copyright infringement of software, drive up costs for the creation of new software, and strengthen claims of copyright holders.
We just sent you an email. Please click the link in the email to confirm your subscription!
OKSubscriptions powered by Strikingly