1. Open Source and the Law of Interfaces:
Implications of Oracle v. Google After
the Federal Circuit Decision
By: Paul H. Arne1,2
In some ways, adulthood is marked by the ability to hold
as true concepts that are seemingly contradictory. The District
Court3
and Federal Circuit4
decisions in Oracle v. Google
(collectively, the “Android litigation”) suggest that there is an
inverse relationship between (i) the rights of a programmer to
utilize interfaces with another software program without infringing
the interface developer’s intellectual property rights and (ii) the
scope of “copyleft” open source licenses. Limiting the rights to
use the interfaces increases the scope of required openness in open
source software. This article will explore the decisions in Oracle
v. Google and this interesting result.
In order to put this issue in context, three concepts must be
understood: (1) how software is built, (2) the law — specifically
legal concepts of derivative works and the idea/expression
dichotomy, and (3) how many of the most important open source
software licenses utilize this law. After addressing each of these
background concepts, this article will address how the Federal
Circuit’s reversal of the District Court in Oracle v. Google
potentially affects the scope of open source licenses.
Understanding the scope of open source licenses is especially
important for software companies that market proprietary software
products but use certain open source components.
1
Paul is the chair of the Technology Transactions Group of Morris,
Manning & Martin, L.L.P. This article does not create an attorney/client
relationship with you and does not provide specific legal advice to you or
your company. Certain legal concepts have not been fully developed and
certain legal issues have been stated as fact for which arguments can be
made to the contrary, due to space constraints. It is provided for
educational purposes only.
2
Copyright © Paul H. Arne, 2014. All rights reserved. Special thanks to
Austin B. Mills for his assistance in preparing this article.
3
Oracle Am., Inc. v. Google Inc., 798 F.Supp.2d 1111 (N.D. Cal. 2011).
4
Oracle Am., Inc. v. Google Inc., 750 F.3d 1339 (Fed. Cir. 2014).

2. -2-
Building Software
Modern software is built in pieces. A classic example is
programming in the Java software development environment. In
Java, generally speaking, “methods” contain the programming
code that is actually executed by a computer. In 2008, according
to the District Court decision in Oracle v. Google, Java contained
over 6,000 pre-written methods that were available for
programmer use in the standard Java development environment.
Programming in Java, as well as other modern programming
development environments, consists of creating code for some
functionality while invoking pre-written code for many other
functions needed for the particular software program.
For the purposes of this article, “base code” refers to that
code that is being written by the programmer, and “library” refers
to the code that has been pre-written. Also, this article assumes
that the base code and library are actually separate electronic files.
The creation of a program by the combination and use of
multiple pieces of code has two important implications.
First, in order for a functional computer program to use
multiple modules or pieces of software code, these multiple
modules must be able to interact with each other. In order for the
base code to invoke the functionality of the library, there must be
some aspects of the base code and library that must be the same.
Typically, the base code must use the name of the library in order
to use the library. The base code must also be able to invoke
specific functionality of the library, which typically means that the
base code must use the name of one or more commands in the
library. The base code must know the required organization — or
syntax — of the information to be passed to the library for
processing. The base code must also know the syntax of the
outputs from the library. In this article, all such information will
be referred to as “interface information.” A library would
therefore consist of “functional code” and “interface information,”
among other things.
Second, the code of the library that actually performs the
functions needed by the base code does not otherwise exist in the

3. -3-
base code. If the functionality had been written in the base code,
then use of the library would not have been necessary.
From the two concepts above, one can see that the
information that must be shared between the base code and the
library is the interface information, rather than the functional code.
Applicable Copyright Law Principles
Several basic principles of copyright law apply in this
context.
First, fundamental to copyright law is the “idea-expression
dichotomy.” The idea-expression dichotomy is codified in the
section of the Copyright Act that describes what a copyright is and
what it covers, Section 102. Section 102(b) provides:
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.5
Generally speaking, the expressive portions of any work
are what receive protection under copyright and not the ideas.
Calling part of a work (such as a computer program) expressive is
a short way of describing the portion of a work that is protected
under copyright law.
The second fundamental aspect of copyright law needed
for this analysis is the concept of a derivative work. The
Copyright Act also defines this concept.
A “derivative work” is a work based upon
one or more preexisting works, such as a
translation, musical arrangement,
dramatization, fictionalization, motion
5
17 U.S.C. § 102(b).

4. -4-
picture version, sound recording, art
reproduction, abridgment, condensation, or
any other form in which a work may be
recast, transformed, or adapted.6
One of the exclusive rights granted to a copyright holder is
the right to create derivative works of the copyrighted work.7
The third concept follows from the two above. One does
not create a derivative work if only the uncopyrightable portions of
the work are used. If one only uses the idea part of another’s
work, then no derivative work is created and no rights are needed
from the other.
Let’s put these three concepts together with the notions of
modern software creation. If a library’s interface information
needed by the base code is expressive and therefore protected
under copyright, then the developer of the base code must receive
permission from the copyright holder of the library in order to use
the library. If a library’s interface information needed by the base
code is not expressive and therefore not protected under copyright,
then the developer of the base code does not need permission from
the copyright holder of the library in order to use the library.
Open Source Licenses
Some of the most popular licenses used in open source
have provisions that attempt to enforce the openness of computer
software. These provisions are frequently called “reciprocal,”
“viral,” or “copyleft” provisions (this article will use “copyleft”).
Generally speaking, there are three copyleft concepts in
these open source licenses. Any licensee of the copyleft software
must: (i) have access to the source code of the software, (ii) be
able to modify the applicable software, and (iii) be able to further
distribute the software. These copyleft provisions will apply not
only to the library but also to the combined work.
6
17 U.S.C. § 101.
7
17 U.S.C. § 106.

