Copyright is the thing that applies to works of authorship, like short stories and music. You can't copyright a fuel pump for a jet engine. You can't copyright function. That's patents, not copyright.
Software is somewhat unusual in that it's at the same time a work of authorship (code, copyrightable), and a set instructions for a machine to interpret (functional), and pure mathematics (facts about the universe, not subject to patent or copyright).
But an API is at the intersection of the functional part and the factual part. What distinguishes a literary work from a fact is that the literary work leaves room for creative expression. A copyright on an expression of a fact isn't a copyright on the fact itself, because someone else doesn't have to use your expression. They can create their own expression, so you having a copyright over your expression doesn't exclude them from using or conveying the same factual information.
When someone creates an implementation of an API, the API itself is a fact about how to interact with implementations of that API. There isn't any other way to interact with other implementations, so there is no room for creative expression in that aspect of a compatible implementation, so there is nothing there to copyright. You have to use the same API for entirely functional reasons or it's not compatible. And you can't copyright function.
Does the presence of third party Skyrim mods mean that everything they refer to is an API and therefore non-copyright? The game geometry, maps, characters and events are facts about Skyrim that those mods need to operate. Does this therefore imply that a hypothetical person could sell their own re-implementation of Skyrim on the grounds that all those things (characters, missions, events, geometry, models, etc) were function required for mods to continue to operate?
Or, to stretch it in a different direction, let's suppose I write some functions. If you write some functions that call them, presumably my API is therefore functionality and non-copyright? But what about if you don't call them, and only I happen to write calling code. It's still an API, it's still functionality required for other code to operate (my own), so is it still non-copyright?
What about whether I mark my code public? If I omit "public" from the same function definitions so they can't be called externally do the definitions become artistic and copyright? If so then is the artistry in the lack of a public keyword? If not then is any code structure copyright - it's all functionality that calling functions requires to operate.
Yes, that's deliberately playing logic games and taking things to extremes to see if there's a clear line in the sand. It's going to be interesting to see what the court determines, anyway, because it seems like a big question.
You're supposing that function being uncopyrightable narrows the copyright in the expression, but they're really just two completely different things.
Let's try an even more extreme example. Remember those anti-piracy book codes from a few decades ago? They'd sell a game with a printed manual and then to start the game you'd have to type in the third word of paragraph two on page seven of the manual.
We'll take the game copyright itself out of the equation by saying that the software is cheating by trying to restrict a copyright year 1800 work (expired copyright) using a copyright year 2000 book.
The book itself is clearly subject to copyright. It could be Harry Potter for all that matters. But the third word of paragraph two on page seven? That's a fact about the book. As is the fourth word of paragraph two on page seven, and so on.
If you collect every single fact about the book, you have all the information you need to reproduce a copy of the book. That neither means that facts are copyrightable nor that books are not. If you used all the facts to reproduce a printed copy of the book, that would clearly be copyright infringement. But if you collected and used all the facts only to solve the book code, not so much. Interoperability is solving the book code, not reproducing the book. Function, not expression.
And it has nothing to do with publication vs. secrecy because that's a copyright thing. Facts are facts whether you intended anybody else to know them or not.
We cheered for Compaq when they reverse engineered the IBM PC and started selling computers that could run software built for the IBM. We cheered Linux when it created a free alternative to the proprietary Unix interface. We cheered WINE when it made Windows APIs available under Linux. This kind of interoperability gives the rest of us the ability to reuse our own software without being beholden to the companies that created the original target platform.
Incidentally, there's a slight distinction in wording around API copyrights. I don't think there's a doubt that they can be copyrighted. Anything that is written down, recorded or filmed automatically receives copyright protection. The interesting question is whether there is a fair use exemption for interoperability. I think it would be obviously wrong if Google had taken Java and its APIs, renamed it Gava and then started pushing developers to write Gava software instead of Java. But they didn't, they just made Java be able to run on a new class of devices. If all you're doing is helping to ensure that existing code written by other developers can work with your product, that's a benefit for those developers too as well as the end users that buy and run the software.
This is factually untrue. Many things written down, recorded, and filmed do not receive copyright protection in the united states. A common example is recipes.
There is extremely good reason to think that APIs specifically fall into the set of things that can not be copyrighted. That's what the original ruling in this case was (overturned on appeal by the federal circuit). That's what a good portion of Google's brief argues.
Most relevant to this case is the merger doctrine. Ideas that can be expressed in only a small number of ways are not copyrightable.
Even more on point to your comment is the concept of copyright misuse. If you try to use your copyright (a government granted temporary monopoly on the reproduction of your work) to gain monopolies on other things you can not only lose the infringement case but in extreme cases even lose the copyright entirely.
https://en.wikipedia.org/wiki/Copyright_misuse
https://en.wikipedia.org/wiki/Idea%E2%80%93expression_distin...
The CC's opinion is of interest here:
> We further find that the district court erred in focusing its merger analysis on the options available to Google at the time of copying. It is well-established that copyrightability and the scope of protectable activity are to be evaluated at the time of creation, not at the time of infringement. See Apple Computer, Inc. v. Formula Int'l, Inc., 725 F.2d 521, 524 (9th Cir.1984) (quoting National Commission on New Technological Uses of Copyrighted Works, Final Report at 21 (1979) ("CONTU Report") (recognizing that the Copyright Act was designed "to protect all works of authorship from the moment of their fixation in any tangible medium of expression")). The focus is, therefore, on the options that were available to Sun/Oracle at the time it created the API packages. Of course, once Sun/Oracle created "java.lang.Math.max," programmers who want to use that particular package have to call it by that name. But, as the court acknowledged, nothing prevented Google from writing its own declaring code, along with its own implementing code, to achieve the same result. In such circumstances, the chosen expression simply does not merge with the idea being expressed.[7]
> copyright misuse
Inoperability with customers who have decided to use a service or product or lock-in due to said inoperability itself does not necessarily make the provider of the original service a monopoly.
Interoperability arguments have relevance in fair-use, but the courts have yet to determine if Google has a right to the APIs under fair use. Google and others may be entitled to the APIs under fair use, but the CC has determined that the SSO of APIs are copyrightable.
And fair use is yet another can of uncertainty, since usurpation of market share counts negatively to one's case for fair use.
====
In the case of APIs, a competing service can create a functionally identical competing API, but differently structured and organized and named, and then provide a competitor2us.sh script to help their customers migrate.
That said, I think fair use is more likely to apply than copyright misuse in this case. I just brought it up as one way that the judiciary is empowered to be lenient in their judgment on copyright infringement because of compatibility and lock-in.
Does the work become public domain or government royalty subject in that case? If the latter, it is worse since the government cannot be sued for copyright misuse, either.
The reasoning is quite simple and obvious: We have long-standing statutory and case law that defines specifically what is or isn't eligible for copyright protection, or patents, or trademarks. Your gut feelings about whether your API deserves protection because of how much effort you put into it are completely irrelevant to that legal framework.
There was a time when software didn’t have copyright protection. Somebody had to make the first move.
And all of the above is about the legal, technical questions about what the law is. The public policy question of what the law should be is a different matter entirely, and opinions about that generally should be addressed to Congress, not the Supreme Court.
I think you're mixing up different types of intellectual property:
- Trademarks are intended to identify a source. Trademarks cannot be functional, they have to be descriptive.
- Copyright must express a creative idea. That idea can be artistic, or functional. Computer code and APIs can be copyrighted (as they most often are), but they can also be patented.
- Patents cover inventions with some utility. One can definitely patent a piece of art if it provides some utility.
It's not uncommon for companies to throw all three at whatever they are cooking up.
Are they though?
Implementors aren't piggybacking on APIs because they can't come up with anything better, they can ... easily. They are implementing those APIs because they want compiled Java programs to run on their runtime.
Well, that's a difference without meaning. Familiarity with the syntax is important but we're not talking about copyrighting the language structure and syntax.
The other aspect is that of the wider ecosystem. Once you commit to Java, you have to reimplement the existing APIs because every Java library relies on those APIs. And it is that ecosystem that is the true value prop. The API itself isn't special itself (in fact, the Java one is frequently maligned for how bad it is), and devs adapt quickly to different ones when they move to another programming language. There would be no point in selecting the Java language without being able to partake in the ecosystem, no matter how brilliant the API design is. And if it was brilliant, they could have aped it in another language (Dart?) ... I'm making an assumption that presumably adapting the API to another language would be fine by you? Because if not, the mess you would cause in the industry would be immeasurable.
But I also think that it is better for the world with much less copyright protection in general.
The long version of both of those is made much better than I could hope to make it in the various briefs. You can find them all here: https://www.supremecourt.gov/search.aspx?filename=/docket/do...
Google's brief probably provides the best version of the legal arguments, that being their job. Read the text under the heading "The Federal Circuit erred in holding that the Java API declarations were copyrightable." on pages 16 to 21 and the text under "This Court Should Grant Review To Decide Whether, As The Jury Found, Petitioner’s Use Of A Software Interface In The Context Of Creating A New Computer Program Constitutes Fair Use" on pages 21 to 29. I personally find the merger doctrine arguments particularly convincing, starting on page 17. Here's a direct link https://www.supremecourt.gov/DocketPDF/18/18-956/81532/20190...
As for why it would be disastrous for the software industry, I particularly like this amicus brief, and would suggest reading section 2. It was written by 78 particularly famous computer scientists, including Steve Wozniak, Guido van Rossum, Ken Thompson, Bjarne Stroustrup, Martin Odersky, Peter Norvig, Brian Kernighan, and Alan Kay. https://www.supremecourt.gov/DocketPDF/18/18-956/89487/20190...
Here's an except, where one of the programmers for Java says that while he was creating Java's standard libraries he copied APIs in the same way ("Amicus" in this context means one of the computer scientists who wrote this brief to help better inform the court)
> Sun reimplemented existing APIs for Java. Java reimplemented C’s math API,which includes methods for calculating a variety of mathematical functions. While at Sun, amicus Joshua Bloch oversaw Sun’s reimplementation of the Perl programming language’s regular expression API for Java, which allows sophisticated text searches and alterations. Oracle’s attempt to copyright Java’s API and hold Google liable for infringement of the resulting java.util.regex API ignores Java’s own history of API reimplementation.
Here's an excerpt about an API you are probably familiar with, which hopefully underlies just how bad a compatability nightmare this ruling will create
> In 1983, the Berkeley Systems Research Group released the Berkeley Systems Distribution (BSD) sockets API. Sockets control the endpoints for any communication over the Internet. Because the BSD sockets API was not copyrighted, it became widely adopted: Every major operating system reimplemented it to enable Internet communication. Thus, programmers can write standardized software compatible across computers to manage Internet connectivity.
But really, read the whole of section 2.
I’ve always found it strange that other programmers are so dismissive of APIs as copyrightable work. They’re they hard part! Building APIs requires creativity and careful thought.
If you support the idea that APIs can’t be copyrighted, and ignoring the evilness of Oracle and Google, what’s your reasoning?