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.
This post was originally published on February 25th, 2019, but has been updated (December 2nd, 2019) to include the Supreme Court’s (November 15th, 2019) acceptance of the case.
We’re asking the Supreme Court to protect Open APIs.
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 that 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.
November 2019 Update: The Supreme Court FINALLY Takes the Case!
It’s been a long, long road for this one, but we can finally see the end. The Supreme Court has agreed to take up this case after years of it wandering around amongst various lower courts across the country.
This is a big deal because SCOTUS gets the last word on saying what the law is in this country.
While there’s a mountain of legal procedures, formats, and general mysticism involved in presenting a case to the Supreme Court, it all starts with a clear definition of the question you’re asking them to answer. Here, Google’s questions are:
Whether copyright protection extends to a software interface.
Whether, as the jury found, the petitioner’s use of a software interface in the context of creating a new computer program constitutes fair use.
The first one is pretty clear – it’s taking copyright law and finally answering how various coding practices fit. The second one needs a little unpacking as to what “fair use” is – and this will be a big part of what the court will need to wrestle with. “Fair use” is a concept that provides a bit of a carve-out for people that want to quote a small extract from a copyrighted work, or use a snippet for research, and so-on and so-on. The devil is in the details, and the question here is whether APIs – assuming you can hold copyright in them (question 1) – would fall under this doctrine to allow people to use them without explicit permission.
Our next step will be to file another brief in the weeks ahead in anticipation of oral arguments at the Supreme Court in the spring of 2020. We’ll be arguing both that APIs should NOT be copyrighted (the code behind them is), and that if they are, that fair use applies. The law is great in that you can argue both at the same time.
This may sound wonky, but again, this is important stuff if you hope to make a living writing code.
Please sign up for our newsletter if you’d like to stay informed on this and all the other stuff we do, and to lend us your moral support!