True Detective: another round in the Oracle v Google battle
Patent or copyright disputes between large vendors are sometimes just like the TV/Netflix series — season 1 (the initial litigation) is either striking and fascinating or a total disaster (so you don’t spend more of your time). Season 2 (the appellate stage), however, becomes decisive — it will either enable producers to launch a long-lasting series or will probably cut the series to its end (glorious or boring — does not really matter).
So far, it seems that the Oracle v Google battle over 37 Java API packages has already become a successful series — we have seen 4 seasons already with at least one more to come soon.
I happen to be a fan of this “series” since the very beginning — the battle of two giants at first looked intriguing due to the rise of Android mobile operating system (it was also more entertaining, compared to patent wars between Apple, Motorola, Samsung, Microsoft because they often were settled out-of-court). Of course, it took a while for me to understand how Java API works and what actually Google have copied. Though I have not taken Java programming lessons as Judge Alsup has (he tried the case in a Northern District Court of California) and limited my efforts to several talks to Android and Java developers. Therefore, it is not the first piece of thought regarding this particular battle — more than a year ago I analyzed in this journal the case after the ruling of Court of Appeals and predicted some additional developments in the copyrightability of programming interfaces may appear.
Since that time a few important things have happened and I would like first to make a brief recap of the previous “episodes”.
Season 1. The dispute began in 2010, when Oracle sued Google. Google was accused in breach of the Oracle’s copyright1 to a number of packages of Java API, in particular, their structure, sequence and organization. In 2012 the District court (first instance) found that copying 37 packages of Java API was not breaching Oracle’s copyright because those packages are not subject to copyright protection. The court used two arguments — method of operation (the code at stake was considered as a method of operation rather than the work of art) and merger doctrine (there is a limited number of ways on how to describe and arrange Java’s methods).
Season 2. The case went to appeal, where the Federal Circuit after almost 2 years from the time of the initial judgement overturned the decision of the District Court. In fact, the appellate court has denied every single one of Google’s arguments, including those upheld by the first instance. In particular, the 9th Circuit noted that the method of operation doctrine the way it was applied in this case could result in a world where “no computer program is protectable” because the program is designed to perform only pre-assigned functions. According to the Circuit’s decision the case was remanded to the District court for a decision on possible fair use of Java API (this argument was left untouched in the first instance for obvious reasons).
Season 3. In October 2014 Google sent a petition to U.S. Supreme Court asking for review of this case, claiming there was a circuit split — different decisions of Federal Circuit Courts on the same legal issues. This claim was supported with amici curiae briefs (kind of advisory opinion given by third parties interested in the dispute) by a variety of organizations — Electronic Frontier Foundation, Computer & Communications Industry Association, Berkeley University law professors, a number of computer scientists and even such companies like HP, Red Hat and Yahoo. Oracle has, in its turn, also provided its arguments against Google’s petition, which was also supported by few organizations — Software Freedom Law Center and Free Software Foundation. As a result, the Supreme Court decided to ask the Solicitor General (who represents the federal government) for an opinion on this matter. In May 2015 the Solicitor-General recommended that the Supreme Court deny Google’s petition for two reasons: (1) it would be premature for Supreme Court to take this case into consideration while the “fair use“ issue has not been tried in the lower courts; and (2) the Solicitor-General agrees with the appellate court’s decision. On 26 May 2015 the “season finale“ was no surprise — the U.S. Supreme Court denied the petition with basically the same argumentation as the Solicitor — General had.
Season 4. A year after the Supreme Court’s ruling, the district court started a trial on the question whether Google’s conduct falls within the scope of the fair use doctrine. This is the point where I would like to bring in some more details.
What actually happened in the first 3 “seasons”? Google lost its case. Google failed to convince both Federal Circuit and Supreme Court of the need for some sort of special approach to the copyrightability of programming interfaces. The higher courts found nothing that could prevent Oracle from having a valid copyright to Java API — the latter was considered a creative work of art, including its structure, sequence and organization. Thus, the fair use doctrine could be the last resort for Google in this dispute.
Luckily for the “Don’t-be-evil” corporation, district court Judge Alsup was again as favorable to their claims as possible. Some bloggers2 have even raised concern about the bias of the judge, whose narrative in the jury instructions is way too Google-oriented. The jury instructions definitely leave some flavor of non-copyright ability of APIs that was established by this court 4 years ago. However, even after the appellate court’s opinion, we can find people arguing that fair use cannot be a proper vehicle to resolve this dispute — so everything should have been limited to copyrightability issue3.
Let’s try to have a look at the legal issue with our own eyes. The fair use doctrine is an exemption from the general rule of copyright that all works of art should get protection from unauthorized use or copying. U.S. law provides for a four-factor test of “fair use”, according to which judges/jurors have to decide on the following questions:
— the purpose and character of your use;
— the nature of the copyrighted work;
— the amount and substantiality of the portion taken;
— the effect of the use on the potential market.
At first sight it feels reasonable for Google to refer to this doctrine. At least, some of the criteria might be met.
For instance, the purpose of the use as put by Google is a creation of transformative work, which is a to win tally new mobile operating system (which is a great topic for discussion). Moreover, the code itself is used in a different way than it was developed by Sun Microsystems, i.e. the implementation of the copied code is totally different thanks to Google’s own virtual built-from-scratch machine named Dalvik.
As to the nature of the copyrighted work, Google claimed that first of all, the copied pieces were more functional elements which one cannot avoid having in one’s code when trying to ensure the same functionality. Moreover, Google claimed that the use of the copied code is conjunct to the use of Java programming language (the use of which is not restricted) and was unavoidable (read — “fair”). In fact, more than a hundred lines of copied code was found as essential to Java language syntax, while a few other thousand ones from Google were deemed to be distributed as freely as the “essential” ones.
The quantity of copied material is probably not the best defense for Google, while it has copied 11,000 lines of code (and so Google usually refers to 37 (the number of packages and not the lines)). However, Judge Alsup in his jury instructions says that the quantity here might not be the most important factor, while even copying a small piece of work can sometimes be very harmful.
The market effect of API copying is also debatable. On the one hand, Google claimed that Android programming and its SDK did no harm to the market share of the versions of Java platforms containing such API. Formally speaking, it is a good argument. However, one might say that Java was a huge market player in the software for mobile devices and it was so until Android and iOS appeared on the market (so Google definitely contributed to Java’s decline on the mobile platform market, but the question is: to what extent?).
In addition, Google claimed that Java was considered as free even by Sun Microsystems’ Chief Executive, who was brought to trial as a witness. In summation, there was definitely room for Google to play with the arguments and convince the jurors.
Oracle was in a less favorable position simply because their arguments are much stricter and straightforward (and thus, less touching) — APIs are copyright-protected, Google have used it in order to compete with Java platforms and was aware of the need to get a license. Google was able to create analogous packages as well as to arrange them in a different way than Sun did to Java. There was also a bunch of emails, describing internal discussions at Google regarding the need to use those 37 API packages as well as proposals to obtain a license from Sun Microsystems (which could indicate the bad faith use of the copyrighted code).
If we had a chance to decide on this dispute, who would be our win ner? Unfortunately, there are few decent arguments on both sides (so our task is not easy at all). The fans of strict copyright protection will probably find Oracle the ultimate winner. Those who are skeptical about current copyright laws are more likely to step in for Google.
For me personally it is a quite awkward situation because I believed that APIs could be found non-copyrightable (under certain conditions that Google would probably have met). However, U.S. courts stated that API is a copyrightable object and since then Google’s fair use does not look like a very compelling argument. Mainly, because the way it was brought to the court, it is either a duplication of copyrightability issue or a set of arguments that at some point, without additional clarifications, might harm the concept of fair use. For instance, I really doubt answering the question whether Google’s use of a API (now we know it is copyright-protected in the U.S. for sure) was in good faith (which is a criteria of a fair use — its purpose and character). Until the API packages under dispute were considered as lacking copyright protection, the behavior of Google seemed reasonable. However, it is not necessarily the case now.
It looks like your favorite character of the series — you expect him or her to be cool all the way but at some point the plot lands him in trouble. Then the hero either becomes less nice and appealing to you afterwards, or simply does not make its way out of this problem.
Nevertheless, on 26 May 2016 the jury came to their verdict — once again, Google won the case heard by the district court. Thus, for now Google looks a bit more confident in their fair use argument. However, Oracle has already declared there will be an appeal and there is no guarantee that Google will be there as successful as in its first instance trial. Moreover, there are experts waiting for Google to fail in the Federal Circuit once again4.
As I said earlier, the 2nd season for the TV show is somewhat decisive. The same happened in this case for Google — the appellate court has defined the trajectory for the dispute. As observers outside of the U.S. we have a chance to make our own judgement on this matter and probably try to reconsider what U.S. courts have done to date regarding the reimplementation of programming interfaces. Still, don’t dare to miss Season 5.
Pdf: UJBL
Other post