United States Court of Appeals
`for the Federal Circuit
`______________________
`
`
`
`
`
`
`
`
`
`
`ORACLE AMERICA, INC.,
`Plaintiff-Appellant,
`
`v.
`
`GOOGLE INC.,
`Defendant-Cross-Appellant.
`______________________
`
`2013-1021, -1022
`______________________
`
`Appeals from the United States District Court for the
`Northern District of California in No. 10-CV-3561, Judge
`William H. Alsup.
`______________________
`
`Decided: May 9, 2014
`______________________
`
`
`E. JOSHUA ROSENKRANZ, Orrick, Herrington & Sut-
`cliffe LLP, of New York, New York, argued for plaintiff-
`appellant. With him on the brief were MARK S. DAVIES,
`ANDREW D. SILVERMAN, KELLY M. DALEY; and ANNETTE L.
`HURST, GABRIEL M. RAMSEY, and ELIZABETH C. MCBRIDE,
`of San Francisco, California. Of counsel on the brief were
`DORIAN E. DALEY, DEBORAH K. MILLER, MATTHEW
`SARBORARIA, and ANDREW C. TEMKIN, Oracle America,
`Inc., of Redwood Shores, California; and DALE M.
`CENDALI, DIANA M. TORRES, SEAN B. FERNANDES, and
`JOSHUA L. SIMMONS, Kirkland & Ellis LLP, of New York,
`New York. Of counsel were SUSAN M. DAVIES, Kirkland &
`
`

`
`2
`
`
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`Ellis LLP, of New York, New York; MICHAEL A. JACOBS,
`Morrison & Foerster LLP, of San Francisco, California;
`and KENNETH A. KUWAYTI, of Palo Alto, California.
`
`ROBERT A. VAN NEST, Keker & Van Nest LLP, of San
`Francisco, California, argued
`for defendant-cross-
`appellant. With him on the brief were CHRISTA M.
`ANDERSON, STEVEN A. HIRSCH, MICHAEL S. KWUN, and
`DANIEL E. JACKSON. Of counsel on the brief were IAN C.
`BALLON and HEATHER MEEKER, Greenberg Traurig, LLP,
`of East Palo Alto, California; RENNY HWANG, Google Inc.,
`of Mountain View, California; and DARYL L. JOSEFFER and
`BRUCE W. BABER, King & Spalding LLP, of Washington,
`DC.
`
`MARCIA B. PAUL, Davis Wright Tremaine LLP, of New
`York, New York, for amicus curiae Ralph Oman. With
`her on the brief were LACY H. KOONCE, III and DEBORAH
`A. ADLER.
`
`WILLIAM A. RUDY, Lathrop & Gage LLP, of Kansas
`City, Missouri, for amici curiae Picture Archive Council of
`America, Inc., et al. With him on the brief were CAROLE
`E. HANDLER and BRIANNA E. DAHLBERG, of Los Angeles,
`California.
`
`GREGORY G. GARRE, Latham & Watkins, LLP, of
`Washington, DC, for amici curiae Microsoft Corporation,
`et al. With him on the brief was LORI ALVINO MCGILL. Of
`counsel on the brief were PAUL T. DACIER, KRISHNENDU
`GUPTA, EMC Corporation, of Hopkinton, Massachusetts;
`and DOUGLAS LUFTMAN, NETAPP, Inc., of Sunnyvale,
`California.
`
`JARED BOBROW, Weil, Gotshal & Manges LLP, of
`Redwood Shores, California, for amici curiae Eugene H.
`Spafford, Ph.D., et al. With him on the brief was AARON
`Y. HUANG.
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`3
`
`
`MATTHEW S. HELLMAN, Jenner & Block LLP, of Wash-
`ington, DC, for amicus curiae BSA/The Software Alliance.
`With him on the brief was PAUL M. SMITH.
`
`STEVEN T. COTTREAU, Clifford Chance US LLP, of
`Washington, DC, for amici curiae, Scott McNealy, et al.
`
`MEREDITH JACOB, Program on Information Justice
`and Intellectual Property, American University, Washing-
`ton College of Law, of Washington, DC, for amici curiae
`Intellectual Property Law Professors.
`
`JULIE P. SAMUELS, Electronic Frontier Foundation, of
`San Francisco, California, for amici curiae Computer
`Scientists. With her on the brief was MICHAEL BARCLAY.
`Of counsel on the brief was JASON M. SCHULTZ, NYU
`Technology Law and Policy Clinic, NYU School of Law, of
`New York, New York.
`
`JONATHAN BAND, Jonathan Band PLLC, of Washing-
`ton, DC, filed a brief for amicus curiae Computer & Com-
`munications Industry Association. With him on the brief
`was MATTHEW SCHRUERS, Computer & Communications
`Industry Association, of Washington, DC.
`
`CHAD RUBACK, The Ruback Law Firm, of Dallas, Tex-
`as, filed a brief for amici curiae Rackspace US, Inc., et al.
`
`JENNIFER M. URBAN, Samuelson Law, Technology and
`Public Policy Clinic, U.C. Berkeley School of Law, of
`Berkeley, California for amici curiae Software Innovators,
`et al.
`
`______________________
`
`Before O’MALLEY, PLAGER, and TARANTO, Circuit Judges.
`
`

`
`4
`
`
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`O’MALLEY, Circuit Judge.
`This copyright dispute involves 37 packages of com-
`puter source code. The parties have often referred to
`these groups of computer programs, individually or collec-
`tively, as “application programming interfaces,” or API
`packages, but it is their content, not their name, that
`matters. The predecessor of Oracle America, Inc. (“Ora-
`cle”) wrote these and other API packages in the Java
`programming language, and Oracle licenses them on
`various terms for others to use. Many software develop-
`ers use the Java language, as well as Oracle’s API pack-
`ages, to write applications (commonly referred to as
`“apps”)
`for desktop and
`laptop computers, tablets,
`smartphones, and other devices.
`Oracle filed suit against Google Inc. (“Google”) in the
`United States District Court for the Northern District of
`California, alleging that Google’s Android mobile operat-
`ing system infringed Oracle’s patents and copyrights. The
`jury found no patent infringement, and the patent claims
`are not at issue in this appeal. As to the copyright claims,
`the parties agreed that the jury would decide infringe-
`ment, fair use, and whether any copying was de minimis,
`while the district judge would decide copyrightability and
`Google’s equitable defenses. The jury found that Google
`infringed Oracle’s copyrights in the 37 Java packages and
`a specific computer routine called “rangeCheck,” but
`returned a noninfringement verdict as to eight decompiled
`security files. The jury deadlocked on Google’s fair use
`defense.
`After the jury verdict, the district court denied Ora-
`cle’s motion for judgment as a matter of law (“JMOL”)
`regarding fair use as well as Google’s motion for JMOL
`with respect to the rangeCheck files. Order on Motions
`for Judgment as a Matter of Law, Oracle Am., Inc. v.
`Google Inc., No. 3:10-cv-3561 (N.D. Cal. May 10, 2012),
`ECF No. 1119. Oracle also moved for JMOL of infringe-
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`5
`
`ment with respect to the eight decompiled security files.
`In granting that motion, the court found that: (1) Google
`admitted to copying the eight files; and (2) no reasonable
`jury could find that the copying was de minimis. Oracle
`Am., Inc. v. Google Inc., No. C 10-3561, 2012 U.S. Dist.
`LEXIS 66417 (N.D. Cal. May 11, 2012) (“Order Granting
`JMOL on Decompiled Files”).
`Shortly thereafter, the district court issued its deci-
`sion on copyrightability, finding that the replicated ele-
`ments of the 37 API packages—including the declaring
`code and the structure, sequence, and organization—were
`not subject to copyright protection. Oracle Am., Inc. v.
`Google Inc., 872 F. Supp. 2d 974 (N.D. Cal. 2012) (“Copy-
`rightability Decision”). Accordingly, the district court
`entered final judgment in favor of Google on Oracle’s
`copyright infringement claims, except with respect to the
`rangeCheck code and the eight decompiled files. Final
`Judgment, Oracle Am., Inc. v. Google Inc., No. 3:10-cv-
`3561 (N.D. Cal. June 20, 2012), ECF No. 1211. Oracle
`appeals from the portion of the final judgment entered
`against it, and Google cross-appeals from the portion of
`that same judgment entered in favor of Oracle as to the
`rangeCheck code and eight decompiled files.
`Because we conclude that the declaring code and the
`structure, sequence, and organization of the API packages
`are entitled to copyright protection, we reverse the district
`court’s copyrightability determination with instructions to
`reinstate the jury’s infringement finding as to the 37 Java
`packages. Because the jury deadlocked on fair use, we
`remand for further consideration of Google’s fair use
`defense in light of this decision. With respect to Google’s
`cross-appeal, we affirm the district court’s decisions:
`(1) granting Oracle’s motion for JMOL as to the eight
`decompiled Java files that Google copied into Android;
`and (2) denying Google’s motion for JMOL with respect to
`the rangeCheck function. Accordingly, we affirm-in-part,
`reverse-in-part, and remand for further proceedings.
`
`

`
`6
`
`
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`BACKGROUND
`A. The Technology
`Sun Microsystems, Inc. (“Sun”) developed the Java
`“platform” for computer programming and released it in
`1996.1 The aim was to relieve programmers from the
`burden of writing different versions of their computer
`programs for different operating systems or devices. “The
`Java platform, through the use of a virtual machine,
`enable[d] software developers to write programs that
`[we]re able to run on different types of computer hard-
`ware without having to rewrite them for each different
`type.” Copyrightability Decision, 872 F. Supp. 2d at 977.
`With Java, a software programmer could “write once, run
`anywhere.”
`The Java virtual machine (“JVM”) plays a central role
`in the overall Java platform. The Java programming
`language itself—which includes words, symbols, and
`other units, together with syntax rules for using them to
`create instructions—is the language in which a Java
`programmer writes source code, the version of a program
`that is “in a human-readable language.” Id. For the
`instructions to be executed, they must be converted (or
`compiled) into binary machine code (object code) consist-
`ing of 0s and 1s understandable by the particular compu-
`ting device. In the Java system, “source code is first
`converted into ‘bytecode,’ an intermediate form, before it
`is then converted into binary machine code by the Java
`virtual machine” that has been designed for that device.
`Id. The Java platform includes the “Java development kit
`(JDK), javac compiler, tools and utilities, runtime pro-
`grams, class libraries (API packages), and the Java virtu-
`al machine.” Id. at 977 n.2.
`
`
`1 Oracle acquired Sun in 2010.
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`7
`
`Sun wrote a number of ready-to-use Java programs to
`perform common computer functions and organized those
`programs into groups it called “packages.” These packag-
`es, which are the application programming interfaces at
`issue in this appeal, allow programmers to use the pre-
`written code to build certain functions into their own
`programs, rather than write their own code to perform
`those functions from scratch. They are shortcuts. Sun
`called the code for a specific operation (function) a “meth-
`od.” It defined “classes” so that each class consists of
`specified methods plus variables and other elements on
`which the methods operate. To organize the classes for
`users, then, it grouped classes (along with certain related
`“interfaces”) into “packages.” See id. at 982 (describing
`organization: “[e]ach package [i]s broken into classes and
`those in turn [are] broken into methods”). The parties
`have not disputed the district court’s analogy: Oracle’s
`collection of API packages is like a library, each package
`is like a bookshelf in the library, each class is like a book
`on the shelf, and each method is like a how-to chapter in a
`book. Id. at 977.
`The original Java Standard Edition Platform (“Java
`SE”) included “eight packages of pre-written programs.”
`Id. at 982. The district court found, and Oracle concedes
`to some extent, that three of those packages—java.lang,
`java.io, and java.util—were “core” packages, meaning that
`programmers using the Java language had to use them
`“in order to make any worthwhile use of the language.”
`Id. By 2008, the Java platform had more than 6,000
`methods making up more than 600 classes grouped into
`166 API packages. There are 37 Java API packages at
`issue in this appeal, three of which are the core packages
`identified by the district court.2 These packages contain
`
`
`2 The 37 API packages involved in this appeal are:
`java.awt.font,
`java.beans,
`java.io,
`java.lang,
`ja-
`
`

`
`8
`
`
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`thousands of individual elements, including classes,
`subclasses, methods, and interfaces.
`Every package consists of two types of source code—
`what
`the parties
`call
`(1) declaring
`code;
`and
`(2) implementing code. Declaring code is the expression
`that identifies the prewritten function and is sometimes
`referred to as the “declaration” or “header.” As the dis-
`trict court explained, the “main point is that this header
`line of code introduces the method body and specifies very
`precisely the inputs, name and other functionality.” Id. at
`979-80. The expressions used by the programmer from
`the declaring code command the computer to execute the
`associated implementing code, which gives the computer
`the step-by-step instructions for carrying out the declared
`function.
`To use the district court’s example, one of the Java
`API packages at issue is “java.lang.” Within that package
`is a class called “math,” and within “math” there are
`several methods, including one that is designed to find the
`larger of two numbers: “max.” The declaration for the
`“max” method, as defined for integers, is: “public static int
`max(int x, int y),” where the word “public” means that the
`method is generally accessible, “static” means that no
`
`va.lang.annotation,
`java.lang.ref,
`java.lang.reflect,
`ja-
`va.net, java.nio, java.nio.channels, java.nio.channels.spi,
`java.nio.charset,
`java.nio.charset.spi,
`java.security,
`ja-
`va.security.acl, java.security.cert, java.security.interfaces,
`java.security.spec,
`java.sql,
`java.text,
`java.util,
`ja-
`va.util.jar,
`java.util.logging,
`java.util.prefs,
`ja-
`va.util.regex,
`java.util.zip,
`javax.crypto,
`javax.crypto.interfaces,
`javax.crypto.spec,
`javax.net,
`javax.net.ssl,
`javax.security.auth,
`ja-
`vax.security.auth.callback,
`javax.security.auth.login,
`javax.security.auth.x500,
`javax.security.cert, and
`ja-
`vax.sql.
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`9
`
`specific instance of the class is needed to call the method,
`the first “int” indicates that the method returns an inte-
`ger, and “int x” and “int y” are the two numbers (inputs)
`being compared. Copyrightability Decision, 872 F. Supp.
`2d at 980-82. A programmer calls the “max” method by
`typing the name of the method stated in the declaring
`code and providing unique inputs for the variables “x” and
`“y.” The expressions used command the computer to
`execute the implementing code that carries out the opera-
`tion of returning the larger number.
`Although Oracle owns the copyright on Java SE and
`the API packages, it offers three different licenses to those
`who want to make use of them. The first is the General
`Public License, which is free of charge and provides that
`the licensee can use the packages—both the declaring and
`implementing code—but must “contribute back” its inno-
`vations to the public. This arrangement is referred to as
`an “open source” license. The second option is the Specifi-
`cation License, which provides that the licensee can use
`the declaring code and organization of Oracle’s API pack-
`ages but must write its own implementing code. The
`third option is the Commercial License, which is for
`businesses that “want to use and customize the full Java
`code in their commercial products and keep their code
`secret.” Appellant Br. 14. Oracle offers the Commercial
`License in exchange for royalties. To maintain Java’s
`“write once, run anywhere” motto, the Specification and
`Commercial Licenses require that the licensees’ programs
`pass certain tests to ensure compatibility with the Java
`platform.
`The testimony at trial also revealed that Sun was li-
`censing a derivative version of the Java platform for use
`on mobile devices: the Java Micro Edition (“Java ME”).
`Oracle licensed Java ME for use on feature phones and
`smartphones. Sun/Oracle has never successfully devel-
`oped its own smartphone platform using Java.
`
`

`
`
`
` 10
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`B. Google’s Accused Product: Android
`The accused product is Android, a software platform
`that was designed for mobile devices and competes with
`Java in that market. Google acquired Android, Inc. in
`2005 as part of a plan to develop a smartphone platform.
`Later that same year, Google and Sun began discussing
`the possibility of Google “taking a license to use and to
`adapt the entire Java platform for mobile devices.” Copy-
`rightability Decision, 872 F. Supp. 2d at 978. They also
`discussed a “possible co-development partnership deal
`with Sun under which Java technology would become an
`open-source part of the Android platform, adapted for
`mobile devices.” Id. The parties negotiated for months
`but were unable to reach an agreement. The point of
`contention between the parties was Google’s refusal to
`make the implementation of its programs compatible with
`the Java virtual machine or interoperable with other Java
`programs. Because Sun/Oracle found that position to be
`anathema to the “write once, run anywhere” philosophy,
`it did not grant Google a license to use the Java API
`packages.
`When the parties’ negotiations reached an impasse,
`Google decided to use the Java programming language to
`design its own virtual machine—the Dalvik virtual ma-
`chine (“Dalvik VM”)—and “to write its own implementa-
`tions for the functions in the Java API that were key to
`mobile devices.” Id. Google developed the Android plat-
`form, which grew to include 168 API packages—37 of
`which correspond to the Java API packages at issue in
`this appeal.
`With respect to the 37 packages at issue, “Google be-
`lieved Java application programmers would want to find
`the same 37 sets of functionalities in the new Android
`system callable by the same names as used in Java.” Id.
`To achieve this result, Google copied the declaring source
`code from the 37 Java API packages verbatim, inserting
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`11
`
`that code into parts of its Android software. In doing so,
`Google copied the elaborately organized taxonomy of all
`the names of methods, classes, interfaces, and packages—
`the “overall system of organized names—covering 37
`packages, with over six hundred classes, with over six
`thousand methods.” Copyrightability Decision, 872 F.
`Supp. 2d at 999. The parties and district court referred
`to this taxonomy of expressions as the “structure, se-
`quence, and organization” or “SSO” of the 37 packages. It
`is undisputed, however, that Google wrote its own imple-
`menting code, except with respect to: (1) the rangeCheck
`function, which consisted of nine lines of code; and
`(2) eight decompiled security files.
`As to rangeCheck, the court found that the Sun engi-
`neer who wrote it later worked for Google and contributed
`two files he created containing the rangeCheck function—
`“Timsort.java” and “ComparableTimsort”—to the Android
`platform. In doing so, the nine-line rangeCheck function
`was copied directly into Android. As to the eight decom-
`piled files, the district court found that they were copied
`and used as test files but “never found their way into
`Android or any handset.” Id. at 983.
`Google released the Android platform in 2007, and the
`first Android phones went on sale the following year.
`Although it is undisputed that certain Android software
`contains copies of the 37 API packages’ declaring code at
`issue, neither the district court nor the parties specify in
`which programs those copies appear. Oracle indicated at
`oral argument, however, that all Android phones contain
`copies of the accused portions of the Android software.
`Oral Argument at 1:35, available at http://www.
`cafc.uscourts.gov/oral-argument-recordings/2013-1021/all.
`Android smartphones “rapidly grew in popularity and
`now comprise a large share of the United States market.”
`Copyrightability Decision, 872 F. Supp. 2d at 978. Google
`provides the Android platform
`free of charge to
`smartphone manufacturers and receives revenue when
`
`

`
`
`
` 12
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`customers use particular functions on the Android phone.
`Although Android uses the Java programming language,
`it is undisputed that Android is not generally Java com-
`patible. As Oracle explains, “Google ultimately designed
`Android to be incompatible with the Java platform, so
`that apps written for one will not work on the other.”
`Appellant Br. 29.
`C. Trial and Post-Trial Rulings
`Beginning on April 16, 2012, the district court and the
`jury—on parallel tracks—viewed documents and heard
`testimony from twenty-four witnesses on copyrightability,
`infringement, fair use, and Google’s other defenses.
`Because the parties agreed the district court would decide
`copyrightability, the court instructed the jury to assume
`that the structure, sequence, and organization of the 37
`API packages was copyrightable. And, the court informed
`the jury that Google conceded that it copied the declaring
`code used in the 37 packages verbatim. The court also
`instructed the jury that Google conceded copying the
`rangeCheck function and the eight decompiled security
`files, but that Google maintained that its use of those
`lines of code was de minimis. See Final Charge to the
`Jury (Phase One), Oracle Am., Inc. v. Google Inc., 3:10-cv-
`3561 (N.D. Cal. Apr. 30, 2012), ECF No. 1018 at 14 (“With
`respect to the
`infringement
`issues concerning the
`rangeCheck and other similar files, Google agrees that
`the accused lines of code and comments came from the
`copyrighted material but contends that the amounts
`involved were so negligible as to be de minimis and thus
`should be excused.”).
`On May 7, 2012, the jury returned a verdict finding
`that Google infringed Oracle’s copyright in the 37 Java
`API packages and in the nine lines of rangeCheck code,
`but returned a noninfringement verdict as to eight de-
`compiled security files. The jury hung on Google’s fair use
`defense.
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`13
`
`The parties filed a number of post-trial motions, most
`of which were ultimately denied. In relevant part, the
`district court denied Oracle’s motion for JMOL regarding
`fair use and Google’s motion for JMOL as to the
`rangeCheck files. Order on Motions for Judgment as a
`Matter of Law, Oracle Am., Inc. v. Google Inc., No. 3:10-
`cv-3561 (N.D. Cal. May 10, 2012), ECF No. 1119. The
`district court granted Oracle’s motion for JMOL of in-
`fringement as to the eight decompiled files, however. In
`its order, the court explained that: (1) Google copied the
`files in their entirety; (2) the trial testimony revealed that
`the use of those files was “significant”; and (3) no reason-
`able jury could find the copying de minimis. Order Grant-
`ing JMOL on Decompiled Files, 2012 U.S. Dist. LEXIS
`66417, at *6.
`On May 31, 2012, the district court issued the prima-
`ry decision at issue in this appeal, finding that the repli-
`cated elements of the Java API packages—including the
`declarations and their structure, sequence, and organiza-
`tion—were not copyrightable. As to the declaring code,
`the court concluded that “there is only one way to write”
`it, and thus the “merger doctrine bars anyone from claim-
`ing exclusive copyright ownership of that expression.”
`Copyrightability Decision, 872 F. Supp. 2d at 998. The
`court further found that the declaring code was not pro-
`tectable because “names and short phrases cannot be
`copyrighted.” Id. As such, the court determined that
`“there can be no copyright violation in using the identical
`declarations.” Id.
`As to the overall structure, sequence, and organiza-
`tion of the Java API packages, the court recognized that
`“nothing in the rules of the Java language . . . required
`that Google replicate the same groupings even if Google
`was free to replicate the same functionality.” Id. at 999.
`Therefore, the court determined that “Oracle’s best argu-
`ment . . . is that while no single name is copyrightable,
`Java’s overall system of organized names—covering 37
`
`

`
`
`
` 14
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`packages, with over six hundred classes, with over six
`thousand methods—is a ‘taxonomy’ and, therefore, copy-
`rightable.” Id.
`Although it acknowledged that the overall structure of
`Oracle’s API packages is creative, original, and “resem-
`bles a taxonomy,” the district court found that it “is
`nevertheless a command structure, a system or method of
`operation—a long hierarchy of over six thousand com-
`mands to carry out pre-assigned functions”—that is not
`entitled to copyright protection under Section 102(b) of
`the Copyright Act. Id. at 999-1000. In reaching this
`conclusion, the court emphasized that, “[o]f the 166 Java
`packages, 129 were not violated in any way.” Id. at 1001.
`And, of the 37 Java API packages at issue, “97 percent of
`the Android lines were new from Google and the remain-
`ing three percent were freely replicable under the merger
`and names doctrines.” Id. On these grounds, the court
`dismissed Oracle’s copyright claims, concluding that “the
`particular elements replicated by Google were free for all
`to use under the Copyright Act.” Id.
`On June 20, 2012, the district court entered final
`judgment in favor of Google and against Oracle on its
`claim for copyright infringement, except with respect to
`the rangeCheck function and the eight decompiled files.
`As to rangeCheck and the decompiled files, the court
`entered judgment for Oracle and against Google in the
`amount of zero dollars, per the parties’ stipulation. Final
`Judgment, Oracle Am., Inc. v. Google Inc., No. 3:10-cv-
`3561 (N.D. Cal. June 20, 2012), ECF No. 1211. Oracle
`timely appealed from the portion of the district court’s
`final judgment entered against it and Google timely cross-
`appealed with respect to rangeCheck and the eight de-
`compiled files. Because this action included patent
`claims, we have jurisdiction pursuant to 28 U.S.C.
`§ 1295(a)(1).
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`15
`
`DISCUSSION
`I. ORACLE’S APPEAL
`It is undisputed that the Java programming language
`is open and free for anyone to use. Except to the limited
`extent noted below regarding three of the API packages, it
`is also undisputed that Google could have written its own
`API packages using the Java language. Google chose not
`to do that. Instead, it is undisputed that Google copied
`7,000 lines of declaring code and generally replicated the
`overall structure, sequence, and organization of Oracle’s
`37 Java API packages. The central question before us is
`whether these elements of the Java platform are entitled
`to copyright protection. The district court concluded that
`they are not, and Oracle challenges that determination on
`appeal. Oracle also argues that the district court should
`have dismissed Google’s fair use defense as a matter of
`law.
`According to Google, however, the district court cor-
`rectly determined that: (1) there was only one way to
`write the Java method declarations and remain “interop-
`erable” with Java; and (2) the organization and structure
`of the 37 Java API packages is a “command structure”
`excluded from copyright protection under Section 102(b).
`Google also argues that, if we reverse the district court’s
`copyrightability determination, we should direct the
`district court to retry its fair use defense.
`“When the questions on appeal involve law and prece-
`dent on subjects not exclusively assigned to the Federal
`Circuit, the court applies the law which would be applied
`by the regional circuit.” Atari Games Corp. v. Nintendo of
`Am., Inc., 897 F.2d 1572, 1575 (Fed. Cir. 1990). Copyright
`issues are not exclusively assigned to the Federal Circuit.
`See 28 U.S.C. § 1295. The parties agree that Ninth Cir-
`cuit law applies and that, in the Ninth Circuit, whether
`particular expression is protected by copyright law is
`
`

`
`
`
` 16
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`“subject to de novo review.” Ets-Hokin v. Skyy Spirits,
`Inc., 225 F.3d 1068, 1073 (9th Cir. 2000).3
`
`
`3 The Supreme Court has not addressed whether
`copyrightability is a pure question of law or a mixed
`question of law and fact, or whether, if it is a mixed
`question of law and fact, the factual components of that
`inquiry are for the court, rather than the jury. Relatedly,
`it has not decided the standard of review that applies on
`appeal. Ten years ago, before finding it unnecessary to
`decide whether copyrightability is a pure question of law
`or a mixed question of law and fact, the Seventh Circuit
`noted that it had “found only a handful of appellate cases
`addressing the issue, and they are split.” Gaiman v.
`McFarlane, 360 F.3d 644, 648 (7th Cir. 2004). And,
`panels of the Ninth Circuit have defined the respective
`roles of the jury and the court differently where questions
`of originality were at issue. Compare North Coast Indus.
`v. Jason Maxwell, Inc., 972 F.2d 1031, 1035 (9th Cir.
`1992), with Ets-Hokin, 225 F.3d at 1073. More recently,
`several district courts within the Ninth Circuit have
`treated copyrightability as a question for only the court,
`regardless of whether it is a pure question of law. See
`Stern v. Does, No. 09-1986, 2011 U.S. Dist. LEXIS 37735,
`*7 (C.D. Cal. Feb. 10, 2011); Jonathan Browning, Inc. v.
`Venetian Casino Resort LLC, No. C 07-3983, 2009 U.S.
`Dist. LEXIS 57525, at *2 (N.D. Cal. June 19, 2009); see
`also Pivot Point Int’l, Inc. v. Charlene Prods., Inc., 932 F.
`Supp. 220, 225 (N.D. Ill. 1996) (Easterbrook, J.) (citing to
`Markman v. Westview Instruments, Inc., 517 U.S. 370
`(1996), and concluding that whether works are copyright-
`able is a question which the “jury has nothing to do
`with”). We need not address any of these questions,
`because the parties here agreed that the district court
`would decide copyrightability, and both largely agree that
`
`

`
`ORACLE AMERICA, INC. v. GOOGLE INC.
`
`17
`
`We are mindful that the application of copyright law
`in the computer context is often a difficult task. See Lotus
`Dev. Corp. v. Borland Int’l, Inc., 49 F.3d 807, 820 (1st Cir.
`1995) (Boudin, J., concurring) (“Applying copyright law to
`computer programs is like assembling a jigsaw puzzle
`whose pieces do not quite fit.”). On this record, however,
`we find that the district court failed to distinguish be-
`tween the threshold question of what is copyrightable—
`which presents a low bar—and the scope of conduct that
`constitutes infringing activity. The court also erred by
`importing fair use principles, including interoperability
`concerns, into its copyrightability analysis.
`For the reasons that follow, we conclude that the de-
`claring code and the structure, sequence, and organiza-
`tion of the 37 Java API packages are entitled to copyright
`protection. Because there is an insufficient record as to
`the relevant fair use factors, we remand for further pro-
`ceedings on Google’s fair use defense.
`A. Copyrightability
`The Copyright Act provides protection to “original
`works of authorship fixed in any tangible medium of
`expression,”
`including “literary works.”
` 17 U.S.C.
`§ 102(a). It is undisputed that computer programs—
`defined in the Copyright Act as “a set of statements or
`instructions to be used directly or indirectly in a computer
`in order to bring about a certain result,” 17 U.S.C.
`§ 101—can be subject to copyright protection as “literary
`works.” See Atari Games Corp. v. Nintendo of Am., Inc.,
`975 F.2d 832, 838 (Fed. Cir. 1992) (“As literary works,
`copyright protection extends to computer programs.”).
`Indeed, the legislative history explains that “literary
`works” includes “computer programs to the extent that
`
`
`we may undertake a review of that determination de
`novo.
`
`

`
`
`
` 18
`
` ORACLE AMERICA, INC. v. GOOGLE INC.
`
`they incorporate authorship in the programmer’s expres-
`sion of original ideas, as distinguished from the ideas
`themselves.” H.R. Rep. No. 1476, 94th Cong., 2d Sess. 54,
`reprinted in 1976 U.S.C.C.A.N. 5659, 5667.
`By statute, a work must be “original” to qualify for
`copyright protection. 17 U.S.C. § 102(a). This “originality
`requirement is not particularly stringent,” however. Feist
`Publ’ns, Inc. v. Rural Tel. Serv. Co., 499 U.S. 340, 358
`(1991). “Or