We’re asking the Supreme Court to protect Open APIs.
The lawsuit between Google and Oracle is the gift that keeps giving. The two companies have been battling over the Java/Android APIs since 2012 (see my previous blog on this HERE). We’ve now come to the point where the U.S. Supreme Court (aka SCOTUS) is the only place where things can be settled.
What’s at stake is ownership of APIs: specifically, can Oracle claim copyright to the Java APIs and prevent anyone from using them without permission? Worse still, if the Supreme Court declines to wade into this, we’ll end up in a situation where the rules in, for example, California are different from those in other parts of the country. Oh, and we’re not talking Java, but virtually any API out there is now subject to someone’s ownership and control - so get ready to rewrite everything, my developer friends.
What a cluster.
So, for the last few weeks, I’ve been dusting off my law books and trying to remember how to write a respectable legal brief (the result isn’t too bad!). We’ll be filing it with the Supremes in time for a Feb 25 deadline - encouraging them to take the case and settle the law on behalf of the developer community. Our argument goes like this:
When a developer writes original code, there is a universal understanding that they hold protected rights in their work. So far so good. To enable collaborative development and interoperability however, developers must be free to connect their own code to code that other developers have written. This is commonly done through Application Programming Interfaces (APIs) of course. Shared APIs are the established industry mechanism that promotes innovation while protecting the creative works of individual developers.
The struggle in the courts is over the format and ownership of the APIs themselves - the “declaring code”, not the implementing code in the background. While everyone agrees implementing code is protected, the question is who controls the actual API itself? If access to APIs remains separate and independent of rights to the implementing code in the background, then the ability to collaboratively create interoperable software and hardware will proceed at its current frenetic pace. If, on the other hand, both the use and implementation of APIs are subject to someone's control, then the API owner has a stranglehold on whatever code tries to use the software behind it. Even if someone rewrote every single line of code behind an API - the original author would keep control. That’s not the way code has been written for the last decade or two.
The long list of third parties that are involved in this case demonstrates how widespread the concerns are: computer science profs, the open source community, and people like us are trying to alert the courts to the tremendous ramifications of the changes the courts are contemplating. And while this is a US case, the software marketplace is international, and the world works hard to keep copyright laws in harmony via the WTO etc. I would expect any changes in US law to be felt in the EU in short order.
So, once again, a clash of giants is putting the whole damn industry at risk. If you’re a sucker for punishment, our brief is available for reading below. The direct link is here.
For our part, we’ve got our fingers crossed that SCOTUS takes up the case. THEN we’ll need to see what we can do to steer them towards an answer we can all live with.
Wish us luck. We’ll all need it.