from the nice-try,-see-you-next-time dept
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 control.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 accordinglyAlsup 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....Honestly that's one of the most thorough and clear descriptions I've seen to date of the fair use question here.
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.
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.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:
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.
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 House Report):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.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.”