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.