5. -5-
Normally, those licenses with copyleft provisions rely on
copyright law to determine when the copyleft provisions are
applicable. If a programmer in creating base code uses a library
that is subject to a copyleft license, then if the programmer must
have a license to one of the exclusive rights of a copyright holder
(i.e., creation of derivative works) in order to use the library, the
copyleft provisions in the open source license for the library must
be obeyed. In order to use the library, a programmer must
therefore license the base code using the copyleft provisions, or the
programmer is not authorized to use the library at all.8
Applying this concept to the conclusions reached about
creation of modern software and the application of copyright law
to a copyleft open source license then results in the following
conclusions. If the interface code of a library licensed under a
copyleft license is expressive, then the use of the interface code
will require the base code to be licensed under the copyleft license.
If, on the other hand, the interface code of a copyleft library is not
expressive, but falls on the idea side of the idea-expression
dichotomy, then the base code is not required to be licensed under
the copyleft license. Whether the interface code is protected under
copyright law as expressive therefore directly impacts the reach of
the open source license.
Differences of Opinion
Different camps of the copyleft open source movement
may have different ideas whether certain kinds of interface
information is protectable under copyright law or not. A good
example of this difference of opinion is between the Free Software
Foundation, the creators of the GNU General Public License
(“GPL”), and The Eclipse Foundation, the keepers of the Eclipse
Public License (“Eclipse License”). This difference is most
specifically felt respecting a specific kind of library: the dynamic
link library or DLL.
8
This analysis assumes that the copyleft license requires that derivatives
be licensed under the copyleft license as well. The analysis is more
nuanced for certain open source licenses, especially the GNU Lesser
General Public License.

6. -6-
Both the GPL and the Eclipse License utilize the test of
whether a derivative work is created to enforce the terms of its
licenses. If a developer’s use of software licensed under the GPL
does not require a license under copyright law, then no license is
required from the GPL, and no copyleft restrictions exit on its use.
The same situation goes for software licensed under the Eclipse
License.
The Free Software Foundation, in its Frequently Asked
Questions, states the following:
Linking a GPL covered work statically or
dynamically with other modules is making a
combined work based on the GPL covered
work. Thus, the terms and conditions of the
GNU General Public License cover the
whole combination.9
In contrast, The Eclipse Foundation states:
Some free software communities say that
linking to their code automatically means
that your program is a derivative work. Is
this the position of the Eclipse Foundation?
No, the Eclipse Foundation interprets the
term "derivative work" in a way that is
consistent with the definition in the U.S.
Copyright Act, as applicable to computer
software. Therefore, linking to Eclipse code
might or might not create a derivative work,
depending on all of the other facts and
circumstances.10
9
Frequently Asked Questions about the GNU Licenses,
https://www.gnu.org/licenses/gpl-faq.html. Does the GPL have different
requirements for statically vs dynamically linked modules with a covered
work?
10
Eclipse Public License (EPL) Frequently Asked Questions.
http://www.eclipse.org/legal/eplfaq.php#DERIV Ques #26.

7. -7-
Facts of Oracle v. Google
This 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.11
The Java platform consists of the Java
development kit, the javac compiler, various class libraries, the
Java virtual machine, and other components.12
The Java
programming language has been made freely available for anyone
to use, without charge.13
In creating Android, Google used 37 Java packages.14
However, the functionality of those packages, contained in the
methods, was completely rewritten by Google.15
This means that
in all Java methods used by Google, all of the program instructions
that actually manipulated data were rewritten. All parties to the
litigation agreed that the rewritten code was not subject to a
copyright claim.16
Under the belief that persons would want some
interoperability with other Java programs, Google left the names of
these 37 packages the same, as well as the syntax required by Java
in order to interoperate. Therefore, even though the underlying
functional code was different, the names and syntax of the
methods and classes remained the same. In effect, Google only
used the interface information portions of Java. It was this
identical information that was the subject of Oracle’s copyright
claim.
The court was then faced with the question of whether the
use of the interface information infringed Oracle’s copyright. The
use of 37 packages means that the naming and syntax of over
6,000 methods and over 600 classes were the same.17
11
Oracle, 2012 U.S. Dist. LEXIS 75896, at *6-7.
12
Id. at *11 n.2.
13
Id. at *25.
14
Id. at *6.
15
Id. at *6-7.
16
Id. at *70.
17
Id. at *13.

8. -8-
Ruling and Implications
Stated simply, the District Court held that the applicable
interface information was not subject to copyright protection,
holding that the applicable interface information fell on the idea
side of the idea-expression dichotomy. The Federal Circuit Court
reversed, holding that the applicable interface information was
protected under copyright law.
There is at least a subset of the world’s programming
community that is surprised by this reversal.
In an unusual decision, an appeals court in
Washington ruled on Friday that Oracle can
copyright application programming
interfaces (APIs) for the Java programming
language. The ruling is a defeat for Google,
which uses the APIs for its Android
software, but also has implications for the
technology industry as a whole, where APIs
— which let computer programs speak to
each other — are considered to be a basic
building tool and outside the scope of
copyright.18
As a lawyer practicing in this area, it makes sense to
understand that a certain portion of the programming community
does not believe that the use of interface information requires a
license from anyone. Our clients, or companies that are being
acquired by our clients, may have some potential issues by the use
of certain interface information that is believed to be appropriate
by the programmer. When software licensed under a copyleft
license is the source of the interface information — especially
when program using the interface information is proprietary — the
business and legal stakes may be even higher.
18
https://gigaom.com/2014/05/09/tech-world-stunned-as-court-rules-
oracle-can-own-apis-google-loses-copyright-appeal/