Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page1 of 41
`
`IN THE UNITED STATES DISTRICT COURT
`
`FOR THE NORTHERN DISTRICT OF CALIFORNIA
`
`ORACLE AMERICA, INC.,
`Plaintiff,
`
` v.
`GOOGLE INC.,
`Defendant.
` /
`
`No. C 10-03561 WHA
`
`ORDER RE COPYRIGHTABILITY
`OF CERTAIN REPLICATED
`ELEMENTS OF THE
`JAVA APPLICATION
`PROGRAMMING INTERFACE
`
`INTRODUCTION
`This action was the first of the so-called “smartphone war” cases tried to a jury.
`This order includes the findings of fact and conclusions of law on a central question tried
`simultaneously to the judge, namely the extent to which, if at all, certain replicated elements
`of the structure, sequence and organization of the Java application programming interface are
`protected by copyright.
`
`PROCEDURAL HISTORY
`In 2007, Google Inc., announced its Android software platform for mobile devices.
`In 2010, Oracle Corporation acquired Sun Microsystems, Inc., and thus acquired Sun’s interest
`in the popular programming language known as Java, a language used in Android. Sun was
`renamed Oracle America, Inc. Shortly thereafter, Oracle America (hereinafter simply “Oracle”)
`sued defendant Google and accused its Android platform as infringing Oracle’s Java-related
`copyrights and patents.
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page2 of 41
`
`Both Java and Android are complex platforms. Both include “virtual machines,”
`development and testing kits, and application programming interfaces, also known as APIs.
`Oracle’s copyright claim involves 37 packages in the Java API. Copyrightability of the elements
`replicated is the only issue addressed by this order.
`Due to complexity, the Court decided that the jury (and the judge) would best understand
`the issues if the trial was conducted in phases. The first phase covered copyrightability
`and copyright infringement as well as equitable defenses. The second phase covered patent
`infringement. The third phase would have dealt with damages but was obviated by stipulation
`and verdicts.
`For the first phase, it was agreed that the judge would decide issues of copyrightability
`and Google’s equitable defenses and that the jury would decide infringement, fair use, and
`whether any copying was de minimis. Significantly, all agreed that Google had not literally
`copied the software but had instead come up with its own implementations of the 37 API
`packages. Oracle’s central claim, rather, was that Google had replicated the structure, sequence
`and organization of the overall code for the 37 API packages.
`For their task of determining infringement and fair use, the jury was told it should take
`for granted that the structure, sequence and organization of the 37 API packages as a whole
`was copyrightable. This, however, was not a final definitive legal ruling. One reason for this
`instruction was so that if the judge ultimately ruled, after hearing the phase one evidence, that
`the structure, sequence and organization in question was not protectable but was later reversed
`in this regard, the court of appeals might simply reinstate the jury verdict. In this way, the court
`of appeals would have a wider range of alternatives without having to worry about an expensive
`retrial. Counsel were so informed but not the jury.
`Each side was given seventeen hours of “air time” for phase one evidence (not counting
`openings, closings or motion practice). In phase one, as stated, the parties presented evidence
`on copyrightability, infringement, fair use, and the equitable defenses. As to the compilable
`code for the 37 Java API packages, the jury found that Google infringed but deadlocked on the
`follow-on question of whether the use was protected by fair use. As to the documentation for
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`2
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page3 of 41
`
`the 37 Java API packages, the jury found no infringement. As to certain small snippets of code,
`the jury found only one was infringing, namely, the nine lines of code called “rangeCheck.”
`In phase two, the jury found no patent infringement across the board. (Those patents, it should
`be noted, had nothing to do with the subject addressed by this order.) The entire jury portion of
`the trial lasted six weeks.1
`This order addresses and resolves the core premise of the main copyright claims, namely,
`whether the elements replicated by Google from the Java system were protectable by copyright
`in the first place. No law is directly on point. This order relies on general principles of
`copyright law announced by Congress, the Supreme Court and the Ninth Circuit.
`* * *
`Counsel on both sides have supplied excellent briefing and the Court wishes to recognize
`their extraordinary effort and to thank counsel, including those behind the scenes burning
`midnight oil in law libraries, for their assistance.
`SUMMARY OF RULING
`So long as the specific code used to implement a method is different, anyone is free
`under the Copyright Act to write his or her own code to carry out exactly the same function
`or specification of any methods used in the Java API. It does not matter that the declaration or
`method header lines are identical. Under the rules of Java, they must be identical to declare a
`method specifying the same functionality — even when the implementation is different.
`When there is only one way to express an idea or function, then everyone is free to do so and
`no one can monopolize that expression. And, while the Android method and class names could
`have been different from the names of their counterparts in Java and still have worked, copyright
`protection never extends to names or short phrases as a matter of law.
`It is true that the very same functionality could have been offered in Android
`without duplicating the exact command structure used in Java. This could have been done
`
`1 After the jury verdict, the Court granted Oracle’s Rule 50 motion for judgment as a matter of law of
`infringement of eight decompiled computer files, which were literally copied. Google admitted to copying eight
`computer files by decompiling the bytecode from eight Java files into source code and then copying the source
`code. These files were not proven to have ever been part of Android.
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`3
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page4 of 41
`
`by re-arranging the various methods under different groupings among the various classes and
`packages (even if the same names had been used). In this sense, there were many ways to group
`the methods yet still duplicate the same range of functionality.
`But the names are more than just names — they are symbols in a command structure
`wherein the commands take the form
`java.package.Class.method()
`Each command calls into action a pre-assigned function. The overall name tree, of course, has
`creative elements but it is also a precise command structure — a utilitarian and functional set
`of symbols, each to carry out a pre-assigned function. This command structure is a system or
`method of operation under Section 102(b) of the Copyright Act and, therefore, cannot be
`copyrighted. Duplication of the command structure is necessary for interoperability.
`STATEMENT OF FINDINGS
`JAVA AND ANDROID.
`1.
`Java was developed by Sun, first released in 1996, and has become one of the world’s
`most popular programming languages and platforms.2 The Java platform, through the use of a
`virtual machine, enables software developers to write programs that are able to run on different
`types of computer hardware without having to rewrite them for each different type. Programs
`that run on the Java platform are written in the Java language. Java was developed to run on
`desktop computers and enterprise servers.3
`The Java language, like C and C++, is a human-readable language. Code written in
`a human-readable language — “source code” — is not readable by computer hardware.
`
`2 For purposes of this order, the term “Java” means the Java platform, sometimes abbreviated to
`“J2SE,” which includes the Java development kit (JDK), javac compiler, tools and utilities, runtime programs,
`class libraries (API packages), and the Java virtual machine.
`
`3 Rather than merely vet each and every finding and conclusion proposed by the parties, this order has
`navigated its own course through the evidence and arguments, although many of the proposals have found their
`way into this order. Any proposal that has been expressly agreed to by the opposing side, however, shall be
`deemed adopted (to the extent agreed upon) even if not expressly adopted herein. It is unnecessary for this
`order to cite the record for all of the findings herein. In the findings, the phrase “this order finds . . .” is
`occasionally used to emphasize a point. The absence of this phrase, however, does not mean (and should not be
`construed to mean) that a statement is not a finding. All declarative fact statements set forth in the order are
`factual findings.
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`4
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page5 of 41
`
`Only “object code,” which is not human-readable, can be used by computers. Most object code
`is in a binary language, meaning it consists entirely of 0s and 1s. Thus, a computer program
`has to be converted, that is, compiled, from source code into object code before it can run, or
`“execute.” 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.
`The Java language itself is composed of keywords and other symbols and a set of
`pre-written programs to carry out various commands, such as printing something on the screen
`or retrieving the cosine of an angle. The set of pre-written programs is called the application
`programming interface or simply API (also known as class libraries).
`In 2008, the Java API had 166 “packages,” broken into more than six hundred “classes,”
`all broken into over six thousand “methods.” This is very close to saying the Java API had
`166 “folders” (packages), all including over six hundred pre-written programs (classes) to carry
`out a total of over six thousand subroutines (methods). Google replicated the exact names and
`exact functions of virtually all of these 37 packages but, as stated, took care to use different code
`to implement the six thousand-plus subroutines (methods) and six-hundred-plus classes.
`An API is like a library. Each package is like a bookshelf in the library. Each class is
`like a book on the shelf. Each method is like a how-to-do-it chapter in a book. Go to the right
`shelf, select the right book, and open it to the chapter that covers the work you need. As to the
`37 packages, the Java and Android libraries are organized in the same basic way but all of the
`chapters in Android have been written with implementations different from Java but solving the
`same problems and providing the same functions. Every method and class is specified to carry
`out precise desired functions and, thus, the “declaration” (or “header”) line of code stating the
`specifications must be identical to carry out the given function.4
`The accused product is Android, a software platform developed by Google for
`mobile devices. In August 2005, Google acquired Android, Inc., as part of a plan to develop
`a smartphone platform. Google decided to use the Java language for the Android platform.
`
`4 The term “declaration” was used throughout trial to describe the headers (non-implementing code)
`for methods and classes. While “header” is the more technically accurate term, this order will remain consistent
`with the trial record and use “declaration” and “header” interchangeably.
`
`5
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page6 of 41
`
`In late 2005, Google began discussing with Sun the possibility of taking a license to use
`and to adapt the entire Java platform for mobile devices. 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. Google and Sun
`negotiated over several months, but they were unable to reach a deal.
`In light of its inability to reach agreement with Sun, Google decided to use the
`Java language to design its own virtual machine via its own software and to write its
`own implementations for the functions in the Java API that were key to mobile devices.
`Specifically, Google wrote or acquired its own source code to implement virtually all
`the functions of the 37 API packages in question. Significantly, all agree that these
`implementations — which account for 97 percent of the lines of code in the 37 API packages —
`are different from the Java implementations. In its final form, the Android platform also had its
`own virtual machine (the so-called Dalvik virtual machine), built with software code different
`from the code for the Java virtual machine.
`As to the 37 packages at issue, Google believed 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. Code already written in the Java language would, to this extent, run on
`Android and thus achieve a degree of interoperability.
`The Android platform was released in 2007. The first Android phones went on sale
`the following year. Android-based mobile devices rapidly grew in popularity and now comprise
`a large share of the United States market. The Android platform is provided free of charge
`to smartphone manufacturers. Google receives revenue through advertisement whenever a
`consumer uses particular functions on an Android smartphone. For its part, Sun and Oracle
`never successfully developed its own smartphone platform using Java technology.
`All agree that Google was and remains free to use the Java language itself. All agree
`that Google’s virtual machine is free of any copyright issues. All agree that the
`six-thousand-plus method implementations by Google are free of copyright issues.
`The copyright issue, rather, is whether Google was and remains free to replicate the names,
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`6
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page7 of 41
`
`organization of those names, and functionality of 37 out of 166 packages in the Java API, which
`has sometimes been referred to in this litigation as the “structure, sequence and organization” of
`the 37 packages.
`The Android platform has its own API. It has 168 packages, 37 of which are in
`contention. Comparing the 37 Java and Android packages side by side, only three percent
`of the lines of code are the same. The identical lines are those lines that specify the names,
`parameters and functionality of the methods and classes, lines called “declarations” or “headers.”
`In particular, the Android platform replicated the same package, method and class names,
`definitions and parameters of the 37 Java API packages from the Java 2SE 5.0 platform.
`This three percent is the heart of our main copyright issue.
`A side-by-side comparison of the 37 packages in the J2SE 5.0 version of Java versus in
`the Froyo version of Android shows that the former has a total of 677 classes (plus interfaces)
`and 6508 methods wherein the latter has 616 and 6088, respectively. Twenty-one of the
`packages have the same number of classes, interfaces and methods, although, as stated, the
`method implementations differ.
`The three percent of source code at issue includes “declarations.” Significantly, the rules
`of Java dictate the precise form of certain necessary lines of code called declarations, whose
`precise and necessary form explains why Android and Java must be identical when it comes to
`those particular lines of code. That is, since there is only one way to declare a given method
`functionality, everyone using that function must write that specific line of code in the same way.
`The same is true for the “calls,” the commands that invoke the methods. To see why this is so,
`this order will now review some of the key rules for Java programming. This explanation will
`start at the bottom and work its way upward.
`THE JAVA LANGUAGE AND ITS API — IMPORTANT DETAILS.
`2.
`Java syntax includes separators (e.g., {, }, ;), operators (e.g., +, -, *, /, <, >), literal
`values (e.g., 123, ‘x’, “Foo”), and keywords (e.g., if, else, while, return). These elements
`carry precise predefined meanings. Java syntax also includes identifiers (e.g., String,
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`7
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page8 of 41
`
`java.lang.Object), which are used to name specific values, fields, methods, and classes
`as described below.
`These syntax elements are used to form statements, each statement being a single
`command executed by the Java compiler to take some action. Statements are run in the sequence
`written. Statements are commands that tell the computer to do work.
`A method is like a subroutine. Once declared, it can be invoked or “called on” elsewhere
`in the program. When a method is called on elsewhere in the program or in an application,
`“arguments” are usually passed to the method as inputs. The output from the method is known
`as the “return.” An example is a method that receives two numbers as inputs and returns the
`greater of the two as an output. Another example is a method that receives an angle expressed
`in degrees and returns the cosine of that angle. Methods can be much more complicated.
`A method, for example, could receive the month and day and return the Earth’s declination to
`the sun for that month and day.
`A method consists of the method header and the method body. A method header contains
`the name of the method; the number, order, type and name of the parameters used by the method;
`the type of value returned by the method; the checked exceptions that the method can throw;
`and various method modifiers that provide additional information about the method. At the trial,
`witnesses frequently referred to the method header as the “declaration.” This discrepancy has no
`impact on the ultimate analysis. The main point is that this header line of code introduces the
`method body and specifies very precisely its inputs, name and other functionality. Anyone who
`wishes to supply a method with the same functionality must write this line of code in the same
`way and must do so no matter how different the implementation may be from someone else’s
`implementation.
`The method body is a block of code that then implements the method. If a method is
`declared to have a return type, then the method body must have a statement and the statement
`must include the expression to be returned when that line of code is reached. During trial, many
`witnesses referred to the method body as the “implementation.” It is the method body that does
`the heavy lifting, namely the actual work of taking the inputs, crunching them, and returning an
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`8
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page9 of 41
`
`answer. The method body can be short or long. Google came up with its own implementations
`for the method bodies and this accounts for 97 percent of the code for the 37 packages.
`Once the method is written, tested and in place, it can be called on to do its work.
`A method call is a line of code somewhere else, such as in a different program that calls on
`(or invokes) the method and specifies the arguments to be passed to the method for crunching.
`The method would be called on using the command format “java.package.Class.method()”
`where () indicates the inputs passed to the method. For example,
`a = java.package.Class.method() would set the field “a” to equal the return of the method called.
`(The words “java.package.Class.method” would in a real program be other names like
`“java.lang.Math.max”; “java.package.Class.method” is used here simply to explain the format.)
`After a method, the next higher level of syntax is the class. A class usually includes
`fields that hold values (such as pi = 3.141592) and methods that operate on those values.
`Classes are a fundamental structural element in the Java language. A Java program is written as
`one or more classes. More than one method can be in a class and more than one class can be in a
`package. All code in a Java program must be placed in a class. A class declaration (or header) is
`a line that includes the name of the class and other information that define the class. The body of
`the class includes fields and methods, and other parameters.
`Classes can have subclasses that “inherit” the functionality of the class itself. When a
`new subclass is defined, the declaration line uses the word “extends” to alert the compiler that
`the fields and methods of the parent class are inherited automatically into the new subclass so
`that only additional fields or methods for the subclass need to be declared.
`The Java language does not allow a class to extend (be a subclass of) more than one
`parent class. This restrictiveness may be problematic when one class needs to inherit fields
`and methods from two different non-related classes. The Java programming language alleviates
`this dilemma through the use of “interfaces,” which refers to something different from the word
`“interface” in the API acronym. An interface is similar to a class. It can also contain methods.
`It is also in its own source code file. It can also be inherited by classes. The distinction is that a
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`9
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page10 of 41
`
`class may inherit from more than one interface whereas, as mentioned, a class can only inherit
`from one other class.
`For convenience, classes and interfaces are grouped into “packages” in the same way we
`all group files into folders on our computers. There is no inheritance function within packages;
`inheritance occurs only at the class and interface level.
`Here is a simple example of source code that illustrates methods, classes and packages.
`The italicized comments on the right are merely explanatory and are not compiled:
`
`package java.lang;
`public class Math {
`public static int max (int x, int y) {
`if (x > y) return x ;
`else return y ;
`
`}
`
`}
`
`// Declares package java.lang
`// Declares class Math
`// Declares method max
`// Implementation, returns x or
`// Implementation, returns y
`// Closes method
`// Closes class
`
`To invoke this method from another program (or class), the following call could be included in
`the program:
`
`int a = java.lang.Math.max (2, 3);
`Upon reaching this statement, the computer would go and find the max method under the Math
`class in the java.lang package, input “2” and “3” as arguments, and then return a “3,” which
`would then be set as the value of “a.”
`The above example illustrates a point critical to our first main copyright issue, namely
`that the declaration line beginning “public static” is entirely dictated by the rules of the language.
`In order to declare a particular functionality, the language demands that the method declaration
`take a particular form. There is no choice in how to express it. To be specific, that line reads:
`public static int max (int x, int y) {
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`10
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page11 of 41
`
`The word “public” means that other programs can call on it. (If this instead says “private,”
`then it can only be accessed by other methods inside the same class.) The word “static” means
`that the method can be invoked without creating an instance of the class. (If this instead is an
`instance method, then it would always be invoked with respect to an object.) The word “int”
`means that an integer is returned by the method. (Other alternatives are “boolean,” “char,”
`and “String” which respectively mean “true/false,” “single character,” and “character string.”)
`Each of these three parameters is drawn from a short menu of possibilities, each possibility
`corresponding to a very specific functionality. The word “max” is a name and while any name
`(other than a reserved word) could have been used, names themselves cannot be copyrighted, as
`will be shown. The phrase “(int x, int y)” identifies the arguments that must be passed into the
`method, stating that they will be in integer form. The “x” and the “y” could be “a” and “b” or
`“arg1” and “arg2,” so there is a degree of creativity in naming the arguments. Again, names
`cannot be copyrighted. (Android did not copy all of the particular argument names used in Java
`but did so as to some arguments.) Finally, “{” is the beginning marker that tells the compiler
`that the method body is about to follow. The marker is mandatory. The foregoing description
`concerns the rules for the language itself. Again, each parameter choice other than the names
`has a precise functional choice. If someone wants to implement a particular function, the
`declaration specification can only be written in one way.
`Part of the declaration of a method can list any exceptions. When a program violates
`the semantic constraints of the Java language, the Java virtual machine will signal this error to
`the program as an exception for special handling. These are specified via “throw” statements
`appended at the end of a declaration. Android and Java are not identical in their throw
`designations but they are very similar as to the 37 packages at issue.
`A Java program must have at least one class. A typical program would have more
`than one method in a class. Packages are convenient folders to organize the classes.
`This brings us to the application programming interface. When Java was first introduced
`in 1996, the API included eight packages of pre-written programs. At least three of these
`packages were “core” packages, according to Sun, fundamental to being able to use the Java
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`11
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page12 of 41
`
`language at all. These packages were java.lang, java.io, and java.util. As a practical matter,
`anyone free to use the language itself (as Oracle concedes all are), must also use the three core
`packages in order to make any worthwhile use of the language. Contrary to Oracle, there is no
`bright line between the language and the API.
`Each package was broken into classes and those in turn broken into methods.
`For example, java.lang (a package) included Math (a class) which in turn included max
`(a method) to return the greater of two inputs, which was (and remains) callable as
`java.lang.Math.max with appropriate arguments (inputs) in the precise form required
`(see the example above).
`After Java’s introduction in 1996, Sun and the Java Community Process, a mechanism
`for developing a standard specifications for Java classes and methods, wrote hundreds more
`programs to carry out various nifty functions and they were organized into coherent packages
`by Sun to become the Java application programming interface. In 2008, as stated, the Java API
`had grown from the original eight to 166 packages with over six hundred classes with
`over six thousand methods. All of it was downloadable from Sun’s (now Oracle’s) website
`and usable by anyone, including Java application developers, upon agreement to certain license
`restrictions. Java was particularly useful for writing programs for use via the Internet and
`desktop computers.
`Although the declarations must be the same to achieve the same functionality, the names
`of the methods and the way in which the methods are grouped do not have to be the same.
`Put differently, many different API organizations could supply the same overall range of
`functionality. They would not, however, be interoperable. Specifically, code written for one
`API would not run on an API organized differently, for the name structure itself dictates the
`precise form of command to call up any given method.
`To write a fresh program, a programmer names a new class and adds fields and methods.
`These methods can call upon the pre-written functions in the API. Instead of re-inventing the
`wheels in the API from scratch, programmers can call on the tried-and-true pre-packaged
`programs in the API. These are ready-made to perform a vast menu of functions. This is the
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`12
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page13 of 41
`
`whole point of the API. For example, a student in high school can write a program that can call
`upon java.lang.Math.max to return the greater of two numbers, or to find the cosine of an angle,
`as one step in a larger homework assignment. Users and developers can supplement the API
`with their own specialized methods and classes.
`The foregoing completes the facts necessary to decide the copyrightability issue but since
`Oracle has made much of two small items copied by Google, this order will now make findings
`thereon so that there will be proper context for the court of appeals.
`3.
`RANGECHECK AND THE DE-COMPILED TEST FILES.
`Oracle has made much of nine lines of code that crept into both Android and Java.
`This circumstance is so innocuous and overblown by Oracle that the actual facts, as found
`herein by the judge, will be set forth below for the benefit of the court of appeals.
`Dr. Joshua Bloch worked at Sun from August 1996 through July 2004, eventually
`holding the title of distinguished engineer. While working at Sun, Dr. Bloch wrote a nine-line
`code for a function called “rangeCheck,” which was put into a larger file, “Arrays.java,” which
`was part of the class library for the 37 API packages at issue. The function of rangeCheck was
`to check the range of a list of values before sorting the list. This was a very simple function.
`In 2004, Dr. Bloch left Sun to work at Google, where he came to be the “chief Java
`architect” and “Java guru.” Around 2007, Dr. Bloch wrote the files, “Timsort.java” and
`“ComparableTimsort,” both of which included the same rangeCheck function he wrote while
`at Sun. He wrote the Timsort files in his own spare time and not as part of any Google project.
`He planned to contribute Timsort and ComparableTimsort back to the Java community by
`submitting his code to an open implementation of the Java platform, OpenJDK, which was
`controlled by Sun. Dr. Bloch did, in fact, contribute his Timsort file to OpenJDK and Sun
`included Timsort as part of its Java J2SE 5.0 release.
`In 2009, Dr. Bloch worked on Google’s Android project for approximately one year.
`While working on the Android team, Dr. Bloch also contributed Timsort and
`ComparableTimsort to the Android platform. Thus, the nine-line rangeCheck function
`was copied into Google’s Android. This was how the infringement happened to occur.
`
`1 2 3 4 5 6 7 8 9
`
`10
`11
`12
`13
`14
`15
`16
`17
`18
`19
`20
`21
`22
`23
`24
`25
`26
`27
`28
`
`13
`
`For the Northern District of California
`
`United States District Court
`
`

`
`Case3:10-cv-03561-WHA Document1202 Filed05/31/12 Page14 of 41
`
`When discovered, the rangeCheck lines were taken out of the then-current version of