In 2010, Oracle sued Google over its use of the Java programming language in Google’s Android mobile operating system. Ten years later, in late 2020, oral arguments were heard in the Supreme Court in this case. This article addresses the legal background that existed before Oracle v. Google, the facts of Oracle v. Google, its rulings, and what is at stake, in terms of open source licensing and generally.
The fundamental question in this case relates to the ability an owner of software to protect interface information—that part of a computer program that allows one piece of software to interact with another, rather than the part that performs a function as the intended use of the software.
1. Why this Matters: Software Development Generally
Almost all software developers use a computer programming language to create human-readable “source code.” Source code is then modified by another software program to create an electronic file, called “object code.” Object code is in binary form—consisting of a series of 1’s and 0’s—that can be operated by a computer.
Normally software is comprised of multiple object code files that have been linked together. The main piece of object code uses other files of object code to provide certain functionality. A good example is spell checking software in a word processing software program. The spell check functionality is frequently not built into the main object code file of the word processing program. Instead, when a spell check is needed, the main object code file “calls” a separate spell check object code file for that functionality.
In order for one piece of object code, which we’ll call the “base code,” to use the functionality of another piece of object code, or “library,” logically the base code must know some things about the library, including the following:
(a) The name of the library, in order to invoke the library,
(b) The location of the library,
(c) The commands used to invoke the functionality of the library, as well as the syntax of those commands,
(d) The format that information must be in to enable the library to process the data, i.e., the input syntax, and
(e) The form that information will be in when it is output by the library, i.e., the output syntax.
This information above is typically called “interface information.” It is sometimes called an “Application Programming Interface,” or “API.” In order for the base code to invoke and get needed functionality from the library, relevant parts of this interface information must be placed in or used by the base code.
If the interface information is protected under copyright law, then in order to use the interface information, the developer of the base code must get permission from the copyright owner of the library. If the interface information is not protected by copyright law, or if copyright law otherwise allows its use, then the base code developer does not need permission from the copyright owner to use the interface information, unless some law other than copyright law protects that interface information.
Whether interface information is copyrightable impacts a number of actions frequently taken by developers, including certain types of web scraping and the use of various types of metadata, such as certain XML schemas. It also may impact the scope of various popular open source licenses.
2. Copyright law generally—idea/expression; fair use
Under copyright law, there are two ways that a base code developer has the legal right to use the interface information of the library without the library owner’s permission.
1. If the interface information of the library is not protected under copyright law. This would occur if the interface information falls into the description set out in Section 102(b) of the Copyright Act.
In no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described, explained, illustrated, or embodied in such work.
Section 102(b) sets out what is frequently referred to as the “idea-expression dichotomy.” However, the term “idea-expression dichotomy” does not appear in the Copyright Act. The phrase suggests that something is either an idea or an expression, but not both: a dichotomy.
Much of the jurisprudence related to the determination of whether § 102(b) applies also lends itself to a dichotomy between “expression” versus “idea,” especially when courts rely on the question of whether there was a significant amount of choice available to the creator in doing a particular thing as a determining factor in determining whether an item is “expressive” and therefore protected under copyright law.
However, the Copyright Act itself may not lend itself to the dichotomy between “expressive” and “idea,” especially when the subject matter is software. Can software be both expressive and an idea, or “procedure, process, system, [or] method of operation”? If so, is it protected under copyright or not?
Section 102(a) describes to what and when copyright protections exists. “Copyright protection subsists … in original works of authorship fixed in any tangible medium of expression.” Section 102(b) describes when copyright protection is not available. Therefore, whether or not something is actually “expressive” would seem to have no bearing on whether something fits within the description in Section 102(b). Even if something is “expressive,” copyright protection may not exist if it is an “idea, procedure, process, system, method of operation, concept, principle, or discovery.”
It is also possible that if a work is expressive, then it is protected by copyright, but if is it an “idea, procedure, process, system, method of operation, concept, principle, or discovery” under § 102(b), then the alleged infringer has a defense to use, analogous to the fair use doctrine discussed below.
These distinctions may be important for understanding the differences between Lotus v. Borland and the Federal Circuit decisions in Oracle v. Google, as discussed below.
2. Even if the interface information of the library is protected under copyright law, the use may be authorized as a “fair use” under Section 107 of the Copyright Act.
[T]he fair use of a copyrighted work … for purposes such as criticism, comment, news reporting, teaching…, scholarship, or research, is not an infringement of copyright.
3. Prior State of the Law
Before Oracle v. Google, the most important case in this area was Lotus Development Corp. v. Borland International, Inc. Lotus was the developer of Lotus 1-2-3, a very popular spreadsheet program. Borland was the developer of Quattro Pro, which was competitive replacement for Lotus 1-2-3. Because of the pervasiveness of Lotus 1-2-3 in the software market, Borland attempted to ease user’s transition from Lotus 1-2-3 to Quattro Pro (i) by allowing Quattro Pro users to substitute Quattro Pro’s menu structure with Lotus 1-2-3’s menu structure and (ii) by allowing macros written for use with Lotus 1-2-3 to run on Quattro Pro without modification, which also required the use of Lotus 1-2-3’s menu structure. The District Court, in a number of decisions, held that Borland’s use of Lotus 1-2-3’s menu structure was a copyright infringement.
Reversing the District Court, the First Circuit held that “the Lotus menu command hierarchy was an uncopyrightable ‘method of operation.’” It noted that “[t]he Lotus menu command hierarchy does not merely explain and present Lotus 1-2-3's functional capabilities to the user; it also serves as the method by which the program is operated and controlled.”
The Court also addressed the relation between expressive elements and methods of operation under the Copyright Act.
Accepting the district court's finding that the Lotus developers made some expressive choices in choosing and arranging the Lotus command terms, we nonetheless hold that expression is not copyrightable because it is part of Lotus 1-2-3' s “method of operation.” We do not think that “methods of operation” are limited to abstractions; rather, they are the means by which a user operates something. If specific words are essential to operating something, then they are part of a “method of operation” and, as such, are unprotectable. (emphasis supplied)
The fact that Lotus developers could have designed the Lotus menu command hierarchy differently is immaterial to the question of whether it is a “method of operation.” In other words, our initial inquiry is not whether the Lotus menu command hierarchy incorporates any expression. Rather, our initial inquiry is whether the Lotus menu command hierarchy is a “method of operation.” Concluding, as we do, that users operate Lotus 1-2-3 by using the Lotus menu command hierarchy, and that the entire Lotus menu command hierarchy is essential to operating Lotus 1-2-3, we do not inquire further whether that method of operation could have been designed differently. The “expressive” choices of what to name the command terms and how to arrange them do not magically change the uncopyrightable menu command hierarchy into copyrightable subject matter. (emphasis supplied)
As can be seen, the First Circuit held that it did not matter whether the Lotus 1-2-3 menu structure was expressive or not. If the menu structure constituted a method of operation, then it was not protected by copyright. Whether or not the menu structure was expressive was irrelevant.
Part of the First Circuit’s rationale for this decision is also telling.
That the Lotus menu command hierarchy is a “method of operation” becomes clearer when one considers program compatibility. Under Lotus's theory, if a user uses several different programs, he or she must learn how to perform the same operation in a different way for each program used. For example, if the user wanted the computer to print material, then the user would have to learn not just one method of operating the computer such that it prints, but many different methods. We find this absurd.
4. Oracle v. Google
A. Java Programming Language
In order to understand the decisions in Oracle v. Google, one must have some understanding of the Java programming language. Java has a large number of pre-built pieces of code, each equivalent to a library, which allows a developer to invoke the pre-written code rather than developing that code herself.
Java is organized in a taxonomy, with various “methods” grouped into “classes,” which are in turn grouped into “packages.” “Methods” contain the actual functional programming code. Out of the box, thousands of Java methods are available, allowing a programmer to incorporate functionality into her software program without the need to actually program the functional code. Methods also contain interface information. Each method has a name (which is used to invoke the functionality of the method), a set of commands that may be used to invoke the functionality of the method, an input syntax, an output syntax, and various other parameters. Classes and packages are similar to methods; in order to utilize classes and packages, certain naming and other conventions must be followed.
In order to invoke a method, a programmer must first “declare” the package, class, and method in the programmer’s code, using very specific language that cannot be deviated from. Once declared, in order to invoke or “call” the method, the base code contain an instruction that must use the package, class and method names, plus the information that is to be used by the method.
B. The Dispute
The litigation is over Google’s use of the Java platform in the creation of its Android mobile device software. Oracle owns Java as a result of its purchase of Sun Microsystems, the original developer of Java.
In the creation of Android, it was important to Google to allow the development of Android applications without requiring programmers to learn a new programming language. Google wanted to allow programmers already schooled in Java to write programs using Java standards of programming. However, Google completely rewrote the functional code in all of the Java methods. All parties to the litigation agreed that the rewritten code was not subject to a copyright claim. Therefore, for the most part, Google only copied the names and syntax of a number of Java methods, classes, and packages. A programmer could therefore program an Android application using the same commands and structures used to program in Java.
Google ultimately used the names and syntax of 37 Java packages, 600 classes, and over 6,000 methods. Therefore, even though the underlying functional code was different, the names and syntax of the methods and classes remained the same. It was this identical information that was the subject of Oracle’s copyright claim.
C. District Court Decision
The District Court was faced with the question of whether the use of the same names and syntax for 37 Java packages, over 600 classes, and over 6,000 methods infringed Oracle’s copyright. It would be fair to state, and the court acknowledged, that 6,000 methods and 600 classes could have been implemented in a sufficient number of different ways to treat the totality of all names and syntaxes of the methods and classes as being expressive. The District Court, however, held that the names and syntax were not subject to copyright.
This order holds that, under the Copyright Act, no matter how creative or imaginative a Java method specification may be, the entire world is entitled to use the same method specification (inputs, outputs, parameters) so long as the line-by-line implementations are different. … The method specification is the idea. The method implementation is the expression. No one may monopolize the idea.
To carry out any given function, the method specification [i.e., names and syntax] as set forth in the declaration must be identical under the Java rules (save only for the choices of argument names). Any other declaration [i.e., names and syntax] would carry out some other function. The declaration requires precision. Significantly, when there is only one way to write something, the merger doctrine bars anyone from claiming exclusive copyright ownership of that expression. Therefore, there can be no copyright violation in using the identical declarations. Nor can there be any copyright violation due to the name given to the method (or to the arguments), for under the law, names and short phrases cannot be copyrighted. (emphasis in original)
The District Court therefore holds that material that may be expressed in enough different ways as to be expressive will be held not to be protectable if the material is a method or system. Oracle sought to rely on case law that makes certain taxonomies subject to copyright protection. In distinguishing a taxonomy case, the court noted that “while the overall scheme of file name organization resembles a taxonomy, it is also a command structure for a system or method of operation of the application programming interface.” The court seems to be very clearly in stating that otherwise expressive, copyrightable subject matter is not copyrightable if it is also a system or method. As can be seen, the District Court took a very similar approach to this issue as the First Circuit in Lotus v. Borland.
That a system or method of operation has thousands of commands arranged in a creative taxonomy does not change its character as a method of operation. Yes, it is creative. Yes, it is original. Yes, it resembles a taxonomy. But it is nevertheless a command structure, a system or method of operation — a long hierarchy of over six thousand commands to carry out pre-assigned functions. For that reason, it cannot receive copyright protection — patent protection perhaps — but not copyright protection.
D. First Federal Circuit Decision
The Federal Circuit reversed the District Court almost in its entirety.
[W]e conclude that a set of commands to instruct a computer to carry out desired operations may contain expression that is eligible of copyright protection. … [A]n 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 Federal Circuit seems to have adopted the concept that the limitation on copyright as described in § 102(b) only applies if the item is not expressive in the first place.
The Federal Circuit also states that the application of Section 102(b) is a defense to a copyright claim and not a question of whether copyright is available at all.
In the Ninth Circuit, ... concepts of merger and scenes a faire are affirmative defenses to claims of infringement. EtsHokin, 225 F.3d at 1082; Satava v. Lowry, 323 F.3d 805, 810 n. 3 (9th Cir.2003) (“The Ninth Circuit treats scenes a faire as a defense to infringement rather than as a barrier to copyrightability.”). The Ninth Circuit has acknowledged that “there is some disagreement among courts as to whether these two doctrines figure into the issue of copyrightability or are more properly defenses to infringement.” EtsHokin, 225 F.3d at 1082 (citations omitted). It, nonetheless, has made clear that, in that circuit, these concepts are to be treated as defenses to infringement. Id. (citing Kregos, 937 F.2d at 705 (holding that the merger doctrine relates to infringement, not copyrightability); ReedUnion Corp. v. Turtle Wax, Inc., 77 F.3d 909, 914 (7th Cir.1996) (explaining why the doctrine of scenes a faire is separate from the validity of a copyright)).
The Federal Circuit also expressly rejected Lotus v. Borland.
[T]he Ninth Circuit has not adopted the court's “method of operation” reasoning in Lotus, and we conclude that it is inconsistent with binding precedent. Specifically, we find that Lotus is inconsistent with Ninth Circuit case law recognizing that the structure, sequence, and organization of a computer program is eligible for copyright protection where it qualifies as an expression of an idea, rather than the idea itself. See Johnson Controls, 886 F.2d at 117576. And, while the court in Lotus held “that expression that is part of a `method of operation' cannot be copyrighted,” 49 F.3d at 818, this court — applying Ninth Circuit law — reached the exact opposite conclusion, finding that copyright protects “the expression of [a] process or method,” Atari, 975 F.2d at 839.
The Federal Circuit seems to ask the question of whether code or an abstraction of code is expressive or not. If it is expressive, then Section 102(b) does not apply. The First Circuit in Lotus v. Borland does the reverse. If the code or an abstraction of code qualifies under Section 102(b), then it is not protected under copyright, whether or not it is expressive.
E. Trial on Remand
The Federal Circuit also noted that the issue of fair use was not addressed by the District Court as a result of the District Court’s decision. Accordingly, the case was remanded to the District Court for a trial on the issue of fair use.
At the trial on whether Google’s use of Java was fair use, Google prevailed. The case was once again appealed to the Federal Circuit.
F. Federal Circuit Decision on Fair Use
After an extensive review of the factors to consider in connection with a fair use, the Federal Circuit reversed the jury decision, holding that Google’s use of Java did not constitute fair use, as a matter of law.
The case has now been appealed to the Supreme Court.
5. Why Oracle v. Google Matters
As can be seen from above, the two ways that a developer can use another code’s interface information without permission, § 102(b) and fair use, are now before the Supreme Court.
A. Open Source
Some of the most popular open source software licenses rely on copyright law to determine whether the code that uses the open source must be offered to third parties in source code form, without restrictions on further modification and further distribution, such license terms sometimes known as “copyleft.” If one creates a derivative work, then the license terms apply. If a derivative work is not created, because what has been used by the base code is not subject to copyright, then the copyleft provisions of these open source licenses may not be applicable.
The most well-known of the copyleft licenses are those promulgated by the Free Software Foundation: the GNU Public License and the GNU Affero Public License. However, other open source software licenses also use copyright as its foundation for determining whether the copyleft provisions of those licenses apply, such as the Mozilla Public License and the Eclipse Public License version 1.0.
Fundamentally, what was used by Oracle in the creation of Android is very similar to what must be used by any software that relies on third party software libraries for functionality: the name of the library, the library’s input specification, and its output specification. In the absence of the creation of a derivative work, the reach of the open source licenses that use copyright law to determine whether the copyleft terms apply may be reduced in their scope.
B. Screen Scraping
Data is frequently not protected by copyright law. Data that is publicly available on the internet, or data that is available by virtue of permission from the rights holder, may still not be available if the APIs or other metadata are subject to copyright protection and therefore cannot be copied or used without permission.
In the author’s practice, this issue often comes up in the following scenario. A software company has a dominant position in a particular market. This dominant player has other pieces of software that complement its main offering. That secondary piece of software uses data from the dominant player’s flagship product. A competitor of the dominant player wants to market a software package that is a competitive replacement for the secondary piece of software. The competitor needs to get data from the flagship product, meaning that the competitor needs to use the APIs of the dominant player. The dominant player can thwart the competitor by asserting copyright claims to the APIs.
This relates not only to APIs. It also applies to any metadata that must be shared, including non-public XML schemas, etc.