If you're big enough and have enough lawyers, there's no reason to license software you want to build on.
What you could perhaps do is create your own implementation of the readline API distributed under a different license and then claim your program is intended to link against that, but how would you claim that if no such implementation exists? Whereas if you have to write your own readline implementation in order to use it then you still end up with a large incentive to avoid that by releasing your work under the GPL instead.
Can you elaborate on that? What does this have to do with those thing?
If Google can steal the code from the GPL version and then just not obey the license or pay for an enterprise license, dual licensing is dead and no business will open source their code under a dual licensing model.
Please.
They might use the GPL software, but feel no compunction to either open source their own modifications nor pay for an enterprise license.
For that matter, how does that have anything to do with the GPL at all? If you distribute your software under a proprietary license instead, how does that affect whether anyone can reimplement your API? If somebody wants your implementation then they get it under your license. If all they want is their own implementation of your API then your license doesn't matter, does it?
This ruling doesn't change that APIs are copyrightable code.
This decision sidestepped the question of whether APIs are copyrightable or not by declaring that this particular instance was fair use.
Reimplementing interfaces has always been fair-use, they are definitions. Re-Implementation of these interfaces has been a cornerstone of FOSS since its very beginning.
> So if fair use is granted for theft of copylefted code in a non-copyleft manner, it doesn't matter heavily whether that was "declaring code" or "implementing code".
I don't think these words mean what you think they mean. There was no theft and of course there is a difference between declaring code and implementing code.
Shesh...
This is incorrect, before fair use was tested, copyrightability was established, which is why the fair use defense, which is an exemption for copyright violation, was then determined. If you followed the various appeals and rulings this case entailed, you'd have to be aware of this.
APIs are copyrightable, as this case has determined, but now the Supreme Court has also thrown out any reasonable definition of what is and isn't fair use.
Ninth Circuit courts held APIs weren't copyrightable. The Federal Circuit (which only had jurisdiction because of the thrown out patent claims) held that they were copyrightable. The majority of SCOTUS here explicitly said they weren't deciding copyright of APIs. Instead they looked at both cases and said: "either it isn't copyrightable, but even if it is copyrightable, that this is fair use." Either way, Oracle loses. Arguing in the alternative is a common legal pattern, as is ruling on the narrowest possible ground.
Generally when a circuit court makes a ruling, it's only "binding" precedent on subsidiary courts within that same circuit. The federal circuit is weird though, as it doesn't have a geographical jurisdiction, instead it has a subject matter jurisdiction. If a case has patent claims (or a few other things), an appeal gets routed there.
So, effectively, APIs are copyrightable if there is a linked patent claim in the same lawsuit.
Courts can certainly use the Federal Circuit ruling as "persuasive" precedent, and rule the same way, but it's not binding, and it's not settled law.
I suspect the Supreme Court would not be happy if a pattern develops where companies include spurious patent claims in order to get their copyright case heard by the Federal Circuit instead of one of the other circuits. They won't want another mess like this case, and if the Federal Circuit again rules in favor of API copyright and against fair use, I would expect the Supreme Court to rule on the API copyright question directly rather than merely clarify the bounds of fair use as in this case.
The supreme court explicitly refused to rule on whether code was copyrightable or not.
The lower courts made conflicting rulings on that question. But the supreme court itself only assumed, for the safe of argument, that code was copyrightable, and did not rule on that question itself.