Oracle vs Google: One claim that should not stand

Oracle claims that Google appropriated the Java API fror Android and that money is due. That's not the way the law has worked in the past, nor how it should in the future
Written by Rupert Goodwins, Contributor

Can you copyright or patent an API? It's one of the key questions in the Oracle vs Google case, and one with huge consequences.

APIs — application programming interfaces — have been around in one form or another since the 1950s; they're the plug and sockets of software. There are a set of functions your computer can do for any program; the API describes how an application has to set up its data to use those functions. It's a simple idea and absolutely central to any workable concept of an open system where people are free to write or run software.

Android uses the Java APIs. It doesn't use Java — instead, Google has written a system called Dalvik that provides compatible APIs so that Java applications can run on it. Oracle says this infringes the intellectual property it owns in Java; Google says it doesn't.

It should be simple. Sun, which Oracle bought, invented Java and thus Oracle has normal inventor privilege. Yet that privilege does not cover APIs and never has. For while copyright protects any particular software that implements an API, in the same way that any novel that fleshes out a plot is copyright, the API itself is just a concept. You can't copyright concepts, as you can't copyright plots.

How about patents? While software that does a task in a particular way can be patented in the same way as a machine that does a particular task, the API just describes the knobs on the machine that operators have to twiddle. APIs transfer information, they don't transform it — and transformation is a central concept in patent law.

Software vs APIs

So: you can copyright a document or a piece of software that defines or implements an API, but that isn't the API itself. You can patent the methods in the software that uses the API, but the API itself is not part of the protected scheme and doesn't have any protection in its own right.

These are pivotal distinctions, because they prevent someone who invents an API from controlling all uses of it. You don't get to collect money every time someone sells software that uses the API, and you don't get to stop people who want to write software for your system but who don't want to enter into a commercial partnership. Other people can write compatible software without your permission.

Even at the peak of Microsoft's domination of desktop IT, people could and did write alternative operating systems that duplicated MS-DOS and Windows's API, and Microsoft couldn't legally stop them (although that didn't stop it trying alternatives). Which was just as well: the MS-DOS API was deliberately under-documented and lacked key features. You had to add those features for certain classes of software, such as networking, and to do that you had to replicate and take over aspects of the API. Without that ability, that software could not work.

APIs transfer information, they don't transform it — and transformation is a central concept in patent law.

And that's before the very basic idea that to use an operating system — or indeed, any shared software — you need to include at least some of the API standard in your application. It's what it's there for. While Microsoft, or indeed any proprietary software company, would very much like to be able to charge developers every time they distribute an application, APIs don't figure in the legally enforceable ways this can be done.

This has led to much greater diversity and much more freedom for developers, and has encouraged competition. In cases where companies attempt to restrict competition through interface control, such as IBM's battles in the 1970s with peripheral makers, such behaviour was found unacceptable by the US courts. Given the degree to which computer companies have borrowed each other's APIs, this has been to the good of all.

It's unlikely that Oracle will prevail with its API claims; unlikely, but not impossible. You just can't tell what will happen in court. But if APIs are added to the armoury of IP litigation, we'll be looking at a lot more court cases and a lot less freedom. That may not seem like a win for anyone.

Get the latest technology news and analysis, blogs and reviews delivered directly to your inbox with ZDNet UK's newsletters.
Editorial standards