There’s a dangerous meme going around that if Oracle loses its novel copyright claims against Google that suddenly the GPL will become unenforceable. This idea hinges on a misunderstanding about the difference between linking to a code library and merely using an API.
In this post I will attempt to explain in layman’s terms why the GPL does not depend on the copyrightability of APIs. For the same reasons, neither does any other free software or open source license.
Programmers usually write code in some human-readable form that is then “compiled” into machine code. The machine code, not the code that programmers actually write, is what a computer actually executes.
Programmers save themselves from having to reinvent the wheel by using code libraries. That is, they put statements into their programs that “call” prewritten pieces of code. The exact way they call these libraries is called an “Application Programming Interface,” or “API.”
When a program is compiled, and it calls such an API, the machine code the compiler produces is based, not just on the code the programmer has written, but on the code that is in the code library. In copyright terms, the compiled program is a “derivative work,” and it’s derivative not only of the programmer’s code, but of the code that is in the code library. The derivative work that is the compiled program can only be created with the permission of all of the relevant copyright owners. This means, of course, the person or organization that owns the copyright to the code libraries.
The GPL states that any derivative work that is based on GPL code must itself be licensed under the GPL. The GPL thus relies on the copyrightability of code libraries to work some of its viral magic. However, this has nothing to do with whether the method of calling a GPL’d code library is itself copyrighted. For what it’s worth, Richard Stallman, author of the GPL, appears to agree.
If a developer does not want to be subject to the licensing terms of a library, he has a few options. Most obviously he can use code libraries that allow him to create derivative works without being required to license them under any particular terms. Licenses such as the LGPL allow this. Or a developer can structure her code in such a way that it uses “dynamic” libraries; that is, external pieces of code that are not incorporated directly into the compiled program. If you are familiar with Windows then you have seen .dll files; there are such external pieces of compiled code. If these dynamic libraries are already installed on a user’s computer then the user can run the program without the developer needing any special license.
Another option for a developer is to do what Google did when it created Android, and create replacement code libraries that are compatible with the existing code libraries, but which are new copyrighted works. Being “compatible” in this context means that the new libraries are called in the same way that the old libraries are–that is, using the same APIs. But the actual copyrighted code that is being called is a new work. As long as the new developer didn’t actually copy code from the original libraries, the new libraries are not infringing. It does not infringe on the copyright of a piece of software to create a new piece of software that works the same way; copyright protects the actual expression (lines of code) but not the functionality of a program. The functionality of a program is protected by patent, or not at all.
In the Oracle/Google case, no one is arguing that code libraries themselves are not copyrightable. Of course they are and this is why the Google/Oracle dispute has no bearing on the enforceability of the GPL. Instead, the argument is about whether the method of using a code library, the APIs, is subject to a copyright that is independent of the copyright of the code itself. If the argument that APIs are not copyrightable prevails, programs that are created by statically-linking GPL’d code libraries will still be considered derivative works of the code libraries and will still have to be released under the GPL.
Though irrelevant to the enforceability of the GPL, the Oracle/Google dispute is still interesting. Oracle is claiming that Google, by creating compatible, replacement code libraries that are “called” in the same way as Oracle’s code libraries (that is, using the same APIs), infringed on some kind of copyright that inheres in the APIs themselves. This means that Oracle is claiming copyright not on the unique creative expression of its code libraries, but on the functionality of the libraries. Oracle is saying that to make a piece of software that is “API-compatible” with another product, without more, constitutes copyright infringement.
I believe that Oracle is wrong, but it is certainly a complex subject. Florian Mueller, who provides indispensable analysis of various intellectual property issues in the mobile industry, believes that whether an API is copyrightable can only be determined on a case-by-case basis. He is certainly right that the overall design of a system of APIs can show “creativity,” in the same sense that a brilliant mechanical invention is creative. But that does not mean that copyright is the proper way to protect that creativity, if at all. Copyright extends only to “original works of authorship fixed in a tangible medium of expression,” and a system of API calls does not meet that test. It is not a “fixed” work in the same way that an actual computer program is. I will not address whether a system of APIs is patentable, but certainly the creativity that a well-designed API scheme might show is closer to the creativity that a concise mathematical statement (not patentable) or a new design for an engine (patentable) might show. In any event, simply because something is “creative” in some sense does not mean that it deserves legal protection, unless it can be shown that some desired level of creativity would not happen without such protection. I do not see any evidence that the dynamic and innovative software industry requires copyright protection for APIs to maintain its current high level of creativity. Finally, I would take the legal opinions of software industry participants with a Bonneville Salt Flats’ worth of salt, since the easiest option for large companies is to simply assume that any and everything needs a “license.” This approach certainly reduces litigation risk. And remember that according to the software industry when you buy a computer program at a store you haven’t actually purchased and at no point actually own anything, not even the physical discs the program came on. So you be the judge of whether you want software industry practices determining the scope of the law.
But regardless of what you think about the proper relationship between copyright and API design, there is no risk to the GPL if Google prevails and Oracle’s APIs are found to be uncopyrightable. The GPL does not depend on some legally tenuous theory about the true nature of a system of API calls.