Following the jury verdict
finding in favor of fair use for Google and its use of Oracle's Java APIs (if you haven't yet, you should listen to our podcast
about the trial), Oracle asked Judge Alsup to basically ignore the jury ruling. Specifically, Oracle asked Judge Alsup to rule that "as a matter of law" that Google's use was not fair use, thus negating the need for the jury to settle any dispute. This is actually how the original
Alsup ruling in this case came about. After the first trial had a jury find Google had infringed, Alsup said that, as a matter of law, APIs were not eligible for copyright protection and effectively dumped the jury ruling... until the appeals court overturned
that ruling and sent the case back for a second trial focused solely on the fair use question.
This time, however, Judge Alsup was not at all willing to say that either side prevailed as a matter of law, and has declared the jury verdict final
. Alsup's explanation for denying the motions
to ignore the jury is well argued, and basically said "look, there was a clear trialable issue here and the jury handled it":
Under the law as stated in the final charge and on our trial record, our jury could
reasonably have found for either side on the fair use issue. Our trial presented a series of
credibility calls for our jury. Both sides are wrong in saying that all reasonable balancings of
the statutory factors favor their side only. To the extent either side now quarrels with the law
as stated in the final charge, the time for those arguments was at or before the
charging conference or eventually on appeal. For now, at the district court, the jury instructions
Alsup notes that, of course Oracle is going to appeal, so as with last time, he adds some background potentially directed at the appeals court more than either of the parties in the case. Concerning the main line of attack that Oracle is expected to use on appeal -- over the instructions to the jury concerning fair use, Alsup notes that there was nothing wrong with the instructions at all, and that both parties had plenty of chances to weigh in on those instructions:
The fair use instructions followed largely the review of fair use law as set forth
in the Federal Circuit’s opinion except for modifications urged by counsel and to account for
how the case was actually tried. The final jury charge culminated an exhaustive and iterative
process of proposals by the judge followed by critiques by counsel. Months before trial, the
Court informed both sides that it expected to use the Federal Circuit’s opinion canvassing
fair use law as the starting point and requested briefing from the parties addressing what
modifications should be made. After reviewing those comments,
the Court circulated a first proposed charge on fair use and requested critiques.
Counsel submitted their critiques a week later with replies the following week. In light of the
critiques, a second draft made substantial revisions, asking counsel to
meet and confer to reach an agreed-on instruction in light of that proposal and to submit briefs
and responses regarding the areas of disagreement. After reviewing the further briefs and
responses, the Court next circulated “penultimate instructions on fair use,” a third draft, and
invited a third round of comment. Those critiques also led to modifications
and a final notice of the pre-instruction on fair use to be read to the jury before the start of the
evidence. Counsel (and the jury) were advised that the final instructions at the
end of the evidence would possibly be adjusted to reflect the way the case was tried (and, in
fact, some minor modifications did occur). During the trial, the judge sought briefs on several
issues in play as the evidence came in. Based thereon, a notice of the proposed final charge
circulated the night before the close of evidence. At the charging conference,
counsel raised both new points and old ones (although they were permitted to rest on prior
critiques). Final modifications followed. The jury was charged accordingly
Alsup also goes into great detail (again, remember that he taught himself Java to better understand the issues in this case the first time around -- and it shows here) discussing the dividing line between Java and not just the APIs, but the "necessary" APIs and the non-necessary APIs. Check out the following, excerpted at great length, to show how thoroughly deep into the weeds Judge Alsup got to understand this case (for clarification, the term "SSO" stands for "Structure, Sequence, and Organization" and was a key issue in the case):
Oracle has portrayed the Java programming language as distinct from the Java API
library, insisting that only the language itself was free for all to use. Turns out, however, that in
order to write at all in the Java programming language, 62 classes (and some of their methods),
spread across three packages within the Java API library, must be used. Otherwise, the
language itself will fail. The 62 “necessary” classes are mixed with “unnecessary” ones in the
Java API library and it takes experts to comb them out. As a result, Oracle has now stipulated
before the jury that it was fair to use the 62 “necessary” classes given that the Java
programming language itself was free and open to use without a license....
That the 62 “necessary” classes reside without any identification as such within the Java
API library (rather than reside within the programming language) supports Google’s contention
that the Java API library is simply an extension of the programming language itself and helps
explain why some view the Java API declarations as free and open for use as the programming
language itself. At least to the extent of the 62 “necessary” classes, Oracle agrees.
All this said, our fair use issue, as presented to our jury, came down to whether someone
using the Java programming language to build their own library of Java packages was free to
duplicate, not just the “necessary” functions in the Java API library but also to duplicate any
other functions in it and, in doing so, use the same interfaces, i.e., declaring code, to specify the
methods — so long as they supplied their own implementing code.
Oracle’s argument in the negative amounts to saying: Yes, all were free to use the Java
programming language. Yes, all were free to use the 62 necessary classes from the Java API.
Yes, all were free to duplicate the same functionality of any and all methods in the Java API
library so long as they “re-implemented” (since copyright does not protect functionality or
ideas, only expression). But, Oracle would say, anyone doing so should have scrambled the
functionalities among a different taxonomy of packages and classes (except as to the 62
“necessary” classes). That is, they should have used a different SSO.
Here, the undramatic yet practical point comes into sharp focus. If, as it was entitled to
do, Google had simply reorganized the same functionality of the 37 re-implemented Java
packages into a different SSO (taking care, however, not to disturb the 62 necessary classes and
their three respective packages), then Java programmers, in order to use the Java system as well
as the reorganized Android system, would have had to master and keep straight two different
SSO’s as they switched between the two systems for different projects. Our jury could
reasonably have found that this incompatibility would have fomented confusion and error to
the detriment of both Java-based systems and to the detriment of Java programmers at large.
By analogy, all typewriters use the same QWERTY keyboard — imagine the confusion and
universal disservice if every typewriter maker had to scramble the keyboard. Since both
systems presupposed the Java programming language in the first place, it was better for both to
share the same SSO insofar as they offered the same functionalities, thus maintaining usage
consistency across systems and avoiding cross-system confusion, just as all typewriter
keyboards should use the QWERTY layout — or so our jury could reasonably have found.
The same could have been reasonably found for the second purpose of the declaring
code — specifying the inputs, outputs, and their type. To the extent a specification could be
written in more than one way to carry out a given function, it was nevertheless better for all
using the Java language to master a single specification rather than having to master, for the
same function, different specifications, one for each system, with the attendant risk of error
in switching between systems — or so our jury could reasonably have found.
In terms of the four statutory factors, this consideration bears significantly upon the
nature and character of the use (the First Factor), the functional character of the declaring code
(the Second Factor), and the limited extent of copying (the Third Factor), that is, Google copied
only so much declaring code as was necessary to maintain inter-system consistency among Java
users. Google supplied its own code for the rest. Overall, avoiding cross-system babel
promoted the progress of science and useful arts — or so our jury could reasonably have found.
Honestly that's one of the most thorough and clear descriptions I've seen to date of the fair use question here.
Another issue that came up was whether or not Oracle showed that Google acted in "bad faith." Oracle used a number of emails (often taken out of context) to argue that Google knew it was infringing on Sun's copyrights (though, many of the details suggested the actual concern was more about trademark -- or involved people who didn't really understand the nuances of copyright law). Judge Alsup points out that it's not even clear "good faith" or "bad faith" are even allowed as considerations in fair use analysis, though he notes that he allowed Oracle to pursue it -- and then allowed Google to build a case for "good faith" in response. For the question of whether or not this is an issue "as a matter of law," Alsup notes that it's clearly one that a jury should decide (and did, in Google's favor):
... our jury could reasonably have concluded that Google’s use
of parts of the Java API as an accelerant was undertaken based on a good faith belief that
at least the declaring code and SSO were free to use (which it did use), while a license was
necessary for the implementing code (which it did not use). Our jury could reasonably have
concluded that Google’s concern about making an enemy of Sun reflected concern about the
parties’ business relationship in light of the failed negotiations that would have brought Sun
in as a major partner in Android, rather than concerns about litigation. Mental state was and
remains a classic province of the jury.
The judge also rejects Oracle's claim that no one could possibly argue that direct copying of the APIs was "transformative." That's not how the "transformative" test works, Alsup notes, pointing to previous fair use cases, such as the Campbell case over the parody of the song "Pretty Woman," which involved direct copying
In Campbell, the accused work (a rap parody song) used the same bass riff and an
identical first line of Roy Orbison’s “Oh, Pretty Woman.” The parody also included exact
copies of certain phrases in subsequent lines and maintained the same structure and rhyme
scheme throughout. The copied elements served the same function in the accused work as in
the original. Nevertheless, the Supreme Court acknowledged that the transformative purpose
of parody had a “need to mimic an original to make its point,” and thus, warranted copying some
exact elements. The question of the extent of the copying permissible to serve
that function was the subject of the inquiry of the third statutory fair use factor. So too here.
Android did not merely incorporate the copyrighted work “as part of a broader work,”
without any change to the purpose, message, or meaning of the underlying work. Android did not merely adopt the Java platform wholesale as part of a broader
software platform without any changes. Instead, it integrated selected elements, namely
declarations from 37 packages to interface with all new implementing code optimized for mobile
smartphones and added entirely new Java packages written by Google itself. This enabled a
purpose distinct from the desktop purpose of the copyrighted works — or so our jury could
reasonably have found.
In light of the foregoing, our jury could reasonably have concluded that Google’s use of
the declaring code and SSO of 37 API packages from the desktop platform work in a full-stack,
open-source mobile operating system for smartphones was transformative.
The ruling goes on like this, over and over again pointing out that the jury's decision is not so crazy and has support in the law. And then it concludes with a big slap to Oracle, noting that it seems to be making completely inconsistent arguments:
Stepping back, it seems hard to reconcile Oracle’s current position with the one it
took just as the trial was getting underway, namely, that fair use is an equitable rule of reason
and each case requires its own balancing of factors. In its critique of the first proposed jury
instructions on fair use..., Oracle argued that the Court’s draft characterization
of the policy of fair use contravened the legislative history, and Oracle cited the following
language from a Senate report on the 1976 Copyright Act (which language was repeated in the
Although the courts have considered and ruled upon the fair use
doctrine over and over again, no real definition of the concept has
ever emerged. Indeed, since the doctrine is an equitable rule of
reason, no generally applicable definition is possible, and each
case raising the question must be decided on its own facts.
.... The Court adopted Oracle’s proposed instruction in the next
draft as well as in the final charge to the jury, stating: “Since the doctrine of fair use is an
equitable rule of reason, no generally accepted definition is possible, and each case raising the
question must be decided on its own facts”....
Now, Oracle argues instead that this case must be decided as a matter of law, and not
“on its own facts.” Oracle argues that Google’s copying fails to resemble any of the statutory
examples of fair use listed in the precatory language of Section 107, again contradicting its
earlier position that “no generally applicable definition is possible.”
Once again, much of this seems more addressed to the appeals court than the parties. Unfortunately, last time around that didn't work, as the appeals court got it wrong. Now we'll have to wait and see what happens this time around.