Google set themselves up for failure with Supreme Court performance
posted Saturday Oct 10, 2020 by Scott Ertz
A little over a decade ago, Oracle followed what seemed like every other tech company and filed suit against Google. While it was the popular thing to do at the time, Oracle's suit was different from everyone else's. Oracle claimed that, in Google's implementation of Oracle's Java programming language for Android, they duplicated protected API interfaces. Google argued that the API surfaces, or the outer structure that defines the methods and arguments for those methods, were publicly available and, therefore, not protectable.
This is an unbelievably complicated topic that requires further explanation. In particular, let's discuss some of the terms which have been at the center of this court battle. The first and most important term is API. An API, or Application Programming Interface, is a collection of code with publicly exposed methods for a system's operation. Generally, when we discuss APIs, we talk about web APIs also known as web services. A lot of web services are intended for public consumption, and so their structure is publicly known.
In the Oracle and Google case, the API is very low level, including basic math functions. The idea of creating a method to find the maximum value or a number is far from unique. However, creating a class called Math in a namespace named java.lang, with a method named max with two arguments, both doubles, named E and PI, is unique. The structure was designed by the Java language team, which Google duplicated in order for Java to be used to develop for Android. That's because Oracle does not make the implementation of Java available to the world. But, because of the nature of APIs, the surface is publicly documented.
The programming surface is the most outer aspect of the API. It is the part that is exposed to programmers. It includes the namespaces, the classes, the methods, and the arguments. Even with fully compiled and signed code, the programming surface is exposed. There is no way for an API to be useful if you cannot discover, one way or another, the structure of the surface. Everything under the surface, however, is protected. That means that the implementation is private, and the code behind the implementation is copyrightable. The case, however, is all about whether or not the surface itself is also copyrightable.
Over the past ten years, this case has seemingly landed in every court possible. This week finalized that legal tour, with Google and Oracle arguing their cases in front of the final word in US law - the United States Supreme Court. The court, which currently has 8 sitting Justices, heard the case presented by both sides and will before the end of their current term. Under normal circumstances, there are two likely outcomes, but under these current circumstances, there are three.
The first likely outcome is that Oracle wins outright, setting a national precedent in favor of code protection. This would mean that developers can protect their general program code, as well as their interfaces. The second likely outcome is that Google wins outright, setting a national precedent in favor of code ubiquity. This could mean that, not only are programming interfaces lose protection, but code as a whole could as well. The third possibility, which is created by the even number of Justices, is a tie. In this fairly unusual scenario, the ruling would default to the previous court's ruling, but would not set a national precedent, meaning that different jurisdictions could relitigate the case. The previous ruling was in favor of Oracle.
In addition to national precedent, which is important to the developers of the country, Oracle is looking for a licensing fee to subsidiary Sun, which is responsible for the Java ecosystem. Sun licenses the Java language and ecosystem as its primary business model. A decade worth of overdue licensing fees for billions of instances of Android across the world could cost Google billions or tens of billions of dollars.
With a case this important, being argued in front of the most important court in the country, with potential repercussions beyond what we currently understand, you would expect that both sides would bring their A-game. However, Google appears to have gone a different direction. In fact, legal scholar James Grimmelmann of Cornell University said of Google's attorney Thomas Goldstein,
He did an abysmal job. At the level of nuance he was willing to get into, his case was a loser. The only way to make it stick is to be nuanced about what it means to declare code.
Nuance was the key to this case. How do you argue that some parts of a software system are protectable but other parts are not? You have to describe in nearly excruciating detail just how different these two aspects of software are. But Goldstein's primary argument was that an API method like Math.max was a "method of operation" because programmers "operate" the Java language through invocations of these interfaces. This seems like an important distinction because Section 102(b) of the Copyright Act, the centerpiece of the case, states that an "idea, procedure, process, system, method of operation, concept, principle, or discovery" cannot be copyrighted.
Google's argument falls apart immediately, however, because any function, including private functions, can be described the same way. That would mean that no software could ever be copyrighted, meaning that software clones (which is where someone steals the code of an app and publishes it under their own name) would be entirely legal. It also means that the entire law, which is intended to allow developers to protect their work, has zero value. Justice Samuel Alito summed this up well, saying,
I'm concerned that under your argument, all computer code is at risk of losing protection under 102(b). How do you square your position with Congress' express intent to provide protection for computer codes?
Goldstein was not able to articulate a position in which the two types of code were different, essentially undermining his own case. Justice Brett Kavanaugh, the last to ask questions because of his position on the court, brought up that Oracle's lawyer said,
...declaring code is a method of operation only in the same sense that computer programs as a whole are methods of operation, and that therefore your method of operation argument would swallow the protection for computer programs.
He followed up by asking Goldstein,
You're not allowed to copy a song just because it's the only way to copy a song. Why is that principle not at play here?
The Court has not yet ruled but will need to by the end of their current session. There is no clear indication which way the court is leaning, though at least some of the Justices seemed unconvinced by Google's arguments.