Special report The decade-long mega-battle between two of the world’s largest corporations, which will decide the future of software development, began its final showdown this morning.
Yes, it was Google versus Oracle at the US Supreme Court, and two hours of wide-ranging, fast-paced legal argument: full of analogies, pointed questions, sharp responses, and virtually no missteps – it indicated just how much is at stake.
At the heart of the case is this: Android, Google’s mobile operating system installed on billions of devices that contributes to making it one of the richest and most powerful corporations on the planet.
Oracle says Google stole code from Java's core libraries after Oracle refused to license the technology to Google in a way that would allow Google to create its own closed flavor of the Java environment in which Android apps would run.
Google says while it built an entire operating system and software environment, it did lift some code from the core Java libraries – specifically, the veneer or application interface of those libraries – to make it easy for people to write their apps using the Java programming language. If you're familiar with Java, you should recognize the same interfaces on Android, which gives you a head start in developing software for the platform.
In the red corner, Big Red, and in the blue corner... the rest of the tech industryREAD MORE
Google claims Java's interfaces, also known as APIs, are so common and frequently used that Oracle can’t reasonably claim to have ownership of them. And even if Oracle is allowed to claim copyright over them, which seems likely given the way the law is written, Google claims its cribbing of the library code – such as copying method and class names and specifications – to implement Java's APIs on Android is “fair use." That would mean it doesn’t have to get permission from Oracle, or pay it to use them.
It’s worth noting that we are talking about approximately 11,000 lines of code, which is a tiny proportion of the millions of lines of code that make up Android and its Java libraries Google said it developed clean-room style albeit with the lifted interface definitions.
Google is on the back foot. The Supreme Court is being asked to rule against not one but two decisions that have gone in Oracle’s favor. Oracle’s position is thus the status quo – the lower courts have backed its arguments – and it has the US government on its side. So Google has to persuade America's highest court to adopt a new position and, in doing so, set a significant precedent.
Things are also complicated by the fact that there are right now only eight judges following the death of Ruth Bader Ginsburg, which could lead to an evenly split court (4-4) and a win for Oracle.
That means Google needs to persuade five judges, and lose only three. It will be an uphill struggle. It’s worth noting that precedent shows the case is unlikely to be reheard when there are nine judges, so today was it. There will be no more Google vs Oracle after this – unless the Supremes remand the matter and punt it back down to the lower courts for a rethink. We await a final judgment.
Based on what happened in court this morning, Google still has a chance, in large part thanks to the outstanding performance of its lawyer Thomas Goldstein, who was arguing his 44th case in front of the Supreme Court.
He also publishes the SCOTUSblog, which is an expert source of Supreme Court news. In other words, Google hired the best.
Aside from the fact that Goldstein appeared to have a muddied understanding of what an API actually is, something that sent those following the case online into a social media frenzy given how critical it is to the whole case, his responses to questions and the arguments he put forward were impeccable. At one point, Goldstein even outmaneuvered Chief Justice John Roberts, who decided to use a safe as an analogy.
In response to Goldstein/Google arguing that the only way Google could make Android work as a viable platform was to provide the core Java library interfaces to app developers, and so copyright shouldn’t apply because it effectively would give Oracle a level of control over a system that copyright isn’t intended to provide – we're talking patent territory here – Roberts argued:
“You say that was the only way to do it. Cracking the safe may be the only way to get the money that you want, but that does not mean you can do it. If it’s the only way for you to get it, the only way to get it, is a license.”
To which Goldstein responded, without missing a beat: “That analogy would help us. If you get a patent on the safe you may be able to keep us out. But if you write a book about the safe, about how to crack safes, that does not give you the exclusive right to do it.”
... if you write a book about the safe, about how to crack safes, that does not give you the exclusive right to do it
That caught Roberts completely unawares because he was thinking in different terms. He hesitantly pushed forward: “What about the combination to the lock on the safe? Can you copy that just because somebody else has it and that is the only way to get in?”
Goldstein: “If you write a book about how to unlock the combination of a lock, that does not give you the exclusive right to the lock. Copyright law is for people to be able to use that knowledge.”
Now, the use of safes was not a good one for this programming issue, but it did demonstrate Goldstein’s effectiveness at trading in the currency of Supreme Court arguments: analogies. Whereas Oracle’s lawyer Joshua Rosenkranz found himself constantly disagreeing with the analogies put forward by the Supreme Court Justices, as well as pushing several forward himself, Goldstein rolled with every analogy thrown his way and frequently turned them around.
And analogies were particularly strong in this case, in large part because none of the Justices understand how software engineering works, even though Justice Stephen Breyer had made several abortive attempts. Some of the most interesting or telling analogies that cropped up that will likely drive the Justices’ thinking include:
- Oracle’s Rosenkranz likened the 11,000 lines of code grabbed by Google to TV show Seinfeld. Google argued that it had “fair use” rights over the code because they are so well known and so widely used in app development. Rosenkranz rejected that:
“If somebody wanted to write a book that preserved and reproduced the 11,000 best lines of Seinfeld, they could not do it by claiming: ‘Well we had to do it because those are the lines that everyone knows.’”
- Justice Breyer kept pushing the analogy of a qwerty keyboard. “If you let someone have a copyright on that, they would control all typewriters.” Rosenkranz wasn’t happy with that analogy:
“This is not like the qwerty keyboard. There was never anything expressive in Qwerty; it was purely mechanical. That is true of all of your examples.” He pushed instead the fact that the Java code in question is extremely clever, honed, and precise in getting computers to do things ultimately for users.
- Rosenkranz refused to accept that what Google had done with Java was “transformative” – basically taken a language for desktop PCs and turned into something for mobile phones. If accepted, that argument backs up Google’s argument that it was “fair use.”
Rosenkranz argued instead: “Adapting our code for the supposedly new smartphone environment does not change the meaning and is no more transformative than adapting a short story into a movie.” He used a variation on the same idea later on:
“If you imagine a motion picture that has only been released in theaters and someone gets the print and tries to livestream it over the internet, it is the same content that is being used on a different platform. No one would think of that as transformative.” The Java within Android, he argued, “is performing exactly the same function” as the Java in desktops.
From a legal precedent perspective, a lot of discussion revolved around a previous case – Baker v Selden – from 1879 amazingly enough, in large part because it drew a distinction between an idea and an expression of that idea.
Charles Selden wrote a book, and got copyright on it, that outlined a better way of book-keeping (he ended up writing six editions of it.) Eight years later, W.C.M. Baker also wrote a book outlining pretty much the same approach.
The big difference was that Baker sold a ton of his books and Selden didn’t. Selden (well, his wife, because he died) sued for copyright infringement. They won in district court and lost at the Supreme Court in large part because of a distinction between patent law and copyright law. Selden didn’t patent his approach; he merely wrote a book about it and so shared that knowledge.
Google claims that Oracle (really, Sun which invented Java and was then bought by Oracle) effective wrote a book and copyrighted it, rather than patented a method of computing.
There was a lot of discussion around this case today by the Justices, and lots of questions and answers. The truth is, however, it’s impossible to tell whether the case will swing it one way or another. The final judgment will have to explain how it fits with the Baker v Selden precedent though it won’t drive the decision.
What is unlikely to drive the decision, even though it is what everyone outside the legal processes is worried about, is the impact of the decision on future software development.
Disaster! No matter what!
Both Oracle and Google have claimed that if the case goes against them it will “up-end the industry.” And it will, but that’s what happens when big decisions are made.
If Oracle wins, it is very likely that companies owning the foundations of old code, that has been built on over and over again in recent decades, will start suing everyone for its use in more modern uses. Why? Because money.
This makes software developers very nervous because, much like music, new software is rarely created completely from scratch – it always builds on what had gone before but with additions and twists and a contemporary take. Basically, everyone writing software will then have to worry about being sued at some future point.
Campaigners cry foul play as Oracle funds conservative lobby group supporting its court case against GoogleREAD MORE
It’s the same approach that has driven the patent system into the ground, with companies amassing patent portfolios in order to act as a deterrent to others that might sue them.
Everyone is infringing everyone else’s patents. It’s a mess, and it birthed patent trolls. A win for Oracle, which seems likely, could well create a new industry of copyright trolls.
On the flip-side, if Google wins, it may derail our whole approach to source code licensing because companies could argue they are cribbing parts of applications under the protection of fair use, and so don’t have to pay a penny or follow any associated licensing obligations.
It could radically restructure the open-source world because license restrictions could be deemed to be irrelevant. And that approach could also stymie future development because companies would fear that the more popular their software became, the less likely they would be to make any money off it.
The upshot, at least in the Supreme Court’s mind, is that it is all likely to balance out. The conservative judges are likely to stick with the status quo; the liberal judges will look forward. Either way, it will shake out because no one believes software development will simply stop.
So what will drive the decision?
Since this is the Supreme Court, it is likely to be deeply legal questions. And a key one is whether it was okay for a federal court to overrule a jury decision that said Google did have “fair use” rights over Oracle’s code.
There was a lot of discussion over whether the court had made the right determination in that case, in large part because the Supreme Court is very uncomfortable with the idea of jury verdicts being overturned later on by a judge – for obvious reasons.
There was plenty of argument as to why that happened and whether it was right to do so. The key aspect that the conservative judges will likely latch onto, is that fair use decisions are much more frequently decided by judges, not by juries.
And it doesn’t help that Google has flip-flopped on the question of jury decisions depending entirely on whether it helps its case – one of the by-products of a massive, decade-long legal fight.
The fact is that the case is on a knife-edge in many ways, and the Justices who will likely tip the decision one way or the other – Kavanaugh, Gorsuch, and Kagan – didn’t give much of an indication which way they were heading.
What’s our bet?
Best guess is that Oracle will win. It is the status quo, and the case has been in and around the legal system multiple times with both trips ending up in Oracle’s favor. The Supreme Court would have to feel very strongly about it to flip the situation.
And then of course there is the cold reality of what Google actually did. Google turned to Java to help make its mobile operating system succeed because to do otherwise would have taken far too long. Apple went its own path, and fostered its own programming language and spent years making sure it had full control and ownership over its technology.
Google didn’t. It wanted Java and it needed programmers’ knowledge of, and trust in, Java to jump-start its entry into the smartphone market. It asked Oracle for a license, and Oracle told Google it would have to make its subsequent work interoperable with the rest of the Java world.
Google didn’t want that because it wanted to control the subsequent ecosystem. And so, the truth is, it knowingly grabbed Java, and pulled in the parts it simply couldn’t avoid using.
That is not the first time Google has built its business on top of other people’s work. If Google loses, and has to pay Oracle the demanded $9bn plus interest and future royalties, you can’t say it didn’t have it coming to it.
What that decision would mean for the future of software development, however, well, we’ll have to wait and see. ®