Okay, either I'm crazy or everyone else is. Assuming the court isn't trying to set a new precedent with regards to software it seems like Oracle should have easily won this case. There is an argument to be made that APIs shouldn't be copyrightable but surely it's not fair use -- Google's use of Java doesn't even come close to meeting the criteria.
This is tricky because if you declare any API no matter how trivial copyrightable then the first guy to copyright a function to compute sqrt, tan, atan, etc wins. And if you can't copyright trivial interfaces then the question becomes where the line is drawn.
There's far more at stake than Oracle trying to squeeze money out of Google.
I completely agree, but I don't really know what to do about it. Surely a document describing a useful software interface (GUI, CLI, API) is a creative work and takes effort to produce. Unless we just agree that it's a necessary exception for the purposes of interoperbility I'm not sure how I would argue that it shouldn't fall under copyright protection.
Copyright would apply to the documentation itself, or the published header files themselves, as works; it wouldn't apply to the API itself.
Mind you, Oracle was suing Google for using the header files themselves; since Google could have easily just typed up their own versions that did the same thing, it's almost more of a "plagiarism" case than a "copyright infringement" case: they shipped something that was exactly from Oracle, rather than just paraphrasing it. Oracle was probably in the right to sue over that.
But re: APIs—there's much more well-resolved case-law for this, coming from the gaming vertical: games have copyright, but game designs (including things like their network protocols) do not. It has both pros (Microsoft can't use the Minecraft IP to sue Terraria or Factorio; people can advance AI by writing bots that play Starcraft) and cons (the iOS and Android stores being saturated with mechanical clones of each successful game) but it's very certainly "the way things are."
Actually, plagiarism and copyright infringement are different things. For example, it is possible to plagiarize something that is not copyrighted, and many forms of copyright infringement wouldn't fit the definition of plagiarism.
True, but the parent seems to think they wouldn't have been plagiarizing if they had "paraphrased" the declaring code so to speak, which makes the relationship here explicit. If they had paraphrased the declaring code, it would have been much harder to say they were infringing on copyright, but instead, they copied it verbatim.
Of course, in academia paraphrasing is still plagiarism, but it is likely no longer copyright infringement especially in this case.
> Of course, in academia paraphrasing is still plagiarism, but it is likely no longer copyright infringement especially in this case.
That seems an odd thing to say. A significant portion of academic writing is paraphrasing, with attribution. What is a review article, other than attributed paraphrasing?
I'm not 100% certain of all the details but isn't that exactly what Google tried, and failed, to assert originally? If I remember correctly, the 'fair use' argument only came up after Google lost on the 'can't copyright an interface' argument, and the real travesty here is not that Google are being denied fair use (because, you're right, it's not fair use), but that Oracle's copyright claim over the Java API ever held up at all.
There are two philosophies of copyright. One, that people/companies have a moral right to control their creative output, and the other, that copyright should be granted sparsely when it has a positive impact on society, such as promoting the writing of books.
Since APIs are a byproduct of software development, it is hard to see how it should be copyrightable under the second stance, but easy for the first.
Perhaps granting copyright, but setting precedence that basically any use is fair use, is a good compromise.
Someone should write a program that generates all possible function names and argument types and declares them copyrighted, then release them all to the public.
You could, by a similar method, generate all possible images but that doesn't mean you would be able to copyright them all. The creative element would become the act of identifying specific images within your set with artistic merit -- those would be copyrightable.
You're right. Sorry, merit is a loaded term in copyright discussions. I don't mean that they would have to argue that their choice of images has artistic merit, but that the artist would probably think it does to pick it out of the billions.
After the original trial verdict was overturned by the appeals court, I joked about copyrighting every single signature I could think of for print functions so that I could claim royalties from virtually every program in existent.
I understand the logic of saying that the API itself is a creative work and should be copyrighted. Creating a solid, logical API structure isn't simple.
But I believe the API signature itself (function name, argument types, return type) should not be copyrightable, in the interests of the industry as a whole. Google didn't steal the implementation, they just reused the same function signatures to make their drop-in replacement of the JVM work with existing software.
If developers can't even have the API signature without being sued, you are seriously hurting competition. It's just reality.
But, and I think this is really the main point, Google didn't just use the API signatures they used the API documentation to preserve the semantic meaning of those signatures which are necessary to make the API actually useful.
I think Google could argue very successfully that literally just the API signatures should fall under fair use but that's not really what this is about.
If I make a menu with the same items that your restaurant offers, it shouldn't be an issue of copyright, even if I preserve the "semantic meaning" of the menu items (copying the recipes, for example.)
Right! That's why I believe that Google's claim that it was 'just the method signatures' doesn't really hold up since they took not just the statement of the interface, but what each part does and how they interact. The only part Google didn't take was the source describing how to do it.
Oracle is in no way correct. Putting ridiculous barriers on software MADE FOR making software is ludicrous. Google is not making money because of the APIs, they simply used them because they already existed. Copyright is in a sorry state as it is. This IP nonsense is nonsense.
Google was found in violation of copying some source code if I am not mistaken, but this is about whether the concept of an API itself should be copyrightable, (how many ways can you write an API for a function that adds two integers together?) and that's the big problem here. If handled badly, it can literally kill the software industry.
What I don't get is Oracle not realizing that this could kill their SQL business if IBM decides to do some suing.
I mean the courts aren't exactly robotic in this sense. It has to be a creative work, for the same reason you couldn't try to copyright a trivial sentence you wouldn't get copyright protection on a method description that adds two numbers. Also, it's the whole work that's copyrighted, not its individual parts. It's not that Google just borrowed a few method signatures, it's that they took all of them along with their relationships and meanings.
You aren't wrong, but the fear is that copyright trolls would immediatelly take massive advantage of this new opportunity as well as that it could have a chilling effects on open-source projects.
Even if eventually found to be in the right, a random guy with a GitHub repo is not going to have the resources/will to effectively defend himself.
Courts in a common law jurisdiction (like the UK and US) don't have to try to set a precedent, each ruling tends to set a precedent. That is what makes common law common, the same law is applied everywhere, so any new ruling would be applied everywhere. This is exactly why judges avoid making rulings that would set a new precedent! I hope I haven't oversimplified a complicated subject!
* Purpose of the use -- Gogole's use wasn't transformative, in fact it was explicitly the opposite.
* Nature of the use -- Google could try to argue that their use was for the public benefit, but since the Android platform exists for business interests it probably shouldn't qualify.
* Amount and Substantiality -- Google basically took it all. There's no case here. They took not just the signatures but their semantic meaning (i.e. the thing that makes an API useful) as well. There's really not much else to an API design document.
* Effect on the market -- This one should be obvious. This directly hurts Oracle. Their implementation diminishes the market for the original. At least that's what their lawyer claims.
> Google concedes it put that code to the same use in the competing Android platform, for what this Court already has deemed "entirely commercial" purposes. And Google reaped billions of dollars while leaving Oracle's Java business in tatters.
The work Oracle copyrighted (and registered) was their implementation of Java SE as a whole, method bodies and all. Google copied only the interface.
If someone copies a paragraph of my novel and claims fair use, I won't get very far on the amount-and-substantiality front by saying "but they basically took all of the part that they copied".
> If someone copies a paragraph of my novel and claims fair use, I won't get very far on the amount-and-substantiality front by saying "but they basically took all of the part that they copied".
It's more like they copied the whole table of contents and rewrote your novel in their own words with all the headings copied verbatim. Good luck with claiming fair use on that.
I think it depends if you consider the part that was copied to be a standalone work. The fact that Google is able to create a separate implementation based only on the API design documents seems to suggest that it's a separate work that has meaning unto itself.
Would you make the same argument if you copied the entire forward from a novel?
A foreword is a lot more substantial all by itself.
Imagine if they copied the index of a textbook. It's possible to create a complete and compatible textbook using only that structure, but very few people would call it a separate work that has meaning unto itself.
In that case I think I would try the argument. But if I were on the jury I wouldn't be thinking "there's no case here".
If I understand how appealing jury decisions works, it isn't going to be anywhere near good enough for Oracle to argue that a reasonable jury might have decided the other way.
Your argument begs the question. You might as well argue "The fact that you were able to write a new novel around the word 'the' that you copied from my novel seems to suggest that the word 'the' is a separate work that has meaning unto itself."
If you write a function int makeHash(int) which computes a trapdoor function, and I write a function int makeHash(int) which prepares breakfast and returns a status code, then they have the same signature but different semantic meaning.
