Oracle II: Looking for Takeaways
If you want to skip the background and history of this case, scroll down to "Takeaways."
Baltimore, Maryland ∙ May 23, 2018
On March 27, 2018, the United States Court of Appeals for the Federal Circuit released its long-awaited opinion in the case of Oracle Am., Inc. v. Google LLC (which we shall call “Oracle II”). The Federal Circuit reversed two 2016 rulings by the U.S. District Court for the Northern District of California in favor of Google. The Federal Circuit found that Google’s copying and use of the declaring code and the structure, sequence and organization (“SSO”) of 37 application programming interfaces (“APIs”) in the Java programming platform, all copyrighted by Oracle, was not defensible under the legal doctrine of “fair use.” This doctrine excuses certain uses of copyrighted material, based on judicial application of various statutory and caselaw factors. Following an exhaustive review of the case, the lower court’s rulings, applicable precedent and the jury’s verdict in favor of fair use, the Federal Circuit concluded that “Google's use of the declaring code and SSO of the 37 API packages was not fair as a matter of law.”
If you are coming into this case with no preconceived notions, you might well read the court’s 56-page opinion and conclude that is a fact-centric ruling that is specific to Google, Oracle and 37 Java API packages. If you have read any of the many alarming articles about Oracle II, you might believe that copyrighted code is now “off-limits,” even if the copier’s only objective is to ensure compatibility across platforms. Neither perspective is entirely right or wrong, but in the end, the first take is the more accurate one. Because of the conflicting, circular and sometimes contradictory nature of the statutory fair use factors and judicial application thereof, fair use cases generally don’t provide precise clarity for future cases. Oracle II is no exception. Despite this, the Federal Circuit’s opinion does offer a few “takeaways” for software developers and other interested observers of copyright law.
What Google Did
First, a quick review of the facts.
Oracle's Java platform allows programmers to write programs that “run on different types of computer hardware without having to rewrite them for each different type” giving rise to the phrase “write once, run anywhere.” Java application programming interfaces (“APIs”) “allow programmers to use [ ] prewritten [Java] code to build certain functions into their own programs rather than write their own code to perform those functions from scratch.” An “API package” is a “collection of classes and each class contains methods and other elements.” To incorporate a Java API into her own program, “a programmer invokes the Java ‘declaring code,’ the line or lines of source code that declares or defines (i) the method name and (ii) the input(s) and their type as expected by the method and the type of any outputs." In addition to declaring code, “each method includes ‘implementing code,’ which takes the input(s) and gives the computer step-by-step instructions to carry out the declared function.”
While Oracle made the Java platform “freely available to programmers building applications… Oracle charges a licensing fee to those who want to use the APIs in a competing platform or embed them in an electronic device.” Oracle also offered a version called of Java called “OpenJDK”, which was open source. However, as with many open source platforms, “any company that improved on the packages in OpenJDK had to give away those changes for free to the Java community.” By 2005, Java had become “the leading platform for developing and running apps on mobile phones.” At issue in the litigation are 37 API packages from Java SE Version 1.4 and Version 5.0.
At the same time, Google acquired Android in order to develop its own software platform for mobile phones, and began negotiating with Sun Microsystems (which created Java) over the terms of a license by which Google could adapt Java into Android for the development of mobile phone applications. The parties could not agree on a license, however, “in part because Google wanted device manufacturers to be able to use Oracle's [Java] APIs in Android for free with no limits on modifying the code, which would jeopardize the ‘write once, run anywhere’ philosophy.”
Feeling pressure to accelerate introduction of the Android platform (and desirable applications to run on that platform) into the exploding market for mobile phones, Google was anxious to “attract Java developers to build apps for Android.” Although Google “had been working on creating its own APIs [for Android], [it] was unable to do so successfully. Therefore, when negotiations failed, Google elected to “[d]o Java anyway and defend [its] decision, perhaps making enemies along the way.” Specifically, “Google copied verbatim the declaring code of the 37 Java API packages—11,500 lines of Oracle's copyrighted code [as well as] the SSO of the Java API packages.” However, Google did write its own implementing code.
Google released the first version of Android in 2007, and the first Android phones hit stores in 2008. Google provides Android to smartphone manufacturers free of charge and publishes the source code for use by developers under an open source license. Although Google does not directly charge anyone for using it, “Android has generated over $42 billion in revenue from advertising.” At trial, Oracle testified that “Android was ‘devastating’ to its licensing strategy and that many of its customers switched to Android. Oracle also testified that “[e]ven customers who stayed with Oracle cited Android as a reason to demand discounts.” For example, “Amazon, which had entered into a license to use Java for its Kindle tablet device, switched to Android for the subsequently released Kindle Fire and then used the existence of Android to leverage a steep discount from Oracle on the next generation Kindle.”
In summary, Google used Oracle’s copyrighted Java APIs to attract developers who were familiar with those APIs into developing applications for use on Google’s competing (but incompatible) platform (Android), thereby shortening Android’s development cycle and time-to-market at a critical stage in the growth of the market for mobile device applications.
Oracle I: Java APIs Are Protected by Copyright
The court’s holdings in Oracle II can’t be fully understood without the context provided by the Federal Circuit’s 2014 opinion in the initial appeal Oracle brought before the court, Oracle Am., Inc. v. Google Inc., 750 F.3d 1339 (Fed. Cir. 2014)(“Oracle I”). There, the Federal Circuit concluded that the declaring code and the SSO of the 37 Java API packages at issue were entitled to copyright protection, reversing the initial decision of the district court, which found that the code and SSO were not copyrightable. Google’s fair use defense was considered but remanded to the district Court for further factfinding (setting up Oracle II).
The district court had found that the declaring code was not copyrightable because, in the Java programming language, “there was only one way to write the declaring code for each of the Java packages.” Therefore, in copyright law terms, the idea (the method declared) and its expression (the declaring code itself) merged into one, and the declaring code was rendered non-copyrightable: because methods per se are not subject to copyright. For the district court, the Java declaring code was the method, and the corresponding implementing code was the expression. In this paradigm, only the implementing code was subject to copyright; but in this case Google had written its own implementing code.
The Federal Circuit rejected this “merger” theory, noting that “[t]his was not a situation where Oracle was selecting among preordained names and phrases to create its packages.” In other words, there was more than one way to write the declaring code, so the way Oracle (through Sun) wrote it was copyrightable: “merger cannot bar copyright protection for any lines of declaring source code unless Sun/Oracle had only one way, or a limited number of ways, to write them.” Furthermore, “nothing prevented Google from writing its own declaring code, along with its own implementing code, to achieve the same result” as Oracle had done, so that “the chosen expression [Oracle’s declaring code] simply does not merge with the idea being expressed.”
The district court found that the SSO of the Java API packages was “a system or method of operation… and therefore, cannot be copyrighted.” But the Federal Circuit rejected the notion that a system or method of operation can never be copyrighted: “although an element of a work may be characterized as a method of operation, that element may nevertheless contain expression that is eligible for copyright protection.” Here, Oracle’s SSO—“a command structure, a system or method of operation—a long hierarchy of over six thousand commands to carry out pre-assigned functions”—was copyrightable because, although functional, it was also expressive in that there were multiple ways in which to accomplish that function in the Java language. “[A] set of commands to instruct a computer to carry out desired operations may contain expression that is eligible for copyright protection.”
The court noted that “if we were to accept… that a computer program is uncopyrightable simply because it carries out pre-assigned functions, no computer program is protectable,” and that this conclusion “contradicts Congress’s express intent to provide copyright protection to computer programs….” Further, “Google could have structured Android differently and could have chosen different ways to express and implement the functionality that it copied.” In siding with Oracle and reversing the Northern District, the Federal Circuit rejected the application of Lotus Development Corp. v. Borland International, Inc., 49 F.3d 807 (1st Cir. 1995), a First Circuit decision in which it was held that “elements which perform a function can never be copyrightable.”
The district court found that Oracle’s SSO was “a method of operation” and that “duplication of the command structure was necessary for interoperability” with that functional method. Google’s copying of Oracle’s SSO was fair because “Google replicated what was necessary to achieve a degree of interoperability—but no more….”
The district court relied on two Ninth Circuit cases—Sega and Sony—which, it found, were “close analogies” to the case before it, and dictated that “interface procedures that were necessary to duplicate in order to achieve interoperability were functional aspects not copyrightable under Section 102(b) [of the Copyright Act].” In Sega, the Ninth Circuit found fair use where defendant reverse-engineered console video games to discover the hidden key to interoperability set up by the console manufacturers to limit the creation of games by independent developers; and in Sony, that same court found fair use where defendant reverse-engineered a game console manufacturer’s software in order to design its own software to let consumers play those same games on their personal computers.
According to the Federal Circuit, however, Sega and Sony explored fair use, not copyrightability. Further, both cases were distinguishable because “the defendants in those cases made intermediate copies to understand the functional aspects of the copyrighted works and then created new products.” Google by contrast, did not “reverse engineer the programming packages to gain access to unprotected functional elements contained therein” but instead “chose to copy both the declaring code and the overall SSO of the 37 Java API packages at issue.”
Google would have done better to “reverse engineer the programming packages to figure out the ideas and functionality of the original, and then create its own structure and its own literal code….” For the Federal Circuit, Sega and Sony were more limited in scope than the district court believed. “Although both cases recognized that the software programs at issue there contained unprotected functional elements, a determination that some elements are unprotected is not the same as saying that the entire work loses copyright protection.”
The Federal Circuit further questioned the district court’s focus on the claimed interoperability of Android with Java. “[T]he relevant compatibility inquiry asks whether the plaintiff’s choices were dictated by a need to ensure that its program worked with existing third-party programs” not “[w]hether a defendant later seeks to make its program interoperable with the plaintiff’s program….” Accordingly, “the district court erred in focusing its interoperability analysis on Google’s desires for its Android software” because “[w]hether Google’s software is interoperable in some sense with any aspect of the Java platform… has no bearing on the threshold question of whether Oracle’s software is copyrightable” and “there is no evidence that when Oracle created the Java API packages at issue it did so to meet compatibility requirements of other pre-existing programs.”
The court also found Google’s interoperability argument “confusing” because “Google designed Android so that it would not be compatible with the Java platform….” Instead, Google wanted to capitalize on the fact that software developers were already trained and experienced in using the Java API packages at issue.” The court did allow that “this competitive objective might be relevant to the fair use inquiry….”
Finally, the court rejected Google’s suggestion “that it was entitled to copy the Java API packages because they had become the effective industry standard…” because “the Ninth Circuit has rejected the argument that a work that later becomes the industry standard is uncopyrightable.” “Google was free to develop its own API packages and to lobby programmers to adopt them”, the court wrote. “Instead, [Google] chose to copy Oracle’s declaring code and the SSO to capitalize on the preexisting community of programmers who were accustomed to using the Java API packages.”
After exploring the four factors of the fair use defense in great detail, the Federal Circuit concluded that, because material disputes of fact remained, remanding fair use to the District Court was appropriate. Among those remaining material disputes: (1) whether Google’s use was “transformative… under a correct reading of the law.” (even at this stage, the court considered Google’s views on transformative use to be overly-expansive); (2) whether “functional aspects of the packages” and “Google’s competitive desire to achieve commercial interoperability” were relevant to fair use. The court also wondered whether certain “core” API packages were “necessary for anyone to copy if they are to write programs in the Java language” and whether any of the packages “were similarly essential components of any Java-based program.” Finally, the court asked whether and to what extent “when Google copied the API packages, Oracle was licensing in the mobile and smartphone markets” and whether “Android’s release substantially harmed those commercial opportunities as well as the potential market for a Java smartphone device.”
Oracle II: Does Google Have a Valid Fair Use Defense
On remand from Oracle I, the district court bifurcated the issue of fair use from the issue of damages. The court then presided over a lengthy trial on the issue of fair use, after which the jury determined that Google’s use of the Java APIs was a fair use. Oracle filed a motion for judgment as a matter of law (“JMOL”), arguing that the jury could not have reached its verdict lawfully, and a motion for a new trial, but the court denied both motions and entered judgement against Oracle on June 8, 2016. Oracle then filed an appeal with the Federal Circuit from the district court’s judgment and rulings on the motions, which appeal became Oracle II.
Fair Use: The Four Factors
The Federal Circuit’s opinion in Oracle II begins with a recitation of fair use law. Under section 107 of the Copyright Act, 17 USC § 107, et seq., courts may permit the use of copyrighted material by someone other than the copyright holder, on a case-by-case basis, if that use is found to be a “fair use.” Determining whether there is a “fair use” depends on the court’s consideration of statutory fair use examples and a non-exhaustive list of statutory factors, in addition to any other factors courts deem relevant.
Section 107 lists “criticism, comment, news reporting, teaching (including multiple copies for classroom use), scholarship, or research” as illustrative fair uses. In practice, however, even these uses are not always found to be fair. Court must consider the four statutory factors (really, more like six):
(1) the purpose and character of the use, including whether such use is of a commercial nature or is for nonprofit educational purposes; Courts have amplified this factor by also asking whether the use is “transformative”;
(2) the nature of the copyrighted work (most commonly, is the work creative or merely functional);
(3) the amount and substantiality of the portion used in relation to the copyrighted work as a whole; and
(4) the effect of the use upon the potential market for or value of the copyrighted work.
In addition, “[t]he fact that a work is unpublished shall not itself bar a finding of fair use if such finding is made upon consideration of all the above factors.” With all of these factors in play, and no procedure for balancing them, small wonder it is that the outcomes in fair use cases can seem (and perhaps simply are) maddeningly unpredictable.
I. Nature of the Use
a. Commercial Purpose
The Federal Circuit found that there was a commercial purpose behind Google’s copying; but also found this factor to be of limited importance. “Use of the copyrighted work that is commercial tends to weigh against a finding of fair use,” the court found, but then cautioned “[s]ince many, if not most, secondary users seek at least some measure of commercial gain from their use, unduly emphasizing the commercial motivation of a copier will lead to an overly restrictive view of fair use.” The court noted that “the fact that Android is free of charge does not make Google's use of the Java API packages noncommercial” because “although Google maintains that its revenue flows from advertisements, not from Android, commerciality does not depend on how Google earns its money… [d]irect economic benefit is not required to demonstrate a commercial use."
b. Transformative Use
More important for the court was whether Google’s use of the API packages was transformative in nature. “To be transformative, a secondary work must either alter the original with new expression, meaning, or message or serve a new purpose distinct from that of the original work.” The district court had found “Google's selection of some, but not all, of the Java API packages—with new implementing code adapted to the constrained operating environment of mobile smartphone devices, together with new methods, classes, and packages written by Google for the mobile smartphone platform—constituted a fresh context giving new expression, meaning, or message to the duplicated code.”
In a critical break with the district court, the Federal Circuit rejected this “fresh context” finding. Brushing aside Google’s argument that “although the declarations and SSO may perform the same functions in Android and Java, the jury could reasonably find that they have different purposes because the point of Android was to create a groundbreaking platform for smartphones," the court found that Google's use of the API packages was not transformative because:
Google’s use of the API packages did not match any of the specific statutory examples of fair use;
The purpose behind Google’s use of the API packages in Android was the same as for Oracle’s use of the packages in Java;
Google made no alteration to the expressive content or message of the API packages; and
Google use of the API packages in the smartphone context was not new or otherwise transformative.
In sum, “[t]he fact that Google created exact copies of the declaring code and SSO and used those copies for the same purpose as the original material seriously weakens [the] claimed fair use,” and “merely copying the material and moving it from one platform to another without alteration is not transformative.”
The court credited Oracle’s claim the API packages were already being used in the smartphone context when Google went to copy them:
[T]he record showed that Java SE APIs were in smartphones before Android entered the market. Specifically, Oracle presented evidence that Java SE was in SavaJe mobile phones and that Oracle licensed Java SE to other smartphone manufacturers, including Danger and Nokia. Because the Java SE was already being used in smartphones, Google did not "transform" the copyrighted material into a new context and no reasonable jury could conclude otherwise.
As we shall see, this finding not only torpedoed Google’s argument on factor 1, the “purpose and character of the use,” but also hamstrung its claim on factor 3, “amount and substantiality.”
II. Nature of the Copyrighted Work
Under fair use law, “creative expression” receives greater protection than “factual works.” The court found that although “the 37 API packages at issue involved some level of creativity… reasonable jurors could have concluded that functional considerations were both substantial and important,” which tended to support fair use. However, as with commercial purpose, the court then noted that nature of the work “typically has not been terribly significant in the overall fair use balancing…” and that “allowing this one factor to dictate a conclusion of fair use in all cases involving copying of software could effectively negate Congress's express declaration—continuing unchanged for some forty years—that software is copyrightable.”
III. Amount and Substantiality of the Portion Used
The third factor in the fair use analysis “looks to the quantitative amount and qualitative value of the original work used in relation to the justification for its use.”
Although “this factor will not weigh against an alleged infringer, even when he copies the whole work, if he takes no more than is necessary for his intended use,” that is only true “where the intended use was a transformative one, because the extent of permissible copying varies with the purpose and character of the use.” The court reiterated that “Google's use was not transformative and Google has conceded both that it could have written its own APIs and that the purpose of its copying was to make Android attractive to programmers.”
The court cited a couple metrics to demonstrate the extent of the materials Google copied. Noting that “only 170 lines of code were necessary to write in the Java language,” the court underscored “that Google copied 11,500 lines of code—11,330 more lines than necessary to write in Java.” Using this narrow view of interoperability, the court easily concluded “[t]hat Google copied more than necessary weighs against fair use.” The court also rejected the import of Google’s observation “that it used a small percentage of Java (11,500 lines of declarations out of roughly 2.86 million lines of code in the Java SE libraries)” because Google “copied the SSO for the 37 API packages in its entirety.”
The court chastened Google for claiming the interoperability high ground. “As we noted in the prior appeal… Google did not seek to foster any "inter-system consistency" between its platform and Oracle's Java platform.” Rather, “Google sought to capitalize on the fact that software developers were already trained and experienced in using the Java API packages at issue.” The court then rejected Google’s economic efficiency argument, finding that even though “it was a sound business practice for Google to leverage the existing community of [Java] developers, minimizing the amount of new material and maximizing existing knowledge… Google also conceded that it could have written the APIs differently to achieve the same functions.”
In sum, the court found “that the third factor is, at best, neutral in the fair use inquiry, and arguably weighs against such a finding.”
IV. Impact on the Potential Market
The fourth factor includes both “harm to the actual or potential market for the copyrighted work, but also harm to the market for potential derivative uses, including those that creators of original works would in general develop or license others to develop.” Put another way, “a copyright holder has the exclusive right to determine when, whether and in what form to release the copyrighted work into new markets, whether on its own or via a licensing agreement.” Thus, if Google’s copying injured the actual market for Oracle’s code, or even a potential market which Oracle may have wished to enter, Oracle prevails on the fourth factor.
The District Court ruled that “the jury could reasonably have found that use of the declaring lines of code (including their SSO) in Android caused no harm to the market for the copyrighted works, which were for desktop and laptop computers.” In another sharp break with the lower court, the Federal Circuit ruled that no reasonable jury could have made these findings, since “Java SE had been used for years in mobile devices, including early smartphones, prior to Android's release… [and] Android competed directly with Java SE in the market for mobile devices….” The court recounted evidence from trial showing that Google won over the right to install Android on Amazon’s Kindle tablets, which had previously shipped with a mobile version of Java called SavaJE. “Given this evidence of actual market harm, “no reasonable jury could have concluded that there was no market harm to Oracle from Google's copying.”
But even if Oracle was not actually in the market for mobile devices, the district court “should have considered how Google's copying affected potential markets Oracle might enter or derivative works it might create or license others to create.” Finally, “the fact that Oracle and Google engaged in lengthy licensing negotiations demonstrates that Oracle was attempting to license its work for mobile devices, including smartphones. Smartphones were, therefore, a "traditional, reasonable, or likely to be developed market." In the Federal Circuit’s estimation, Google was doubly-damned on the fourth factor: it usurped Oracle’s actual and potential position in the market for mobile devices.
Balancing the Four Factors
Fair use law doesn’t specify how a court is meant to balance its findings on the four factors. Left to its own devices, courts generally wrap up their opinions with a ‘balancing’ section, wherein each court reveals how it saw the law and the facts coming together, and which factors ultimately controlled the outcome.
For the Federal Circuit, two factors seem to have been critical: (1) Google’s lack of creativity in copying large swathes of Java and pasting them into Android; and (2) Google’s crassly commercial intent in coopting bits of Java for its own competing and incompatible platform:
Although Google could have furthered copyright's goals of promoting creative expression and innovation by developing its own APIs, or by licensing Oracle's APIs for use in developing a new platform, it chose to copy Oracle's creative efforts instead. There is nothing fair about taking a copyrighted work verbatim and using it for the same purpose and function as the original in a competing platform.
For the court, there was nothing original in Google’s use of the APIs: it simply appropriated them, to elevate its own platform at Oracle’s expense:
Android's release effectively replaced Java SE as the supplier of Oracle's copyrighted works and prevented Oracle from participating in developing markets. This superseding use is inherently unfair.
Tallying up the statutory factors, the court concluded:
On this record, factors one and four weigh heavily against a finding of fair use, while factor two weighs in favor of such a finding and factor three is, at best, neutral. Weighing these factors together, we conclude that Google's use of the declaring code and SSO of the 37 API packages was not fair as a matter of law.
In sum, Google’s failure to establish that its use was transformative (factor 1), and its clear ambition to usurp Java’s potential role in the mobile device market (factor 4) outweighed the relatively functional, and thus less-protected, nature of the Java APIs (factor 2), while the amount and substantiality of the material copied (factor 3) favored neither side.
To concerned observers in the software development community, the court offered this caveat:
We do not conclude that a fair use defense could never be sustained in an action involving the copying of computer code. Indeed, the Ninth Circuit has made it clear that some such uses can be fair.
Oracle II will have enormous implications for Google and Oracle, but its impact on the software development community is less obvious.
Sticking to the legal analysis, the Federal Circuit revealed this much:
(1) Copying code developed primarily for use in desktops and laptops, then adapting and reusing that same code for the same purpose in the smart phone context, is not “transformative” for purposes of fair use;
(2) The fact that code is inherently functional in nature, standing alone, does not render copying code a fair use and is of limited value compared to other considerations;
(3) Extensive, verbatim copying of code, without a truly transformative use, is not fair use;
(4) The impact of copying code on the market, or potential market, for that code is the most important of the fair use factors;
(5) Fair use does not support wholesale copying of code simply to avoid having to do the work of reverse-engineering and re-expressing code; and
(6) À la Sega and Sony, reverse-engineering code, then expressing the same functionality with different code, can be fair use.
Simply put, the Federal Circuit thought Google’s use of the Java APIs was more about convenience and time-to-market objectives and less about innovation, which is the overarching goal of copyright law.
For those in the business of developing software, here are some additional thoughts to consider:
While the term can mean different things to different people, it is fair to say that the Java API license at issue in this litigation was not “open source”—it was a complex scheme designed to permit some uses, restrict others and capitalize on yet others. It permitted use in applications for free; but required royalties for use in competing platforms or installations embedded in physical devices. Viewed in this light, Oracle II can be seen as a win for platform developers that aim to use open-source elements to entice a community of developers, but simultaneously maintain enough licensing restrictions to prevent a rival platform from reaping the benefits of the community’s development activity. True, Google forged ahead and usurped that community despite Oracle’s restrictions, but if the court’s opinion holds up, Oracle is in line for a big payday.
Incredibly, Google attempted to present evidence that Oracle in 2008 moved the contested Java APIs into OpenJDK, the open-source version of Java, but the evidence was denied as being presented too late for Oracle to effectively respond.  Had Google been permitted to use this evidence, which appears to show that the disputed APIs were freely available to Google without restriction, the case would likely have resulted in a very different outcome. First, Google conceivably could have used this evidence to show that it complied with OpenJDK’s open-source license, thereby obviating the entire copyright/fair use analysis. Second, even if Google technically violated the terms of the open-source license, the court’s entire analysis on factor four (impact on the market for the copyrighted material) would be much less potent in an open source environment, since copying of open source code cannot be said to harm the original developer’s prospects for commercially exploiting said code. Presumably, in an open source platform the developer could not have reasonably had any such prospects. This wrinkle in the case should give software developers that use bits of third-party open-source code some measure of comfort.
(1) Google will file a petition for rehearing en banc, asking the entire Federal Circuit bench (18 judges) to reconsider the opinion of the 3-judge panel that decided Oracle II. The panel has granted Google an extension to May 29, 2018 (the day after Memorial Day) to file such its petition. If the petition is granted, the full court could order a new round of briefing, fresh oral argument and the court could revisit some or all of the panel’s March 27 opinion.
(2) assuming the petition for rehearing en banc is denied (as are the vast majority of such petitions), Google will likely file a petition for a writ of certiorari to the Supreme Court, asking the high court to review and overturn Oracle II. The criteria for certiorari are (a) an issue of national importance; and/or (b) a split among the circuits on a significant legal issue. It seems unlikely that the Supreme Court will take up the case, having previously declined taking up Oracle I, but it is possible.
(3) The Ninth Circuit could, in a future case, seek to clarify and/or correct the Federal Circuit’s take on its positions relative to fair use. The Federal Circuit only heard Oracle I and II because Oracle’s original suit against Google included a patent claim (over which the Federal Circuit has exclusive jurisdiction). Because Oracle filed suit in California, the appeal would have (but for the patent claim) gone to the Ninth Circuit, and so the Federal Circuit was bound to apply Ninth Circuit law to the remaining copyright claim.
(4) If and when a trial on damages proceeds at the district court, Google will likely refashion many of its arguments that from Oracle II to mitigate or exclude damages. For example, Google might well argue that Oracle’s actual presence in the market for mobile devices was so tenuous, that usurping the Java APIs did little actual financial damage to Oracle. Further, Google might just get that OpenJDK evidence into the record, in which case it can argue that Oracle, by making the APIs available to all under an open-source license, had no intention of exploiting the APIs for commercial gain.
 Oracle Am., Inc. v. Google LLC, 2018 U.S. App. LEXIS 7794 (Mar. 27, 2018).
 Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 74931 (Jun. 8, 2016); and Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 145601 (Sept. 27, 2016).
 Oracle II, at *68-71.
 The fair use defense is codified at 17 U.S.C. § 107.
 Oracle II, at *71.
 For example, the Electronic Frontier Foundation recently posted an article lambasting Oracle II as “a surprising decision that should terrify software developers” and that “upended decades of software industry practice and created legal uncertainty that will chill innovation.” Federal Circuit Continues to Screw Up Copyright Law and Thwart Innovation, by Corynne McSherry (Mar. 27, 2018). https://www.eff.org/deeplinks/2018/03/federal-circuit-continues-screw-copyright-law-and-thwart-innovation.
 As the court observed, “the doctrine of fair use has long been considered ‘the most troublesome in the whole law of copyright,’” quoting, Dellar v. Samuel Goldwyn, Inc., 104 F.2d 661, 662 (2d Cir. 1939).
 Oracle II, at 9.
 Id., at 10.
 Id., at 11.
 Id., at 11-12.
 Id., at 10.
 Id., at 12.
 Id., at 12-13.
 Id., at 13.
 Id., at 13.
 Oracle Am., Inc. v. Google Inc., 750 F.3d 1339, 1381 (Fed. Cir. 2014)(“Oracle I”).
 Id., at 1360.
 Id., and see, 17 U.S.C. § 102(b)(“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.”).
 Oracle I, at 1360.
 Oracle I, at 1361.
 Id., at 1364.
 Id., at 1366.
 Id., at 1366-67.
 Id., at 1367.
 Id., at 1368.
 The court noted that Lotus was taken up by the Supreme Court, which then proved unable to render an opinion in the case. Lotus Development Corp. v. Borland International, Inc., 49 F.3d 807 (1st Cir. 1995), aff'd without opinion by equally divided court, 516 U.S. 233, 116 S. Ct. 804, 133 L. Ed. 2d 610 (1996).
 Oracle I, at 1366.
 Oracle I, at 1368.
 Id.,at 1369.
 Id., at 1370.
 Id., quoting, Amicus Curiae Brief of Ralph Oman, former Register of Copyrights of the United States.
 Id., at 1370-71.
 Id., at 1371.
 Id., at 1372.
 Id., at 1376.
 Id., at 1376-77.
 Id., at 1377.
 Oracle II, at 16.
 Id., at 17-19.
 See generally, Oracle II, at 20-23.
 17 USC § 107.
 Oracle II, at 36.
 Id., at 38-39.
 Id., at 40.
 Id., at 41-42.
 Id., at 42-43.
 Id., at 45.
 Id., at 46-47.
 Id., at 47-48.
 Id., at 55-56.
 Id., at 56.
 Id., at 58.
 Id., at 59.
 Id., at 59-60.
 Id., at 60.
 Id., at 61.
 Id., at 61.
 Id., at 63-64.
 Id., at 64-65.
 Id., at 65.
 Id., at 65-66.
 Id., at 66.
 Id., at 67.
 Id., at 69.
 Id., at 69-70; citing, Sony, 203 F.3d at 608; and, Sega, 977 F.2d at 1527-28.”
 Before the District Court, Oracle claimed $8.8 Bn in damages. And that figure did not even include Oracles’ claim for damages based on additional uses of Android, which were remanded for findings on liability. Oracle II, at 71.
 Google’s online dictionary application defines “Open Source” as “denoting software for which the original source code is made freely available and may be redistributed and modified.” https://www.google.com/search?q=open+source&oq=open+source&aqs=chrome..69i57.1879j0j8&sourceid=chrome&ie=UTF-8
On its website, Open Source Initiative provides a ten-point “Open Source Definition”, in which the first point is “Free Redistribution”: “The license shall not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license shall not require a royalty or other fee for such sale.”
 Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 145601, *17-18, 101 Fed. R. Evid. Serv. (Callaghan) 670 (“[A] pretrial ruling obtained by Oracle excluded evidence tendered by Google with respect to Android Nougat. Significantly, this evidence would have shown that (back in 2008) all of the accused APIs could simply have been taken from OpenJDK, Sun's own open-source version of Java, apparently in full compliance with the open-source license. Put differently, Sun itself had given away Java (including all of the lines of code in suit) in 2008 via its open-source OpenJDK. In 2015, Google used OpenJDK to reimplement the Java APIs for the latest release of Android, which it called Nougat. Google wished to use this evidence under the fourth fair use factor to show that its infringement did no more market harm than Sun itself had already invited via its own OpenJDK release. Despite its importance, the Court excluded this development because it had not been presented by Google in time for effective rebuttal by Oracle. This exclusion was a major win for Oracle in the weeks leading up to trial.”).