- Oops!Something went wrong.Please try again later.
- Oops!Something went wrong.Please try again later.
A federal appeals court delivered a huge legal blow to Google on Tuesday, but developers are the ones who could end up paying the price.
Google and Oracle have been fighting a war in court since 2012 about whether Google stole Oracle's intellectual property when it adopted Java naming protocols for Android app developers. And after much back and forth, the U.S. Court of Appeals for the Federal Circuit ruled in Oracle's favor.
The case, however, is more than a battle of technology titans. The most recent ruling overturns decades of precedent about the spirit of innovation that up to this point has governed computer science: an environment in which developers build upon and improve others' work, and write compatible programs designed to adapt to multiple ecosystems and the latest technology. In short, developers could be afraid to innovate because of a ruling by a judge in a court that doesn't usually rule on consumer technology copyright law.
“We are disappointed the court reversed the jury finding that Java is open and free for everyone," a Google spokesperson said. "This type of ruling will make apps and online services more expensive for users. We are considering our options.”
Oracle, obviously, doesn't see it quite the same way.
"The Federal Circuit's opinion upholds fundamental principles of copyright law and makes clear that Google violated the law," Dorian Daley, Oracle executive vice president, general counsel and secretary, said. "This decision protects creators and consumers from the unlawful abuse of their rights."
This case may sound like it's all technical legalese. But it actually could have huge consequences for Google, and most importantly, for creativity and innovation in tech.
"It’s really hard to see how you enable the progress of science and useful art when you cast a serious shadow of uncertainty over the development of compatible software," Parker Higgins, a copyright expert and advocate, said.
Federal Circuit's Oracle v. Google opinion is out, reversing the jury decision and finding no fair use. This wild case is headed back to district court https://t.co/7Tn4c82aIN
— Parker Higgins (@xor) March 27, 2018
As part of his work for the Electronic Frontier Foundation and Freedom of the Press Foundation, Higgins has been following the case closely since the throwdown first began in 2010. We spoke with him to get the 411 on this crazy case, and learn what it means for Google, developers, and ... the spirt of innovation and stuff. Here's everything you need to know about the Google vs. Oracle showdown.
This interview has been edited for length and clarity.
So Parker, what is this case all about?
It's about Oracle's claim that they own a sort of amorphous concept of Android's API: the ability to make things compatible with Java. Today's ruling also puts us in a scary place of uncertainty about what are considered very standard practices concerning compatibility in software.
What is Oracle arguing?
In the 1990's, Sun made made a programming language called Java, which runs on multiple different types of hardware. Oracle bought Sun, but everyone agrees that anyone is allowed to write programs in the Java programming language. And you don’t need Oracle’s permission to do that.
Fast forward several years. Google is developing Android, and they want to make it easy for programmers to use Android, so they decide to make the Android development environment partially compatible with Java.
What that means is, if you’re programming a program on Java in Android — things like, if you want to add two numbers together, you use the adding function — Android programs will have the same names for those functions as traditional programs.
This case is basically about those names that they used. There are 37 of them. Google implemented them themselves, which means that instead of using the code that Sun wrote, Google re-wrote the code, but used the same names. The case amounts to effectively just dozens of lines of code over the millions of lines of code that go into Android.
So Oracle is saying, because Google used the same names for code functions — even though Google engineers wrote the actual implementation code — that Google infringed on Oracle's copyright?
Sort of. It's important to understand the background of this case. It's been going on for a really long time. Oracle originally brought a copyright lawsuit in 2010, and it critically included a patent claim. The patent claim got dropped out very quickly. But that's important later on.
There was just this copyright lawsuit, and Google argued in district court that the stuff in question (the names) weren't copyrightable. They won, but then Oracle appealed and the Federal Circuit said no, in fact this material is copyrightable. And so the case was sent back to district court.
So then there was a second trial in 2014. And the question Google argued was actually, OK fine, this is copyrightable, but is it "fair use"?
The jury in that case found that yes this was a fair use. So, for a second reason they should have been allowed to use this. Then Oracle appealed again. And the same appeals court reversed that.
Now, we're heading on the third go-around. Google has won this case twice in district court. And it keeps getting sent back down from this weird court above.
Why is it a weird court to rule on this case? And why does that matter?
The important thing is that this court above doesn't even usually hear copyright cases. They only hear appeals on patent cases. But because this case had a patent element very early on that got knocked out, this is the court that it gets appealed to. So it's this really weird case, but there are billions and billions of dollars on the line.
Jeez. Hooray for the bureaucracy of the American legal system! So anyway, the case. Since a court ruled that the names themselves are copyrightable, what is this "fair use" thing all about? Shouldn't it not be OK for Google to use (and then profit off of) something that was created by another company?
A joke those of us following the trial make is about how heavily the lawyers relied on analogies to explain what's going on, and how APIs work. But they can actually be very useful because the concept of APIs is not that intuitive.
Suppose you're at a restaurant and the items on the menu might be a hamburger, fries, a milkshake, etc. If you were starting a new restaurant in town, you probably want to offer those same items, not call a burger something like a “meat sandwich.” As long as you’re making your own burger in the kitchen, nobody thinks that that’s stealing.
Another example was like, in a car, the gas pedal and the break pedal and the steering wheel are all in roughly the same place. It works better for both car manufacturers and for consumers to have that consistency.
So the API in question is like a hamburger? It's called the same thing, so that everyone who's building on the app can understand what it is they're making and doing. But the actual way you make the hamburger is different — so you should be able to use the name?
Yes. And, it may be that someone has already thought of how it was put together, too. But it doesn’t necessarily mean that no one else should be able to put it together in the same way.
So the district court found that Google was making "fair use" of the Java terms. What allowed the appeals court to overrule that?
Because this was a fair use trial, it gets even weirder. When you're determining whether a use is a fair use, first you have to say, OK, was there any copying? And no one disputed that there was, at least in these 37 API names.
Next, you ask, was the copying fair? And in order to determine whether it was fair, you do a four-factor test. One of the big important factors is the purpose and character of the use. So you say, was Google acting in good faith when they used it? And, was the use "transformative?" Or, in this case, was Google doing something different with the code than Oracle?
In the district court trial, you got the sense that the jury was convinced it was transformative — that Google was doing something different, something transformative, with the naming protocol, than Oracle was. A lot of that came down to how transformative smart phones were. Smart phones were a fundamentally different application of Java than what Oracle was doing with it.
But the Federal Circuit said no, and part of the reason they said "no" is because Oracle was able to point to some failed Java smart phones previously. And I use the world's biggest air quotes around smart phones. There was something that roughly ran software using Java, called "SavaJe."
SavaJe (with a J) was the company that was making Java smart phones in 2003 or whatever. Google's lawyer said, this is why they say our use is not transformative, because they say they were doing smart phones. And look at this. And you can look at the thing and just tell this is just flaming garbage. It's not a smartphone, it's not comparable to Android.
Ugh. So what does that mean for Google and Oracle?
The next phase is arguing damages in district court. Both of these companies are really rich. I’m not so worried about Google. Oracle made a big deal in the trial stage of how much money Google's made on Android, and Oracle wants a piece of that. The Android developer environment doesn't even use Java APIs anymore. And even if the judgement was billions and billions of dollars, Google will come up with the money.
But that's not the part that keeps me up at night.
You're worried that this hurts the little guys, right?
We've got decades and decades of precedent where the way computer science and the world of software advances works is that we make things that are compatible with other people's programs. And just a little better. And you have to compete based on, not having a monopoly on the interface, but by making the best program.
If that goes away — and it doesn't even have to fully go away — there may be just enough uncertainty on it that you have programmers who say "I'd love to make a new, better Facebook, but I can't."
The thing that's hard is that we won't see necessarily the software that doesn't get developed because people are too afraid of copyright lawsuits.
And that's the part that keeps me up at night.