The Supreme Court has put an end to the years-long fight between Google and Oracle over the use of Java in Android. We’ve seen both sides get the win with appellate courts taking it away, and Google’s last loss in court had the company take this to the highest court in the land; the entire saga surely cost the company more than the $5 billion fine would have when you factor in time with the money.
In the end, this was all about the Benjamins.
In the end, the lawsuit wasn’t about Google using Java without a license, though Google did try and procure a license from Sun before Java was sold to Oracle. This case was about trying to force Google to license all of Java because it used some of the APIs to make things easier for developers. That is a horrible idea, and thankfully the majority of the Supreme Court agrees. Justices Clarence Thomas and Samuel Alito dissented, and Justice Amy Coney Barrett did not participate.
You can read the entire set of documents released by the court, including the dissent from Justice Thomas here. It’s worth a look if you’re really curious about the case, but for most of us, a synopsis works. Here are what I think are the relevant parts quoted from the papers.
- The Court’s opinion: Google’s copying of the Java SE API, which included only those lines of code that were needed to allow programmers to put their accrued talents to work in a new and transformative program, was a fair use of that material as a matter of law.
- Google copied approximately 11,500 lines of declaring code from the API, which amounts to virtually all the declaring code needed to call up hundreds of different tasks. Those 11,500 lines, however, are only 0.4 percent of the entire API at issue, which consists of 2.86 million total lines.
- As part of an interface, the copied lines are inherently bound together with uncopyrightable ideas (the overall organization of the API) and the creation of new creative expression (the code independently written by Google).
- Google’s limited copying of the API is a transformative use. Google copied only what was needed to allow programmers to work in a different computing environment without discarding a portion of a familiar programming language.
- Google copied portions of the Sun Java API precisely, and it did so in part for the same reason that Sun created those portions, namely, to enable programmers to call up implementing programs that would accomplish particular tasks.
Source: Android Central
You see Sun mentioned a few times here, and that’s because Google used Java (with Sun’s blessing) for developers to build Android apps and included direct copies of some APIs that you need if you want to use Java. This happened before Oracle purchased Java from Sun. And that’s really the core of the case, in my opinion — these APIs were developed and designed to be “open and free” for anyone to use in order to get more developers to use Java. And it worked — 2.5 billion people now use an Android device.
Because of Android, millions of developers use Java.
This ruling will have a big effect on the entire software industry because it sets a precedent for what portion of a work is copyrightable and what parts are not. If APIs were found to be protected works, AT&T would “own” part of iOS, and Oracle would “own” parts of Android. As crazy as that sounds, it’s because both used previous work to build something new.
J. Michael Keyes, a partner at the international law firm Dorsey & Whitney, has some insight about what this could mean for the future as more cases of this nature head into the courtroom.
The Supreme Court issued the biggest copyright decision in a generation today. It held that Google’s copying of Oracle’s API was fair use as a matter of law. It’s hard to overstate the significance of this decision.
The Court noted that fair use has “an important role to play for computer programs by providing a context-based check that keeps the copyright monopoly afforded to computer programs within its lawful bounds.” I suspect this theme will unlock many future arguments and claims regarding the application of fair use to software-related claims. We will see more copying, more cases, and more claims of fair use.
The Court clarified how reviewing courts should review fair use decisions. The ultimate question of whether the facts rise to the level of fair use is reviewed de novo. This means that there will always be room to argue on appeal that the jury or trial judge got it “wrong.”
Yes, courts often “get it wrong,” and that’s why there are appellate courts. In this case, getting it wrong could have had a major impact on every person who writes software and every company that builds tools to write software for its platform. That’s really what this lawsuit was about — the Android SDK, not the Android that runs on our phones.
Source: Jerry Hildenbrand / Android Central
It’s tough to get a grasp on it unless you’ve ever tried to write an Android app or used Java to build an app for another platform. Imagine you bought a robot that you could program. You tell it to do a thing by using an API, and the robot’s operating system kicks in to do the thing. The way you write the instruction (the API) needs to be available for any and every software development platform, but the code used by the robot to do the thing is proprietary.
The APIs in question need to be available to make Android developer-friendly.
In Android, the operating system is one part, and the way developers write apps is another. Android doesn’t run on top of Java, but the apps can be built using it. Those APIs need to be available because developers know how to use them. Oracle didn’t think so, though, so we got to witness a long and expensive legal battle.
Something tells me this isn’t the end here. As Keyes says, this will lead to more copying of code that a developer says is separate from the system itself and necessary, which will lead to more legal action — no company wants its code copied without a fee. It does bring an end to the battle for Google, which was already trying to move away from Java and is helping developers to use Kotlin instead.
Source: Daniel Bader / Android Central
Regardless of what any of us think, this is a giant moral victory for Google. No company wants to be called out as not doing the hard work to create software, and Oracle pushed that idea very hard. Having the highest court (this is a U.S. jurisdiction matter, courts in the E.U. have decided that APIs are never subject to copyright) vindicate Google was more important than the potential fine and fees.
For us, nothing changes. Except seeing Oracle versus Google less in our newsfeed.
For us, nothing changes. The best Android phones work the same way they did yesterday, and developers can write apps and build upon AOSP the same way they always have. But the whole journey has been interesting, and luckily, the outcome was the right one, in my opinion.