Judge Alsup has ruled that the entire infringement point in the case between Oracle and Google was moot, as the Java APIs in question were not copyrightable, and therefor were open to use by anybody for free. This decision sets a landmark precedent in software law and copyright law, and will surely be tested in appeal.
It has been more than seven weeks since the lawsuit between Oracle and Google began, but the question at the heart of that case, whether or not the structure, sequence, and organization (SSO) of the 37 Java APIs that were used could be copyrighted, has finally been answered. The presiding judge has concluded that a partial verdict that Google infringed on the SSO is invalid as the SSO is not copyrightable, though this decision could be overturned on appeal. This means that Google doesn’t have to worry about an injunction, or ban, against their Android operating system for at least a couple years. If this decision is overturned on appeal, then the question of whether or not Google’s use of the APIs is protected under the fair use defense will have to be determined either by a new jury or by a judicial ruling; Google argues that a new jury being selected means that they would have to reevaluate the infringement, which would cause an even longer delay. For now, Google’s seemingly rash decision to defend itself in court has paid off; it gets away scot-free (for a few years, at least). Few if any other companies would have taken on the risks Google did with this decision. The proverbial jury is still out on this case, at least until Oracle appeals the decision, but Google has more immediate IP litigation worries relating to a long list of Android-related lawsuits against Google, Motorola (a newly-acquired subsidiary), and other device makers, such as Samsung and HTC. Two weeks ago, a US trade agency ordered an import ban on Motorola’s (now Google’s) Android devices, and less than a week later a German court ordered a permanent injunction on the same devices.
It would be understandable for the jurors, who just spent seven weeks of their life missing work and being reimbursed far below the minimum wage, to ask why the judge couldn’t have decided the copyrightable issue firest, and saved them all the hassle. The reason Judge Alsup (the presiding judge) waited until the infringement trial was over was because the judge knew from the start that any decision on the copyrightability of the API SSO would face a huge risk for appeal and overturning. He had already looked into the issue last year when he denied Google a motion for summary judgment, and he certainly wouldn’t have put the question before a jury had he been completely certain of the ruling he was planning to give. Throughout the trial, Judge Alsup showed nothing but consideration for the jury, even telling Google and Oracle that, should they settle, they should do so before the weekend so as to minimize the impact on the jurors’ lives.
Clearly, given that the judge himself is unsure of the defensibility of his ruling in the Federal Circuit Court of Appeals, the next stop for the trial should Oracle pursue it, those who are overjoyed by this ruling should be a bit more cautious. Google built key components of the Android operating system on a highly controversial legal theory that will ultimately be decided by either the Federal Circuit or the Supreme Court of the United States. A couple of years might seem like an eternity in a field like software development and mobile operating systems, but it’s obvious that Google has much longer-term interests in the Android operating system. And to be frank, a ruling that the judge himself was unsure of in no way means that there was no case. This decision is unprecedented; no comparable amount of software code (400 class definitions and thousands of methods) has been held uncopyrightable despite satisfying the originality requirement. Both sides had reason to appeal should the case have gone against them.
“This action was the first of the so-called ‘smartphone war’ cases tried to a jury,” began the order on copyrightability, which, although technically true, is not the first case to be resolved; a number of other cases were filed after the Oracle v. Google which have been adjudicated without juries. More importantly, this case has unique characteristics that other smartphone-related cases don’t, instead dealing with patents instead of copyrights, or without the parties in question being in the middle of negotiating a licensing deal prior to the case. Even among copyright lawsuits, this is a rare case, because it deals not only with the infringement and fair use, but whether or not infringement is possible in the first place (i.e. can this material be copyrighted?). The judge, realizing the import of this decision and just how many people would be analyzing it, clarified the intended limitation of the scope of his holding at the end, saying: “This order does not hold that Java API packages are free for all to use without license. It does not hold that the structure, sequence, and organization of all computer programs may be stolen. Rather, it holds on the specific facts of this case, the particular elements replicated by Google were free for all to use under the Copyright Act.”
Judge Alsup, rather than attempt to dictate how an evolving marketplace can operate, instead decided to say that method definitions are so inherently functional that they can’t be copyrighted, pointing to interoperability considerations to back up his ruling. The example of a method definition he gives is:
public static int max (int x, int y)
The method described here is a public (accessible by all the other code) and static (it gets initialized immediately when the program runs, and only one copy is needed since it never changes) function called “max” that returns an “int” (or integer) result based on the interaction of two variables, x and y, which are also integers. The problem is that programmers like myself know that this is a fairly simple, broad function; object-oriented languages like Java (and even non-object-oriented languages like C) allow for far more complex function names, which can deal with highly specific, even proprietary, formats for variables, returned data, or even project- or class-specific formats, data types, or highly specific types of functions designed to do a particular task within the project, and Oracle never claimed a monopoly over a generic function like “max.” The API part of the lawsuit was about a far larger and more expansive body of work than just basic mathematical functions.
It is now up to the higher courts to decide on whether or not the specific code is copyrightable or not. Should the side with Judge Alsup, then Google is cleared and a new precedent is set in copyright law when dealing with writing software. Should they side with Oracle, then the question becomes whether or not the way Google used the code constituted fair use. Either way, this case is going to be very interesting to watch as time goes on. Rest assured, we will continue to cover this case as it makes its way through the courts. In many ways, it’s just getting started.