Oracle recently lost its attempt to use patent and copyright law to force Google to pay $9 billion for using parts of its Java computer language. Nine billion dollars isn’t chump change, not even for Google, but despite the verdict against Oracle, I’d say Google is not the only winner.
The dispute between the two internet giants was whether Google had needed Oracle’s permission to use computer code called the Java API. The API, and therefore the legal issue, relates to some pretty technical details about how computer programs work – how the instructions programmers write are followed on different hardware devices and different software operating systems.
The outcome of the case, decided in parts by a judge, an appeals court and a jury, was that Google’s use of computer code didn’t violate Oracle’s patents, and that Oracle could copyright its code. However, the jury found that Google’s use did not violate the copyright restrictions because it significantly expanded on the existing copyrighted materials, an exception in law called “fair use”.
It is not only a victory for Google, which has done nothing wrong and need not pay Oracle any money. Programmers remain allowed to use a very popular programming language without fear of crippling legal penalties – which in turn benefits the public, who use apps and websites made with Java. And while technically the legal loser, Oracle also won in a way, because it will benefit from Java’s continued popularity.
What’s an API?
To understand the heart of the dispute, we first need to grasp what an Application Programming Interface (API) is and what it does for programmers. At its simplest, an API defines the specific details of how a program interacts with a computer’s operating system and the underlying hardware.
Computer manufacturers use a wide range of specific components: hard drives and memory storage units with different sizes, faster or slower processing chips, smaller and larger screens. They also choose different operating systems, such as Windows, the Macintosh OS X, and Linux – each of which is regularly upgraded with a new version.
Each variation might handle basic functions differently – such as reading a file connecting to the internet, or drawing images on the screen. For a computer programmer, that is a nightmare. Nobody wants to write a program that works only on a Dell laptop with a 15-inch screen, a 500 GB hard drive, 4 GB of RAM, running Windows 10 – and no other computer. And nobody wants to write the extremely large number of slight variations to make sure a program works on every machine, either.
The API solves that problem for the programmer, handling the complicated and difficult details of exactly how any specific computer will act. That leaves programmers free to concentrate on what they want a computer program to do, without having to worry about precisely how. It’s better for the user, too. If she has (for example) Java installed on whatever computer she uses, programs written in Java will run.
The Java API contains methods for everything from reading and writing a file, to drawing on a screen, to handling web security certificates. Without a functioning copy of the API, programs in Java are fundamentally broken. Clearly, therefore, he who controls the API controls the language.
Oracle, when it bought Sun Microsystems, bought the rights to Java and its API. The crux of the legal battle was how this control is exerted and how far it extends.
No one denied that Oracle has a valid copyright on the language and API specification. This is a good thing. It means I can’t just make a copy of Java, give it a name (like “Darjeeling”), and call it a new language that I own. Similarly, a company can’t change the API arbitrarily and still call it the Java API.
What did Google do?
When it released Android in 2008, Google added software and hardware development to its existing internet service business. If its products were going to succeed, they needed to be able to run lots of interesting programs. The easiest way to do ensure that was to make sure the new devices could understand at least one computer language that’s already widely used by programmers. Java is a natural choice.
The alternative would have been to create a new language, but that pathway is fraught with difficulties. Introducing a new language requires convincing programmers that it is worth using and giving them time and resources to learn the language.
Once Google decided on Java, it needed to connect Java programs to Android’s hardware and software – it needed a Java API for Android.
Sharing names for computer commands
Rather than commissioning Oracle to write it, Google wrote the software in-house, customizing it for cellphone hardware. For example, Bluetooth, touch-screen gestures and telephone calls are not handled in Oracle’s standard Java API; they are solely in Android-specific code.
However, to be sure Android devices could run existing Java software, Google wrote its Android Java with some of the same commands as Oracle’s version of Java. Both Android and Oracle support the Java.io methods that let programmers use the same files.newInputStream(filename) command to initiate the arcane and complex Java file-reading process.
Google didn’t copy the code Oracle had written for other hardware or software systems. It wrote all-new Android-specific instructions for devices to follow each command, but to help programmers, gave many common commands the same name Oracle used.
Oracle’s lawyers sharpened their knives and the battle was on. Could Google use the same names, even if the code they referred to was different?
The stakes were high
If Oracle had won, Java’s days as a primary programming language for Android – the world’s most popular smartphone system – were numbered. Very quickly, Google would have chosen a new language for Android programmers to use, and published a conversion tool to translate existing Java apps into the new language. Then it would have stopped supporting Java. (I suspect one of Oracle’s competitors would have offered Google excellent licensing terms to choose another language.)
Programmers would have lost. The tools to write code for Android would have been, at a bare minimum, more expensive and less flexible. The public would have lost, because new and interesting apps would both be more expensive and released less frequently.
Finally, Oracle would have lost because programming in Java would no longer be a viable option for a major market. Computer languages compete for popularity, so fewer programmers would choose to program in Java, reducing the pool of people who were comfortable and competent in Java. Instead they would choose others, like Python or Ruby. With fewer people working in Java, Oracle’s primary way of making money from it (creating Java-based computer systems that can be expanded by third-party developers) would slowly decline.
Instead, while Oracle doesn’t get $9 billion from Google, the programming community – and those of us who use apps and websites every day – gets to keep using an important tool, without fear of a similarly large lawsuit in the future.Robert Harrison, Professor of Computer Science, Georgia State University
This article first appeared on The Conversation.