This article originally appeared in TechCrunch, and is republished here with permission.
The Supreme Court heard arguments October 7 in Google v. Oracle. This case raises a fundamental question for software developers and the open source community: whether copyright may prevent developers from using software’s functional interfaces – known as APIs – to advance innovation in software. The Court should say no — free and open APIs protect innovation, competition, and job mobility for software developers in America.
An interface allows two things to communicate. When we use an interface, we don’t need to understand (or care) about how the function on the other side of the interface is performed. It just works. When you sit down at your computer, the ‘qwerty’ keyboard allows you to rapidly put words on the screen. When you submit an online payment to a vendor, you are certain the funds will appear in the vendor’s account. It just works.
In the software world, interfaces between software programs are called “application programming interfaces” or APIs. APIs date back to the 1950s and allow developers to write programs that reuse other program functionality without knowing how that functionality is performed. If your program needs to sort a list, you could have it use a sorting program’s API to sort the list for your program. It just works.
Developers have historically used software interfaces free of copyright concerns, and this freedom has accelerated innovation, software interoperation, and developer job mobility. Developers using existing APIs save time and effort, allowing those savings to be refocused on new ideas. Developers can also reimplement APIs from one software platform to others, enabling innovation to flow freely across software platforms. Importantly, reusing APIs gives developers job portability, since knowledge of one set of APIs is more applicable cross-industry. The upcoming Google v. Oracle decision could change this, harming developers, open source software, and the entire software industry.
Google v. Oracle is the culmination of a decade-long dispute. Back in 2010, Oracle sued Google, arguing that Google’s Android operating system infringed Oracle’s rights in Java. After ten years, the dispute now boils down to whether Google’s reuse of Java APIs in Android was copyright infringement.
Prior to this case, most everyone assumed that copyright did not cover the use of functional software like APIs. Under that assumption, competing platforms’ API reimplementation allowed developers to build new yet familiar things according to the API bargain: everyone could use the API to build applications and platforms that interoperate with each other. Adhering to the API made things “just work.” But if the Google v. Oracle decision indicates that API reimplementation requires copyright permission, the bargain falls apart. Nothing “just works” unless platform makers say so; they now dictate rules for interoperability – charging developers huge prices for the platform or stopping rival, compatible platforms from being built.
If APIs are not free and open, platform creators can stop competing platforms from using compatible APIs. This lack of competition blocks platform innovation and harms developers who cannot as easily transfer their skills from project to project, job to job.
MySQL, Oracle’s popular database, reimplemented mSQL’s API’s so third-party applications for mSQL could be “ported easily” to MySQL. If copyright had restricted reimplementation of those APIs, adoption of MySQL, reusability of old mSQL programs, and the expansion achieved by the “LAMP” stack would have been stifled, and the whole ecosystem would be poorer for it. This and other examples of API reimplementation — IBM’s BIOS, Windows and WINE, UNIX and Linux, Windows and WSL, .NET and Mono, have driven perhaps the most amazing innovation in human history, with open source software becoming critical digital infrastructure for the world.
Similarly, a copyright block on API-compatible implementations puts developers at the mercy of platform makers say so – both for their skills and their programs. Once a program is written for a given set of APIs, that program is locked-in to the platform unless those APIs can also be used on other software platforms. And once a developer learns skills for how to use a given API, it’s much easier to reuse than retrain on APIs for another platform. If the platform creator decides to charge outrageous fees, or end platform support, the developer is stuck. For non-developers, imagine this: the ‘qwerty’ layout is copyrighted and the copyright owner decided to charge $1,000 dollars per keyboard. You would have a choice: retrain your hands or pay up.
All software used by anyone was created by developers. We should give developers the right to freely reimplement APIs, as developer ability to shift applications and skills between software ecosystems benefits everyone – we all get better software to accomplish more. I hope that the Supreme Court’s decision will pay heed to what developer experience has shown: Free and open APIs promote freedom, competition, innovation, and collaboration in tech.
A decision is expected by June 2021. Want to learn more in the meantime? Listen to the oral arguments, read the computer scientists’ brief cited in the arguments, and read about the history of APIs and copyright.
The decision will shape the future of the software industry, and is but one of many ongoing policy developments that will impact developers — all the more reason to be sure to vote in the upcoming 2020 U.S. Elections! We’ll be here to fight for developer opportunity, innovation, and collaboration no matter what.
Source: GitHub Old