“I’m not a doctor, but I play one on TV.” – Chris Robinson
I’m not a lawyer (thankfully), but that won’t stop me from rendering a legal opinion: This is nuts.
Let’s start with a car analogy. You decide that your trusty, rusty Ford F-150 pickup truck needs an oil change and a new oil filter. You buy the oil and the filter at your local auto-parts store, jack up the old wreck, and proceed to change them both in your driveway. Ford has no problem with this.
And why is this remarkable? Because Ford didn’t make the oil filter, and yet it fits perfectly in your Ford vehicle. It doesn’t even void the warranty.
Or let’s say you’ve lost your TV remote control and need a new one. No problem there, Amazon.com has dozens of alternative remotes for sale. Some are even “universal” remotes that can control almost anything, not just your TV. Did Sony or Samsung help design these aftermarket remotes? Nope, and yet they work just fine, either because the developers painstakingly reverse-engineered the IR protocol between the TV and the remote, or (more likely), because the TV manufacturer happily publishes the details of said protocol. It works either way, although the latter approach is easier.
So why can’t we do this for software? If I can write code that works with your code, can you sue me over that? The answer is: It depends. All last week, high-level executives from Google and Oracle have been arguing this point. At stake are $9 billion and the future of programming. That’s nine. Billion. Dollars. Seriously?
Here’s the recap: Sun Microsystems invented Java. Sun got acquired by Oracle. Lots of people use Java. Google also uses Java (sort of) in a little thing called Android. If you’re an Android programmer, you’re probably very familiar with Java.
Java is free – free to use, and free to distribute – but it’s not open-source. It’s owned by Oracle. You can have it for free, but you have to sign a license agreement. Mostly, it just says that you acknowledge that Oracle owns the software and you can’t modify it. No big deal, right?
When Google was creating Android, the programmers considered licensing Java from Sun but decided instead to create an equivalent work-alike version. A clean-room implementation, with none of Sun’s (now Oracle’s) code. Neither side disputes this. That’s not the problem.
The problem is that Google also recreated 37 of Java’s application programming interfaces (APIs). That seemed like a no-brainer. The whole idea was for Android to work like Java without actually being Java, so the APIs would naturally be similar. That way, programmers could use it without learning a whole new set of APIs. That wouldn’t be the worst thing in the world – lots of operating systems have their own APIs – but it would kind of defeat the purpose. Android was supposed to leverage programmers’ existing skillset.
Except that Oracle is saying (through its lawyers) that the APIs – and only the APIs – are subject to copyright and can’t be used without permission. Such permission not forthcoming, Google now owes Oracle $9 billion in damages.
Bear in mind that both sides agree that no actual code theft has occurred. No source code was copied, hijacked, or used without permission. Only the APIs. And since Google never took out a license for Java, it’s not entitled to use the Java APIs.
Can APIs even be copyrighted? Depends on whom you ask, and when you’re asking. The courts decided exactly this issue back in 2012 with a resounding “No!” The judge in that case said, “So long as the specific code used to implement a method is different, anyone is free under the Copyright Act to write his or her own code to carry out exactly the same function or specification of any methods used in the Java API.” Seems pretty clear to me. You can copyright code, but you can’t copyright the APIs for that code. You’re also allowed to create equivalent work-alike code, so long as it’s an original, “clean room” implementation.
Except that that ruling was overturned by another court two years later. A different judge in a different court ruled that, yes, you can copyright APIs after all.
Just to be clear, we’re talking about copyright here, not patents, not IP, not trade secrets, and not theft. We normally think of copyright in terms of books or printing (literally, the right to make a copy) – not in the world of software.
So despite the earlier court’s ruling, the current legal view is that APIs are indeed covered under copyright law. That’s both good news and bad news for the litigants.
Copyright law isn’t absolute. It’s not black and white. There’s a gray area called “fair use.” The doctrine of fair use allows you to copy very small examples of someone else’s work so that you can talk about it later. For example, you’re allowed to quote a few sentences from a book or repeat a few lines from a movie when you write a review about it. Musicians call it sampling. Without fair use, you could never mention anything about the book/movie/music you’d just experienced. You could conceivably even get sued just for using the word “the” because it appeared in someone else’s work and the copyright holder could say that you’d misappropriated the word from him. Silly, but that’s why we have fair use.
So how much leeway does fair use give you? It’s fuzzy. Even the U.S. Copyright Office seems unsure. “The distinction between what is fair use and what is infringement in a particular case will not always be clear or easily defined.” Well, that’s not comforting. It’s clear that there is certainly no minimum: “There is no specific number of words, lines, or notes that may safely be taken without permission.” But neither is there a maximum amount of borrowing that will automatically trigger alarm bells.
And would fair use even apply to software APIs? That’s what the court is trying to decide right now. Google is arguing that the APIs are purely functional, not creative works, and that renaming them, rearranging them, or making them work differently would hamper their effectiveness. It would also defeat the purpose, since the whole point was to make Android’s APIs work like Java’s. Even the judge in the overturned 2012 ruling thought so, saying, “Duplication of the command structure is necessary for interoperability.”
Plenty of other software companies see it the same way and have stood behind Google on this one. As I see it, the purpose of an API is to provide an interface between programs – programs likely written by different people working in different places and times. They’re a fixed point around which different creative ideas can coalesce. A software watering hole, if you will.
Without fixed APIs, we’d have no software stacks, no interfaces, and most of all, no open-source code. How else can an unregulated group of volunteers cooperate on a large software project like Linux or gnu without an agreed-upon set of APIs to work with? How can code be made modular without well-defined interfaces? How can we ever develop anything new if all other code is off-limits to us?
Sadly, that may have already happened. The recent flip-flop in legal status has made programmers nervous. Is my code covered under copyright law or isn’t it? Are that vendor’s APIs covered under copyright or aren’t they? And if they are, what constitutes fair use? Can I use one or two APIs with impunity? A dozen? How about 37? And who’s to say that some simple API wasn’t already used long ago by a long-forgotten RTOS? How long before the lawyers go Dumpster diving behind universities, looking for discarded printouts?
No matter how Oracle v. Google turns out, we’re all in trouble.