Google’s copying of the Java SE API was fair use [pdf]
supremecourt.gov
supremecourt.gov
https://news.ycombinator.com/item?id=26699106&p=2
https://news.ycombinator.com/item?id=26699106&p=3
(If you've already seen a bunch of these, I apologize for the annoying repetition.)
One of the big open questions is "are APIs copyrightable?" The court skirted that question, and instead focused on whether it was fair use:
> To decide no more than is necessary to resolve this case, the Court assumes for argument’s sake that the copied lines can be copyrighted, and focuses on whether Google’s use of those lines was a “fair use.”
That said, this case does establish a precedent that if your copying of an API is primarily for purposes of matching an interface so that developers can reimplement it, you're in fair use territory:
> Google copied these lines not because of their creativity or beauty but because they would allow programmers to bring their skills to a new smartphone computing environment.
I'll count that as a win, on balance.
I understand the intuition you're getting at: logically, the first question could make the second irrelevant. But if the second question resolves the issue even when the first is construed in favor of the other party, what's the rationale for demanding the court focus on the first question?
A. We decide this is fair use based on the small number of LOC used and call it a day
B. OR we can decide that APIs are not copyrightable even though they're self-evidently creative works because of the importance of interoperability based on something something related to Borland v. Lotus, a case that we couldn't agree on the last time it came up.
Hey folks. Let's do A.
Avoiding the temptation to set bigger and more far-reaching precedents than is strictly necessary for the case at hand avoids giving the impression that the judicial branch is doing the job of the legislative branch.
I have fundamental problems with an unelected council that serves for life creating law.
However, we have an extremely inefficient form of Government that doesn't allow for quick adaptation, and legal questions will arise tomorrow that did not occur to legislators today. The courts are supposed to help resolve any ambiguity.
The question over whether or not APIs are copyrightable is, however, not a question of ambiguity. APIs are software (or documentation, or source code, etc), and any category you place them into is copyrightable under the current law. If we don't want APIs to be copyrightable, then they must have explicit exemptions carved out in the law. The courts are bound to consider an API as copyrighted right now, and the only question is whether violating that copyright is fair-use.
I think the Court did the right thing in skirting the question. That's up to legislators, the Court cannot help. We need fundamental reform of IP protections for software anyway.
That really is the root issue here. So many problems we're seeing (Pai's clownshow in the FCC, SCOTUS legislating from the bench, federal agencies trampling citizens' rights, etc.) stem from the legislative branch abdicating their authority to third parties -- the librarian of Congress, the FCC, SCOTUS, and even (by legal reference) professional organizations and laws in other countries. It's ridiculous.
A first principle of a democratic government is that citizens can soon fire someone whose legislation and/or executive decision they do not like. We would all have voted Pai out if we could have... but he shouldn't have had the power to do what he did in the first place (remove network neutrality rules). Congress gave him that power - which I would argue was an abdication of authority vested in them.
Legislators assigning regulatory power to bureaucratic agencies is one of the cornerstones of modern democracies - it wouldn't work otherwise. Many of our legislators are barely qualified to send their own emails, let alone decide what is a telecom utility or how much ppb in drinking water is safe for a toxic chemical. Assigning that power to regulatory agencies allows experts to decide those issues in a neutral setting.
Pai's FCC aside, that structure prevented significant disruptions in the last four years and our country continues to function despite decades of increased partisanship and deadlock at the highest level.
Agreed that regulatory agencies are indispensable. But their job is to carry out the law, not make the law. Of course, the law has to delegate some decision-making responsibility to them -- the law can't make every decision ahead of time. But (a) the law can codify principles that regulatory agencies must uphold, and (b) lawsuits can be filed when someone disagrees that a principle has been accurately upheld -- the courts can decide.
We as a country ought to be arguing and disagreeing about principles, and the results (decided by legislators who are under the gun of potential non-reelection) ought to be codified as laws. A lack of principle in congress and in law is what really causes this abdication and delegation of authority.
An ideal legal corpus represents (as much as possible) a simply and directly expressed set of principles under which the country operates.
It is difficult to talk about "regulations" in the abstract but I would suggest that many regulations aren't about a perfect solution devised by an expert. They are more often about finding a tradeoff, a balance between competing goals. Those sorts of decisions can be informed by "expert" knowledge, but I think it is a mistake to think that domain experts are necessarily best positioned to resolve tradeoffs in public policy.
I'm not arguing against expert knowledge being incorporated into construction of regulations -- just pointing out that expert knowledge may be necessary but not sufficient to finding a workable public policy.
If your democratically elected legislators don't like a bench ruling, they are free to make a new law that specifically overrides that ruling. The legislature is the ultimate source of authority in the land. The courts only have a bit of wiggle room in interpreting unclear statutes.
The system is designed well. Unfortunately, democratically elected legislators at the moment would rather obstruct, wreck, and go on wild-ass conspiracy rants, than legislate.
If that legislature spent half the time it complains about activist judges actually drafting law, it would have nothing to complain about. If you, as a constituent are unhappy about the current state of affairs, vote in legislators who are willing to do their job.
But I really do think this case falls squarely inside the parameters of "interpretation" as most members would see it.
Well, that's the theory.
In fact, they are doing the job of the legislative branch, they can't stop people from noticing this, and sticking to this approach just means they're doing their job badly.
In an earlier concurring opinion when he was on the D.C. Circuit — i.e., before joining the Supreme Court as Chief Justice of the United States (his official title) — John Roberts referred to "... the cardinal principle of judicial restraint — if it is not necessary to decide more, it is necessary not to decide more ...." [0]
[0] https://scholar.google.com/scholar_case?case=192785774326304...
The main influence of the Supreme Court is in setting precedent. In the absence of a ruling from the Supreme Court, the previous ruling from the Court of Appeals for the Federal Circuit is binding precedent on the whole country that APIs are copyrightable. That means that the most important precedents set in this case are still an issue for the software industry.
This is not true - other circuit courts are free to set their own, conflicting precedent. Each circuit's decisions are binding only on its own judges, and suggestive but not binding on other circuits.
Circuits deciding differently (a "circuit split") is uncommon, and considered urgent grounds for the Supreme Court to take up a test case to resolve the ambiguity; but it's not considered a "breaking" of precedent by either circuit, just a difference of interpretation for the Supreme Court to resolve
That said I do not actually know whether they would be binding on another circuit court. But they are definitely binding on all federal courts lower than that.
However that question is sort of moot. It is extremely easy for the entity filing the case for infringement to include something about patent or trademark in the suit, which guarantees that you wind up in the Court of Appeals for the Federal Circuit. Where that ruling is binding.
Copyright is not part of their subject matter jurisdiction.
> However that question is sort of moot. It is extremely easy for the entity filing the case for infringement to include something about patent or trademark in the suit, which guarantees that you wind up in the Court of Appeals for the Federal Circuit. Where that ruling is binding.
It’s not, though; outside of its own subject matter jurisdiction, CAFC is bound by the law of the Circuit to which the trial court belongs, which it, in theory, merely applies. Another case coming up through the Northern District of California like Oracle v. Google did would be governed vy Ninth Circuit, not Federal Circuit, copyright precedent even if heard in the Federal Circuit because of other issues in the case.
No, its not.
The CAFC’s interpretation of Ninth Amendment case law on copyrightability in this case (before and after the Supreme Court sidestepped it) is binding on no one except future courts hearing cases on issues and between parties so closely related to those in Oracle v. Google that res judicata rather than rules of precedent is the deciding factor
Which is obviously false. A fair use analysis can -only- take place if the assumption is the code is copyrightable; if the majority had first decided the code was not copyrightable, fair use is immaterial.
Thomas' argument, if followed, would either have led to this same decision, or would make the opposite point he was trying to make.
Within that, and with my incredibly limited understanding of how law evolves in the courts...it seems like Thomas says demonstrably incorrect things more frequently than I am comfortable with.
If you read pdonis’s reply to your parent, you will see that Thomas was rather correct in the way law should have applied in this case. I find that in the limited few of few cases I have read , I politically like the judgement made but I identify more with how Thomas thought about the case.
Really fascinated by the American legal system. In some ways really elegant and so much better than the legal system in my own country.
Which is obviously false. A fair use analysis can -only- take place if the assumption is the code is copyrightable
You are not disputing Thomas's point; you are agreeing with it. Thomas's point was exactly that, before even embarking on a fair use analysis, the Court should have first decided the question of whether the code was copyrightable. In the absence of a finding that the code was copyrightable, fair use analysis indeed makes no sense.
The "cannot square" part of Thomas's statement is just saying that the reason the majority did not even attempt to decide the question of whether the code was copyrightable was that the reasoning they would have had to use in order to find that it was copyrightable--which they would have had to do to even embark on a fair use analysis--would also have completely invalidated the reasoning they used to decide that Google's use was fair use. In other words, they are simply ignoring a glaring inconsistency in their position.
A decision that the code was not copyrightable in the first place would have been consistent, but the Court did not do that. A decision that the code was copyrightable and Google's use was not fair use would have been consistent, but the Court did not do that either. Instead, Thomas is saying, the Court decided that Google's use was fair use, on grounds that are inconsistent with the code even being copyrightable at all. As much as I hate to side with Oracle, I have to agree with Thomas on this point. The Court should either have ruled explicitly that the code was not copyrightable at all, or should have refused to let Google get away with what is obviously not fair use if the code is copyrightable.
> Thomas' argument, if followed, would either have led to this same decision, or would make the opposite point he was trying to make.
No, Thomas's argument, if followed, would end up with the opposite decision from the one the Court made: that Google's use was not fair use and that the decision below should have been affirmed, not reversed.
The thing is that fair use implies the underlying data was copyrighted, but something being copyrighted doesn't imply fair use, which is why I think your analysis is backwards.
For those who may not understand: in the US, fair use is a defense, not a right. By arguing that your usage was fair use, you are admitting to copyright infringement. Just that your infringement was fair use. The analogy above to self defense is a good one; By arguing your killing was self defense, you are admitting that you killed somebody, but that it was justified.
No, its actually fairly common to argue both that an act wasn’t infringement but, if it was, it would be fair use.
One way you might do this is to argue that the thing copied was outside the scope of copyright, bur then argue that, if it was covered by copyright, it would be fair use.
That was, in fact, Google’s argument in this very case.
I agree such arguments are fairly common, but that doesn't make them any less fishy, in my view.
Where there are contradictory assertions of fact in the various defenses, I agree there's something... uncomfortable about it, at least.
But I don't think that applies in a case like "it's fair use, anyway." If we imagine a case where someone copied a small bit of written material for criticism or educational purposes, something clearly fair use, introducing uncertainty about whether the document had been placed in the public domain doesn't cloud the question of whether the behavior was okay, and answering the question in the easier way doesn't force any conclusions about the other matter.
...then we are imagining a case totally unlike this one, where Google copied the entirety of Oracle's API interface declaration code for the purpose of using it to make money. This is one of the key points Thomas makes in his dissent. So this case is not a case of "we weren't sure whether the material was copyrightable, but in any case our use was clearly for a purpose that would be fair use if it was".
Another point in this respect that Thomas makes is that Google tried four times to get a license from Oracle to use their Java API code, before just copying it and using it anyway. That shows what, in legal terms, would be called mens rea--Google clearly knew the code was copyrightable, because if it weren't, they would not have tried to get a license. So Google now saying they aren't sure the code was copyrightable, as they did in their brief in this case, is, to say the least, disingenuous.
That was my intent. My comment was meant to move to a setting where judgement was clear and then bring it back to see what was preserved; I don't think it did a good job of the second half of that.
> Google tried four times to get a license from Oracle to use their Java API code
Did Google try to license just the API? My understanding was that they tried to license the implementation, and eventually went with a (purported?) clean-room reimplementation. That doesn't seem to indicate a belief (or even a worry) that the interface itself is covered by copyright.
> Google clearly knew the code was copyrightable, because if it weren't, they would not have tried to get a license.
Even ignoring the previous point, I don't think that follows. Outcomes in law are rarely certain; "pay not to have to deal with the question" is not necessarily a bad response to ambiguity (particularly when that ambiguity was created by law and the courts rather than the counter-party, in which case there is concern about motivating more such ambiguity).
The majority supreme court opinion basically said "even assuming it is copyrightable, this IS fair use", with the implication that if it's not copyrightable, there is no case, so the same outcome, a win for Google. They intentionally were keeping their decision as little precedent setting as possible.
Thomas' dissent said "you can't decide this based on hypotheticals! You have to decide whether it's copyrightable or not first!" - had justice Thomas felt the code was not copyrightable in the first place he could have written his own concurring opinion. In fact, he did not; his position, as made clear in his dissent, was that he felt APIs -were- copyrightable, AND that this was not fair use.
The court did not agree with him. And had the court first started with addressing whether an API was copyrightable, the outcome would have either been they are not (a more far reaching decision, but still a win for Google), or that they were, and that this was fair use (so the same outcome, but now with, again, a more far reaching decision).
You claim that Thomas is saying that "if the court decided it was copyrightable, then they would have also had to have found this was not fair use". If that is indeed what he said (not my take on it, but I'll grant it), that is false on the face of it, as that is -explicitly what the court did not do-. They accepted it was copyrightable as a hypothetical, and then focused solely on, if that is true, was this was fair use? And they found that it was. To form an argument in this way is logically consistent; Thomas may disagree with it, as is his right, but the statement that the court has made a logical error is absurd.
Again, you are not disagreeing; you are agreeing. Thomas is arguing that the appeals court's ruling, which you correctly describe, should have been affirmed. Which is the opposite decision from the one the Court made, just as I said.
> The majority supreme court opinion basically said "even assuming it is copyrightable, this IS fair use"
Here is the exact quote from the opinion:
"we assume, for argument’s sake, that the material was copyrightable. But we hold that the copying here at issue nonetheless constituted a fair use."
In other words, the Court did not even consider the question of whether or not the material was copyrightable. They assumed it "for the sake of argument", which is just a dodge. They should have considered the question directly; and here is what Thomas says about that:
"The majority purports to assume, without deciding, that the code is protected. But its fair-use analysis is wholly inconsistent with the substantial protection Congress gave to computer code. By skipping over the copyrightability question, the majority disregards half the relevant statutory text and distorts its fair-use analysis."
Further comments below.
> You claim that Thomas is saying that "if the court decided it was copyrightable, then they would have also had to have found this was not fair use".
Yes, because the relevant facts that would support a ruling, based on the statute, that the code was copyrightable, also indicate, based on the statute, that Google's use was not fair use. But by skipping over the copyrightability analysis, the majority is simply ignoring those facts and those portions of the statute. That is Thomas's point.
> To form an argument in this way is logically consistent
Not if it ignores additional information that is not consistent with information used in the argument. Thomas is not saying that the Court's argument is logically inconsistent on its face. He's saying that it's inconsistent once you put back in the information that the Court left out: the facts that support a ruling, based on the statute, that the code was copyrightable, also support a ruling, based on the statute, that Google's use was not fair use. The majority is simply failing to consider those facts.
In other words, the Court can't just "assume for the sake of argument" that the code is copyrightable in a vacuum. They have to take into account the relevant facts of the case that support such an assumption, and consider the implications of those facts, and the relevant parts of the statute, for the fair use analysis.
That is your assumption. You assume the majority ignored that additional information. You say the court is failing to consider the facts that would indicate it copyrightable; that is -assumption- on your part. The court had the same set of facts in front of it (read: the entire body of relevant law); the majority chose to apply them to a different problem than the one Thomas wanted them to be applied to, and came to a different outcome than the one Thomas wanted.
The court can totally "assume for the sake of argument"; it does not reduce the surface of the law, it does not take facts out of the equation. It just makes arguing one part of it moot.
If they didn't, why is it never even mentioned in the opinion? Why does the majority not even acknowledge the fact that there are other facts involved, which do not support their conclusion?
Of course any answer I might propose would also be an "assumption" to you, but I'll propose one anyway: because the majority knew quite well that if they did mention or acknowledge any of those other facts, it would be obvious to anyone reading the opinion that their argument was not cogent. My reading of many, many other Supreme Court opinions over the years tells me that that kind of thing happens all the time. At least dissenting opinions are available, though it seems like the ones that really point out fundamental flaws, like this one by Thomas, never actually get any traction.
> The court can totally "assume for the sake of argument"
The court can of course do whatever it pleases; there is no higher court of appeal to overrule them, and the Justices serve for life so they can simply not care what anyone else thinks of their rulings.
That doesn't make it right when they twist the law, or outright ignore it, to produce rulings that are in accordance with their ideological preconceptions. Which, again, is something that happens all the time.
If they shouldn't be copyrightable because the world would be better off, interoperability between business is harmed, it is up to congress to change the law. Historically legislation like this harms smaller companies mostly, larger companies can better afford to deal with the requirement to license or the cost/work required to stick to fair use or litigate over it, so the larger companies that can afford to lobby to change the law aren't going to want them changed.
This case certainly sets precedent that API re-implementation can be fair use, not that it always is. Fair use is very fact specific, based on a four part test where having one part in favor can be fair use, and having three parts in your favor can still be infringement. A future case with products that would have a more substantial effect on the market of the original work, or had more of the original work reused than was strictly necessary could very well be infringement. With regards to "the amount and substantiality of the portion used" in this case less than 1% of the original code was copied just measuring the lines of code. Substantiality is harder to put a number on, but arguably it was only a small portion of the original product. This is a very low and for many other APIs a more substantial portion would need to be copied to be useful. The precedential value of this case is unclear without either the law changing, or further litigation.
If presence and order of keywords was sufficient, such legal precedence would create collateral damage at levels that is beyond absurd - outside of software, this would extend to atypical calendar formats, plenty of paper forms, automatic telephone voice menus, map projections, and so much more. Calling it "destructive" wouldn't suffice. Entire industries would be leveled by uncooperative rent seekers that hold old copyrights.
Paper forms are often protected by copyright, as long as they have creative non functional elements. And they are licensed much like stock photos in some industries.
There would be some APIs or code that only contain functional elements and aren't eligible for copyright protection, but in most cases there is a substantial amount that is not only functional.
Copyright protects works fixed in a physical media, not the underlying idea. Many people can create similar works based on the same underlying ideas. Like with a map projection a specific implementation can be protected by copyright. But the idea of a map projection where a constant bearing in the real world corresponds to a straight line on a map cannot be protected by copyright, someone else could create their own version that does the same thing without infringement.
Copyright only protects against copying, not against independent creation of the same work. With something like a calendar, or in some cases an API that only has a few creative elements, multiple people could make the same choices and create the exact same thing without there being any infringement.
This type of API copyright would post likely not just mean the paper form is under copyright protection, but that the software to OCR scan it and parse it would also likewise be protected - as it is an ordered series of keywords with types, etc. It would then be a license infringement to parse forms without a license.
Independent creation is legal defense, not a cause for dismissal of a suit. You need to prove it - which becomes harder if they can argue you saw their work first and imitated theirs.
There's precedence where people have created their own works from scratch and held to be infringing because they mimicked an existing work too closely (like one case of a photo of a red London bus), and in civil copyright lawsuits the other copyright holder only needs to show its likely, which may reduce to showing you knew their work existed.
In deference to OP, the question was never "Are APIs copyrightable?" The question was is what Google did in taking header information and doing their own implementation fair use, and it's unquestionably good now that the SCOTUS said this is fair use. Make sure to actually do your own implementation though.
Sun/Oracle didn't want to fragment Java, they copyrighted the language spec, and provided the JVM under SCSL before GPL. Java isn't fragmented, Sun/Oracle got what they wanted.
It's a lot easier to say what Google did was fair use than decide where to draw the line on where an API is in a software project and whether it is copyrightable or not.
Playing Kremlinology here, it feels like Breyer originally had an opinion that explained that APIs were not copyrightable, but sacrificed that section of the opinion to build a 6-2 majority. It's really weird that the opinions took so long to come out for how simple they end up being--why is this coming it in early April instead of early/mid February if it's written like this? My supposition is that there was a much more sharply divided court, running a 3-3-2 or 4-2-2 opinion, and by dropping the discussion of whether or not the APIs were copyrightable and instead saying "it's at best thin copyright" (i.e., it's copyrightable but good luck ever winning infringement) the opinions collapsed down into a more simple outcome. One thing's for sure: this is the case I'm most interested in finding out all the backroom discussions that went on here.
From the market effect part of the opinion, it's Oracle who should be worried if they're different enough from AWS or maybe not if learning any widely-used API means it's a loss if not copied. The WINEs of the world should be safe, Microsoft was never going to bring Win32 or DirectX to Linux.
In my cursory readings about merger doctrine, it's been around for decades, but hasn't been widely adopted by courts, and the justices by little surprise couldn't agree (3-3 or 4-2). The open source lawyers love it, but that means little. Fair use is about as good as it was ever really going to get for the foreseeable future. The industry is just going to have to settle for this or maybe pool it's copyrights like OIN does for patents.
Well, if you can an API for any primary purpose that not making software compatible with the one you are copying, then it's not really an API. It's perfectly fine if you can't frame it and sell around as a painting.
Is the difference that there's no SCOTUS precedent on the issue because it wasn't addressed in this case? Because (IANAL but) I'd assume the bench direction is itself precedent... In that if another circuit court tried to run a case as if the question was in the open, the Court would again ruler-slap them and say "No, assume APIs are copyrightable, plain language of the law."
From page 1 of the opinion, i.e. the actual ruling, which follows the "syllabus" in the pdf. The syllabus is basically just a summary. It's page 5 of the pdf.
Current status, if I understand correctly, is that SCOTUS has not weighed in on whether APIs may be subject to copyright, and precedent in (Edit: Ninth Circuit) should be that they are to be considered copyrightable (and, I suppose, "no precedent in this circuit or from the Supreme Court" in all other circuits).
>> Google copied these lines not because of their creativity or beauty but because they would allow programmers to bring their skills to a new smartphone computing environment.
It's even weaker than you think. It was important that Google's use of Java's API was on a non-competing product. It's still quite up in the air what happens if you provide a generic library using your competitor's API without licensing it from them.
A) J2ME targeted feature phones.
B) Google isn't accused of copying J2ME when you get down to it. The parts that make ME distinct from SE weren't reimplemented in Android's Harmony fork (looking strongly at javax.microedition), and a lot of packages that SE implemented that ME didn't were present in Android.
And you still haven't addressed why anyone should prefer APIs to be covered by copyright rather than patent law, when patents have much shorter duration and are more easily challenged.
Those words were in the previous post.
> And you still haven't addressed why anyone should prefer APIs to be covered by copyright rather than patent law, when patents have much shorter duration and are more easily challenged.
If we know it would be fair use, then copyright is rendered harmless. So in the choice between patents and neutered copyright, it patents are worse.
Algorithms and logical constructs like computer code aren't patentable under US law if that's what you're talking about.
If you patent a method how to organize APIs, that would be perfectly reasonable. In fact we have a bunch of patents like that for networking stuff.
One of the big open questions is "are APIs copyrightable?"
IMHO they got the Huffman table wrong, although arguably it was the result compelled by an overprotective approach.
I did cry a little at the court's assertion creating the huffman table required "a very great deal of hard work". Gather a corpus of databases you have lying around, count the occurrences of each byte value and apply a <50 line algorithm that has been around since the 1950s and is a pretty standard university assignment. "a very great deal of hard work" indeed.
Presumably division 4A / s47D would now allow the cloning of the data table if decided today -- are you aware of any post-1999 case law?
It is even less decisive than you're saying.
The fact that the Supreme Court decided not to overturn the decision of the Court of Appeals for the Federal Circuit that APIs are copyrightable means that binding precedent on every court except the Supreme is that they are. And for fair use, one of the statutory factors is the "effect" of the copying on the "market for or value of the copyrighted work."
That said, this case does establish a precedent that if your copying of an API is primarily for purposes of matching an interface so that developers can reimplement it, you're in fair use territory:
The fact that one statutory factor points one way doesn't stop another from pointing the other. And part of their decision is the conclusion that Google's copying increased the value of Java. That will generally not be true when APIs get copied.
In particular if I am trying to create a product that competes with yours, and I copy your API for the purpose of interoperability, I'm going to have an uphill battle claiming fair use. Because my product directly reduces the market for your product.
To name some historically important examples, Microsoft copied the APIs for JavaScript from Netscape, Microsoft copied APIs from Lotus 1-2-3 for Excel, and Wine copied APIs from Windows for Linux. The outcomes famously were that Netscape went out of business, Lotus 1-2-3 was discontinued, and Linux became somewhat more viable.
Federal Circuit's ruling would only be precedent in the 9th circuit. As it does not have original jurisdiction in copyright disputes (only patent cases), it doesn't supercede any copyrightability rulings in other circuits, for instance the 1st circuit's holding in Lotus v Borland that the Lotus macros were not copyrightable as a "method of operation". And today's opinion cites Lotus v Borland several times even though the original 1996 Supreme Court case was deadlocked at 4-4.
I think it's even narrower than that: the Federal Circuit's ruling on non-patent aspects of the case isn't binding precedent outside of Oracle v. Google. District courts in the Ninth Circuit and the appeals court are free to ignore the Federal Circuit ruling in future cases and look to only rulings from the Ninth Circuit and Supreme Court as binding precedent.
No, not only 9th circuit.
The Court of Appeals for the Federal Circuit is binding nationwide. And if the case includes claims about patents and/or trademarks, even if those specific claims are thrown out, then the Court of Appeals for the Federal Circuit becomes the court that the case is appealed to.
Which is how this particular case wound up there in the first place.
The Federal Circuit's copyright decision is binding on the parties to the case at hand, but the precedent for future cases is non-binding at best.
This was one of the arguments that the FSF and SFLC put forth in their amicus brief recommending that the Supreme Court not take up Google's appeal of the API copyright question:
> The court below predicted, on the basis of no compelling evidence, that the Ninth Circuit would depart from settled existing law in a novel direction which, as amici supporting the petition have said at length, would be destructive alike of commercial certainty and freedom to implement, thus inhibiting the progress of science and the useful arts. Neither the Ninth Circuit nor any other regional Court of Appeals is likely to defer to this improbable supposition, so the error is largely self-limiting. Such erroneous predictions of other courts’ holdings are not a suitable employment of this Court’s scarce resources in review by certiorari.
Not even the 9th Circuit. For cases arising from thr 9th Cir., 9th Cir. case law binds the CAFC, not the other way around, on issues that are outside ofnthe subject-matter for which the CAFC has nationwide jurisdiction.
> The Court of Appeals for the Federal Circuit is binding nationwide
No, it’s decisions are only binding nationwide on the issues within its special jurisdiction, which copyright is not. On other issues, it is instead bound by the case law of the circuit that would otherwise be responsible for the case, and notionally is just an interpreter of that circuit's case law. It’s decisions on those collateral matters on cases brought before it because they also touch on one of the issues reserved to the CAFC aren’t binding on any other court.
How are those issues defined?
This is similar to when federal courts have to apply state law.
What happens when an API is co-created by different software developers which each creates their own software under different licenses, through communications which themselves aren't explicitly licensed (like over email lists), and then summarize what they agree on in text instead of code (like the RFC process)?
At no point have either one of them explicitly given permission to use their respective contributions under another license. Even if they agree that the RFC text is public domain, that technically do not extend to implementations of the API which it describes (as those are different works!). And there exists no official reference code with legal approval from all contributors, whose license could be adopted by other developers.
It would be such a mess...
Huh, I had no idea the React license wasn't still "you're free to use React unless you ever assert a patent against Facebook".
No, it doesn’t. Because the Court expressly declined to examine the question, the CAFC decision is binding only where it would have been without the Supreme Court decision, i.e., those courts bound by the CAFC’s interpration of how Ninth Circuit law applies. As it turns out, that is exactly zero courts.
The reason the Supreme Court often likes to find the narrowest grounds possible for a decision is to avoid making more binding case law than is called for; giving the lower court rulings on all questions not addressed (including those the Supreme Court explicitly avoids) the same binding effect as the actual Supreme Court holding would defeat the purpose, and it is very much not how things work.
CAFC does not have natural jurisdiction over copyright and thus always applies circuit law.
Here, this was also a 3-judge panel of the federal circuit, and en banc review was denied.
Those decisions are already not binding on future 3-judge panels IIRC (it's been a while, honestly), and definitely not binding on the circuits
Right, and I think this played an important role in why the Supreme Court ducked API copyrightability; they’d rather not do so absent a binding lower circuit decision, or especially a conflict between circuits, preferring to let the issue percolate (and also provide Congress more time to intervene) of there is another basis dor resolving particular cases with less sweeping impact.
Lotus was at a crossroads. DOS was obsolete, was the future OS/2 or Windows? They chose OS/2.
Lotus was a big, cash rich company at the time. Their fatal error was not realizing they should have ported 1-2-3 to both OS/2 and Windows. Then they would have been secure regardless of which prevailed.
iOS is a good example though. Windows Mobile had not yet come to dominate the market.
Internet Explorer wasn't the first browser on the market but by the time Chrome had come around Microsoft had let it languish and it became pretty awful. For a long time Microsoft had convincingly won the browser war.
Same with MSN messenger, it didn't keep up. And nobody has ever decisively won that chat app war anyways .
Smartwatches have been around for a very very long time. What Apple did was get smartphone integration right.
Zune Pass isn't a streaming service, its a DRM laden online music store. So more akin to iTunes than Spotify or Apple Music. And it was very late to the game.
That’s...optimistic. The transition to GUIs undermined a major hold they had, which was user-familiarity-lock-in. That transition was going to be an opening no matter what, especially for a competitor that also controlled the platform that won out underneath the application.
Lotus was bigger than Microsoft for most (all?) of the 1980s.
Wordstar was another company that failed to understand the shift to GUIs.
Of course, Wordstar had another major marketing problem. Despite its dominance, nobody knew the name of the company (MicroPro) that made it. Far too late they realized the mistake and changed the company name to Wordstar. Microsoft never made that mistake.
If the choice was between 2 options, 'both' might be a viable response. But 3 or more, especially with a market expectancy that everything DOS-based would disappear?
In hindsight it is much more obvious that Microsoft's involvement in OS/2 was something of a trojan horse to fund early NT development and a short-term hedge in case people did trust the IBM brand more than the Microsoft brand, but at the time it was much more confusing.
It may be hard to believe, but the first iteration of Internet Explorer on Macintosh (back on System 8) was __solid__. IE, at least on PowerMacs, was way faster and more reliable than either NCSA Mosaic or Navigator.
That makes it sound like Netscape had no say in the matter. Netscape sold itself to AOL.
Similarly, if the D compiler crashes when compiling a D source file, it's the D core team's fault.
if (NetscapeIsRunning()) corrupt_data();
As I recall, the anti-trust case revolved around Microsoft including IE for free with Windows, not sabotage. (Of course, every OS comes with a free browser these days. Even my Kindle.)
While it would arguably be Netscape's fault if Netscape actually crashes (rather than simply failing to display a malformed input) at that time in the browser wars there were plenty of energy going into creating incompatible new 'features' - such as Microsoft's own JavaScript competitor, VBScript [1], vector imaging format (AutoShapes) and animation tags (DHTML)
And Microsoft did intentionally sabotage competitors products in the 1990s with approval from the highest levels of the business - such as DR-DOS [2].
So while I'm not aware of any claims Microsoft sabotaged the OS to make Netscape crash, they'd sabotaged the OS to make other competing products crash, and they certainly added a lot of 'features' so web pages wouldn't render right on Netscape.
[1] http://www.gbengasesan.com/fyp/43/ch5.htm [2] https://en.wikipedia.org/wiki/AARD_code
There's zero evidence Microsoft sabotaged Netflix.
There's zero evidence Netscape crashed for any reason other than buggy Netflix code. Making a web page that crashes Netflix is a bug in Netflix. Microsoft is under zero obligation to work around Netflix bugs.
IE4 is where ActiveX and browser bloat started to become more obvious, then IE5 was an improvement again.. but we were only a short time from the launch of what would become Firefox. By that point, people were tired of the constant IE issues.
Commercial users were paying for Netscape in 1995. It was only free for personal use. Even articles from 1996 mention the cost of Netscape as $49. [1]
So at least part of the reason IE displaced Netscape was that it was free for enterprises. And Netscape was not, until it was too late.
Lotus couldn't make the transition to Windows, and so lost to Excel (and perhaps Quattro Pro... it's been a long time and I don't remember details). This had nothing to do with copying APIs. Of course, it probably had everything to do with Microsoft's anti-competitive advantage by having access to Windows internals and undocumented features, but that's another matter.
1. Google did not copy Java APIs strictly for the purpose of interoperability (they specifically did not want interoperability with other Java environments).
2. Ninth Circuit court precedent does not apply in the Federal Circuit, which is the only reason why Oracle even had a leg to stand on.
Had Oracle not had a patent claim in this lawsuit, it would have wound up in the Ninth Circuit, we would have gotten another respectable decision limiting software copyright from that court, and the only thing SCOTUS would have had to have done would have been to deny cert to Oracle after they lost. It's entirely due to the Federal Circuit not respecting basic concepts of how software works and ruling on something that shouldn't have been in their jurisdiction that we got here.
Copyright in a private, internal API seems reasonable in principle.
RIP kotlin-first on android?
So to be fully Java/JVM free with Kotlin-first, Google and JetBrains would need to re-write the Android world to run on ART or Kotlin/Native, including anything that might come from Maven central.
I'm waiting for an ambitious attorney to figure out how to frame this as poaching talent from an ecosystem to bring to another.
Doesn't deciding that it's fair use specifically mean that they think it is copyrightable? The fair use doctrine specifically refers to the use of copyrighted material.
if (!isFairUse(workUnderInvestigation) && copyrightable(originalWork)) {
bigCopyrightPayout();
}
No, deciding it would be Fair Use even if it was copyrightable means you can cutoff the process considering copyright.
(Its perhaps useful to think of legal cases as consisting of a set of parallel questions connected by logic operators—once enough of them are resolved to reach a decision which no resolution on the others will change, the process is free to conclude without waiting for the others to be resolved.)
Also what people fails to realize with fair use is that it is up to the defendant raise a fair use defense and then a judge has to approve of that defense as a valid one (Viva Frei explains this https://youtu.be/AzQz1LrjCWk?t=253 ).Meaning Oracle can still go on with its lawfare campaign against those who made the mistake of basing their tech on theirs.
I'm intrigued by how judgements are passed in such intricate technical matters.
No such consultation exists.
> Or is the judgement based upon the subject matter experts presented as witness from both sides themselves?
Since this was a decision as a matter of law, and not one turning on disputed facts (the Supreme Court can decide cases on either basis), the judges are the relevant subject matter experts.
Because the federal courts already ruled that APIs are eligible for copyright [0].
Google wanted to overturn the ruling that they were in violation of copyright and argued they used Java's APIs fairly under copyright law.
The court will not answer questions not put to it, and Google (I presume) felt they had a better shot at getting the court to agree it was fair usage, rather than arguing copyright should not apply here.
0: https://www.paleudislaw.com/federal-circuit-rules-that-apis-...
This is false; Google appealed on both copyrightability and fair use, and the Supreme Court agreed to hear both issues.
Translated into developers speech: this is some sort of early return. ;)
Sanity prevailed! This judgment could have had devastating consequences and turned software development into a copyright nightmare.
IAAL but IANAIPL and most emphatically IANYL
The court has to talk about programmer skills because Android (at least, the versions before they switched to OpenJDK) was not entirely source- or binary-compatible with Java SE programs. In fact, the reason why they couldn't license Java SE was that Sun insisted on Android being locked into compatibility in the first place. So this entirely represents an expansion of existing fair use precedent: now, not only does fair use apply to full reimplementations for the sake of interoperability, but also partial reimplementations made for the sake of programmer convenience.
But Google's lawyers (inexplicably, in my opinion) failed to talk much about the fact that many Java libraries are interoperable between Android and Oracle Java, leaving the courts to think only in terms of full applications which are not interoperable. Thus the courts have treated this case as if the only benefit to Android's reuse of Java was programmer familiarity.
Thankfully, Google won anyway, so any defendant in a future case who can make a better interoperability argument will be in an even stronger position.
Edit: For example, in the Federal Circuit ruling that the Supreme Court just overruled, they complain: "Indeed, given the record evidence that Google designed Android so that it would not be compatible with the Java platform, or the JVM specifically, we find Google's interoperability argument confusing. [..Google] points to no Java apps that either pre-dated or post-dated Android that could run on the Android platform." [1]
[1] http://www.cafc.uscourts.gov/sites/default/files/opinions-or...
To argue interoperability Google would have needed to copy the entire JAVA SE API.
The key difference is that Java SE (designed for desktops) API was considered by Google mostly not required on smartphone/mobile devices envisaged for Android. Sun would only licence Java SE complete (Sun was the one wanting complete interoperability).
To the extent the concept of interoperability enters into it, it was on the human side; the arguments were about leveraging existing programmer knowledge to the extent that Android's requirements were shared with and common to Java SE.
Only if Google wanted to argue interoperability as defined by Sun/Oracle. I've never seen a coherent argument why Sun's TCK should be considered the sole authority on what degree of interoperability should have legal significance in this copyright case, particularly given that Sun's TCK was part of their trademark licensing program.
And there are obvious reasons why a court would shy away from letting something like Sun's TCK be used as part of a significant legal test; for example, it's really awkward for legal purposes to define something as copyright infringement while it's a work in progress, but it suddenly becomes okay as soon as it attains the status of being 100% compatible and bug-free. It's also not clear how the law could reasonably handle a definition of interoperability that Sun/Oracle can unilaterally make into a moving target and add arbitrary requirements to.
Well, "dollars / year", if you work in an industry where you can directly A-B test against revenue, but I think most of us are happiest not knowing whether our particular lines of code are EV-positive.
Code bases like kubernetes come to mind for LoC far exceeding its value. Code bases like Quake3 come to mind for LoC that provide tremendous value. Every line is an explicit decision to improve the code or make it worse.
Refactoring a system to be generic and re-usable, for example, would reduce LoC yet provide tremendous value. If I were her manager, would I deduct points for -2000 LoC? Would I praise her for taking copy-pasta and making a pattern? I know which I'd choose.
Aka, that you could clone Harry Potter's plot, characters, and story while not copying each word of the book verbatim, and it still be a copy of Harry Potter.
Would that be a copyright infringement? Probably just trademark infringement at that point?
Copyright attaches to the actual text (illustrations, etc; whatever is “fixed in a tangible form”), not the ideas.
You could write a story about a boy of humble origins who is whisked off to a special school, discovers he’s special, and fights evil. There aren’t that many original plots, after all....
You’ll only get into trouble if the main character is called Harry Potter of 10 Privett Drive, where he resides with his mother’s sister and her awful family, and he later attends Hogwarts, etc.
[1] https://en.wikipedia.org/wiki/Copyright_protection_for_ficti...
The merger and scenes a faire doctrine permit lots of overlap in terms of themes, tropes and set dressing. You could certainly write a coming-of-age story set in a magical boarding school; indeed, Harry Potter is neither the first nor the last such novel. One of the classic cases is Walker v. Time Life. The two works, which were found to be non-infringing, both start with a double murder of two cops (one Black, one white) in the South Bronx, both feature demoralized Irish-American cops, and both have similar tropes (rats, cop-talk, etc). A reviewer might reasonably describe it as derivative (and a few did, I think), but not legally so.
What you probably couldn't do is publish the (non-parodic) story of Perry Hotter and his substantially-similar adventures at Pigworts, though that's also absolutely spoiling for a trademark fight.
Music gets weird because it a) seems like there are a lot of possible note sequences but b) there aren't really.
I don't know if their beef is with copyright vs trademark.
Or in other words, a tiny fraction of the original work would essentially be allowed to monopolize the entire space of works involving magical kids going to school.
(And this is why Justice Thomas is widely regarded as the least competent justice of at least the past half century.)
Presumably the issue would be if one wrote a book substantially about the same character as Harry Potter who went through the same plot events in significant detail, but only 0.4% of the sentences were identical and the main character's name was Barry.
Thomas would allow copyright on code regardless of any creativity. This would destroy the software industry. Anyone who is first in time would monopolize entire swaths of software functionality.
And that is what he wants. Thomas is an ideologue, and his sole goal in allowing the copyrighting of code is to destroy the tech industry, which he views as hostile to Republicans. You can see it in the logic of his dissent, which would require the court to override decades of settled case law all supporting the proposition that code and other functional expression. In order to justify his nonsensical arguments, Thomas is forced to come up with an entirely new category of code that is not supported by legislative history or judicial history. Thomas' only justification for this category is...that it's "not fair" to a multi-billion dollar company that the non-copyrightable portions of their code were copied by another corporation. Pity the poor multi-billion dollar corporation, they just can't ever get a break.
Even he notes that his dissent is nonsensical when he admits "declaring code is 'inherently bound together with uncopyrightable ideas.'
This would sound like a convincing position if the company abusing them wasn't a trillionaire corporation. Oracle is literally "the little guy" here.
This case began in 2010 as Oracle attempting to smother a similarly sized competitor...after Oracle acquired the actual creators of Java.
Personally, I think the best code is the code I don't write.
A significant part of my refactoring, is removing as much code as possible, by tweaking algorithms, deriving common base classes, and removing unused code branches.
Every line of code is a potential bug. The less code, the less bugs.
https://www.folklore.org/StoryView.py?story=Negative_2000_Li...
My favorite was replacing a function call with a single character constant.
Then there were two employers who demanded code proliferation (management incentives tied to KLOCs?). Didn't last long at either place.
(start at 20:05 if timestamp fails).
I also appreciate this fair use argument, especially when you point out the code in question was 0.4% of the entire API.
Still, I'll always struggle with the idea that "the amount and substantiality of the portion used" when copying an interface is comparable to copying an implementation. The interface is, intellectually, the substantially heavier, "bigger picture" component of the API than the implementation. In my view they are apples and oranges.
So, I'm glad this was the outcome. But I'll always feel like there was something wrong with Googe taking the Java SE interfaces and using them like they did, gratis.
Ironically the most protected APIs may be the ones nobody implements.
One thing I do see happening is that sensitive and expensive to develop algorithm internals may be prevented from leaking into APIs. I, again, don’t see this as anything other than a win for devs. An API is fundamentally used to get stuff done, if a developer doesn’t need to know the implementation details I overall think this is a win for the developer using the API.
Now, how do you let third parties program against that non-public API? Would only showing it to licensees be a legal way to do that?
If so, and if the API becomes popular, I don’t see how to prevent those licensees from leaking the API to the world, say through small code snippets on Stack Overflow.
That would seem a reasonable outcome, for much the same reason that copyright not protecting the appearance of fonts under US law is reasonable. Yes, it is overriding copyright protection for a creative work that would otherwise apply. However, it does so because a greater good is served, in this case by ensuring that interoperability cannot be encumbered, something which (as the majority opinion alludes) goes against the very purpose of copyright under US law.
One could argue that this is for the judicial branch, not the legislative branch, to decide.
Anyone using fork(), stat(), open(), or other basic parts of the UNIX development environment would be in violation.
Those copyrights were purchased by Novell at some point, and I believe ended up with Attachmate.
One would think that the C Programming Language is also covered by copyright via the K&R books, which would put anyone using printf() in the same position.
That is truly a nightmare scenario.
Absolutely, but courts are supposed to interpret the law, not rule whichever way avoids nightmare scenarios.
The risk of going too far in that direction (and this is by no means the first case in which SCOTUS c̶l̶e̶a̶r̶l̶y̶ may have rationalized a decision for pragmatic reasons) is that it makes the court more corruptible. I am glad the majority ruled this way, because I agree that it leads to a better outcome in this case. On the other hand, any departure from a pure interpretation of the law is very dangerous, because it normalizes the more-corruptible mode of operation, and that can lead to another kind of "nightmare scenario".
You should read the law in question. This would be Section 107 of the Copyright Act, which defines "fair use". It's extremely vague and is best interpreted as a set of considerations that the courts should take into account so that they can handle situations like this one on a case by case basis. If Congress wanted to be more prescriptive, they could (ETA: and if they become unhappy with the courts' decisions they still can in the future), but I think that would lead to worse outcomes.
I was really just responding to the implication that SCOTUS did the right thing because "it would be a nightmare scenario" otherwise.
The law also states that copyright's purpose is to stimulate progress of the arts, and that's why fair use is possible. Interpreting the law also means establishing the limits of fair use.
But, still, yes, determining the scope and applicability of fair use is part of applying the law.
Rewriting history the way we do in the context has all kinds of problems associated with it
This is NOT what the Court found. At the very top of the Opinion, it says "we assume, for argument’s sake, that the material was copyrightable. But we hold that the copying here at issue nonetheless constituted a fair use."
Fair use makes sense to me when you're talking about the table of contents of a book. If I take the table of contents of a famous novel and write my own chapters, it makes sense to me that the owners of that book shouldn't be able to sue me. No one is going to read my book instead of Faulkner's. There's no equivalency there.
If I take an API (the table of contents equivalent of software), that's seems totally different, if not the opposite really: the interface is what matters, and the implementation is secondary. If you apply the analogy to a novel, it's as if I took the table of contents of a famous novel, write my own chapters, and it'll be equivalent to the famous novel. My chapters could be slightly "worse", but readers wouldn't necessarily notice a difference between my version or Faulkner's.
But that's kind-of the point IMO - if we take a free-market approach to this, copying (or sort of "standardizing" onto) an API allows for more innovation, since it's not a prohibitive up-front cost to switching the implementation. We don't copyright (or I guess patent, and I know they're different) the user interface of a fridge. Any fridge can have 2 doors and a slide-out freezer, but it's the actual implementation that would matter to a user - how energy-efficient it is, how cold it can get, extra conveniences (maybe akin to API extensions) like a water/ice dispenser that still can be "copied"/used by other fridges. And I'm sure that maybe those "interfaces" were patented originally, but it seems absurd now that they're so commonplace to restrict who can implement them.
I think the same applies for APIs. It's only taking away users from the original implementation if the new one is better.
Honestly, the fact that it's 0.4% is a BS heuristic. What if they spent a year and all they did was refactor the code so that codebase was 1.43 million lines instead of 2.86? Would that mean these lines of code are 2x as powerful?
Lines of code is an indicative heuristic, but not a deterministic one.
...at least I hope that's what they did.
Certainly, the fact that competing encyclopedias exist, and have for hundreds of years, with > 99% identical entry names (but of course, substantively different content), and that predicated not on any given invention or IP but rather the common use English language, would, I think, make the judges rather reluctant to rule differently even should there be 100% match in entries.
I maintain a reflist of women in the ADB who have no Wikipedia article.[2]
1. https://en.wikipedia.org/wiki/Wikipedia:WikiProject_Australi...
2. https://en.wikipedia.org/wiki/User:Chris.sherlock/Australian...
[1] https://en.wikipedia.org/wiki/Eldred_v._Ashcroft
[2] https://www.legalaffairs.org/issues/March-April-2004/story_l...
> Sanity prevailed! This judgment could have had devastating consequences and turned software development into a copyright nightmare.
This judgment is the equivalent of someone taking a movie script, shooting a new movie out of it without changing a word, and the court declaring this "fair use" of the script.
Software development wouldn't have turned into a nightmare unless you decide to steal a platform. Which most people don't need to do in order to do their work.
Movie scripts and APIs aren't really comparable as you have presented them.
This decision suggests you could include say, the negative of the neighboring building’s facade so that the two “interoperate” in a sensible way.
While I think it would be GREAT to see what Nick Nolte (Lucas was considering him) would have done with Han Solo over the wooden Harrison Ford, I'm not sure I care enough to sit through it all again to find out. Blech.
...the extent to which the use is transformative. In the 1994 decision Campbell v. Acuff-Rose Music Inc,[13] the U.S. Supreme Court held that when the purpose of the use is transformative ... is more likely to favor fair use.
Ethics aside, as a viewer, it'd be kind of cool if this were a thing. Small-time movie makers might like it too.
In fact, they've become a fannish pastime the past few years: https://www.theverge.com/2017/7/20/16006112/revenge-of-the-s...
I'm ok with either decision, but, depending on how this precedent going to be interpreted, it could have far reaching consequences, maybe unintentional/undesired ones too.
Seems like a net benefit to me :-)
No, it is not a first class ticket to unicorn valuation, but it is trivially easy to differentiate
- from Google by just providing any kind of customer service to all paying customers
- from AWS and GCP just by allowing on premise solutions
- from Facebook by not reliably failing to protect and/or actively exploit your customers all the time
- etc
Need proof? See Slack, WhatsApp and Instagram (before the acquisition), Basecamp etc etc.
GNU/Linux, a free reimplementation of AT&T's Unix interfaces, is largely why commercial Unix isn't really a thing any more.
Also known as compatibility and interoperability. I'm so happy to see that judges understand their importance.
Actually, not really. Both this ruling and the lower courts' rulings in the case operated under the strange assumption that Android was not interoperable with Oracle Java, leaving programmer familiarity as the only reason Google copied the APIs. For example, in the Federal Circuit ruling that the Supreme Court just overruled, they complain that Google "points to no Java apps that either pre-dated or post-dated Android that could run on the Android platform". True; but of course third-party libraries often can run on both Android and Oracle Java, and their importance seems to have been lost on everyone involved in the case... including Google's own lawyers.
Thankfully, Google won anyway, so any defendant in a future case who can make a better interoperability argument will be in an even stronger position.
It’d sure have made the practice of taking someone else’s API and re-implementing the innards a lot more interesting:
https://docs.oracle.com/en-us/iaas/Content/Object/Tasks/s3co...
A: some of those suits are still ongoing, and
B: the suits never alleged infringement based on the API alone, SCO was claiming that Linux copied functional code in multiprocessing modules (we don't know which functions because they demand secrecy, even though it's open source).
Not even SCO, trolls that they are, were insane enough to claim that the APIs themselves are copyrighted.
Based on this court decision, it's apparently fair use to lift someone else's API and use it to jumpstart programmer familiarity with your product, if the author of the API previously tried to achieve success in that narrowly-construed, retroactively-interpreted exact same market segment and wasn't very successful.
I see a few things coming out of this. IP holder companies will become even more common: they will be used to hold copyright to one API and license it out to customers -- including independent companies that you would currently recognize as part of the same platform.
But because the IP holder does not provide an implementation and therefore does not 'compete' in a market segment, any unlicensed use of it is necessarily infringing: there's no innate functionality with which one can interoperate under the doctrine of fair use.
Not after this precedent, which says that APIs are free.
What will happen: Intel licensing the i86 instruction set will not be possible from now on, same for ARM.
Patents are what are generally what is used by Intel, etc to protect (and license) new CPU instructions and provide protection for novel ideas/inventions for up to 20 years.
Copyright generally protects specific expressions/implementations of an idea and last up to 95 years for corporate patents, or 70 years + the lifetime of the author for individual patents.
For completeness there is also trademarks which cover names and logos which can last indefinitely, as long as they are in commercial use.
The text of a CPU instruction specification would be covered by copyright, the algorithm for implementing the instruction by a patent, and the branding (ex: MMX) by trademark.
I fail to see why an ISA is fundamentally different than a standard library.
As GP said, the difference is whether it's patented. If Sun had patented parts of the API (or algorithms necessary to implement it), then Oracle would have another weapon against Google even after Google was granted a fair-use defense.
I could understand Intel having a CPU patent for specific CPUs, but an specific ISA?!
A really interesting test case would be to implement an isomorphic encoding to x86 with same instruction widths and what-not such that it's trivial to convert binaries from one to the other, and modify compilers (especially the JIT ones).
No, it doesn't. It says the "fair use" doctrine covers copying an API's "task calling" system, i.e. nomenclature and ontology.
The copyrightability of APIs will have to be determined.
On the plus side though, they only get 20 years of protection. x86-64 in it's original form should be up for grabs pretty soon here.
It seems to me the judge is saying, “the house was full of 10 tons of jewelry but the robbers only took 10 pounds so that isn’t really stealing lol “
> Google copied these lines not because of their creativity or beauty but because they would allow programmers to bring their skills to a new smartphone computing environment.
Perhaps the measurement should have been a count of bytecode instructions rather than lines of code.
Under the fair use doctrine, maybe. Fair use in the US is literally about being able to use "limited" parts of a copyrighted work without getting permission from the copyright holder. What is "limited"? It depends, but 0.4% could reasonably be called limited.
> It seems to me the judge is saying, “the house was full of 10 tons of jewelry but the robbers only took 10 pounds so that isn’t really stealing lol “
Copyright and fair use apply to the creative substance of the work (in your example, the design on the jewelry, perhaps), not to physical instances of it (the actual pieces of jewelry in the house).
The class of actions classified as fair use describe situations where arguably society can loosen the reigns to substantial benefit to society without destroying the incentive to create.
A classic example would be quoting books to discuss them. The free exchange of ideas greatly enriches society while encouraging not replacing readership.
Reducing it to an analogy to physical property obscures instead of enlightens because it misses all the ways a copyright is different than a right to physical property.
I _hated_ Scalia while he was on the bench. I fundamentally disagreed with him on a significant amount of his opinions.
Their actual opinions though are of such a different quality to me. Scalia's opinions I could absolutely follow the logic, and at times I found myself sometimes dispairing as I became convinced he might be right on an issue. Essentially, Scalia's logic usually felt on point to me, we just had deep axiomatic differences in how the law should operate and how the constitution should be applied to laws.
Thomas, though, I sometimes have a hard time understanding the argument he's presenting, and sometimes have a "how do you even believe that" reaction to his opinions.
Again, I think I disagreed strongly with Scalia opinions about as often as I do Thomas opinions, I just think they were for very different reasons.
Hackers and programmers tend to try and read the law like computer code to be "hacked" and exploited based on the letter of the law. So you'd expect us to be more sympathetic to Thomas' view. So this is a great example to smack hackers with when they try and "hack" the law, treating it like code rather than something more human. It's a great example because this is a case where the majority is obviously the "right" decision to any true code hacker.
Because here it's allowable for a product that isn't competing, and is being leveraged for interoperability/ease of users to adopt (rather than for how clean/clever it is).
What if someone had copied Stripe early on, though? Stripe's big claim at launch was "payment processing in 7 lines of Javascript" or similar. Obviously there were other barriers to entry, but what if someone else entered the market at that time with a similar (or even identical) interface? That question was left unanswered.
Yes, but to a textualist how the law was intended doesn't matter! (I'm mostly joking, I agree with what you meant to say here, I think.)
Textualists are trying to ignore the fact that there's a difference between intent and implementation.
The Legislature should do a far better job making their intent clear. But to the degree they make mistakes, leaving the intent unclear in some situation, it's good to have Case Law to inform us.
I am not a lawyer. I don't know much about the law. But I do know metaphors, and when someone talks about exploiting the law, this is what comes to my mind.
Textualism to its proponents is very much like exploiting a system; figuring out the exact rules it defines and finding workarounds. It may not even be to a person's own goals (hence the individual not feeling biased when thinking this way), but is enjoyable in its own right in finding those loopholes (like the meme of the referee allowing Airbud to play, "there's nothing in the rule book!").
To its critics, it's like blindly implementing the ticket as written, rather than asking questions and making sure the intent is understood and the problem is being solved correctly.
Which explains, in a surprisingly empathetic way, why I am not a textualist, and why some of my family are, when it comes to political discussions.
But that's what I mean; exploiting perceived flaws in the system is a greater goal -even when it ruins the game for themselves-. Because there is a greater sense of satisfaction in finding loopholes. And I understand that sense; I just find more value in understanding the underlying goal and intent and delivering on that.
By only looking at the text of the statute, the Court—which consists of unelected officials with lifetime terms—is trying to limit its power. If the text is unclear, they feel it should fall on elected officials to clarify it.
After all, it is as equally fair to say "The wording of this law leads us to a clear understanding of the intent to mean X, and if the legislative body feels that to be in error they should pass new legislation to clarify it" as it is to say "The wording of this law leads us to an unclear understanding, and irrespective of intent we will decide !X until the legislative body passes new legislation to clarify it".
While the non-textualists may be explicit in trying to understand the intent of a law in accordance with their own biases, the textualists are still interpreting the law according to their own biases. There have even been some...really interesting cases of logic to try and do so (i.e., earlier generations' understanding of 'sex' matters when interpreting anti-discrimination statutes, but earlier generations' understanding of 'gun' does not matter when interpreting the 2nd amendment). It's incredibly rare (pretty much unheard of in the case of a few of them) for them to decide against their own predictable biases because a law is ambiguous, or a situation is novel.
Legal language is slippery enough that this is almost always possible. On the few occasions when it is not possible, we learn the truth. Scalia famously revealed his true colors on occasion.
http://www.dorfonlaw.org/2016/06/does-textualism-have-bias.h...
Here's Richard Posner on Scalia:
> Does an ordinance that says that “no person may bring a vehicle into the park” apply to an ambulance that enters the park to save a person’s life? For Scalia and Garner, the answer is yes. After all, an ambulance is a vehicle—any dictionary will tell you that. If the authors of the ordinance wanted to make an exception for ambulances, they should have said so. And perverse results are a small price to pay for the objectivity that textual originalism offers (new dictionaries for new texts, old dictionaries for old ones). But Scalia and Garner later retreat in the ambulance case, and their retreat is consistent with a pattern of equivocation exhibited throughout their book.
> One senses a certain defensiveness in Justice Scalia’s advocacy of a textualism so rigid as to make the ambulance driver a lawbreaker. He is one of the most politically conservative Supreme Court justices of the modern era and the intellectual leader of the conservative justices on the Supreme Court. Yet the book claims that his judicial votes are generated by an “objective” interpretive methodology, and that, since it is objective, ideology plays no role. It is true, as Scalia and Garner say, that statutory text is not inherently liberal or inherently conservative; it can be either, depending on who wrote it. Their premise is correct, but their conclusion does not follow: text as such may be politically neutral, but textualism is conservative.
https://newrepublic.com/article/106441/scalia-garner-reading...
I would say that they are not so much trying to ignore the fact as acknowledging the fact but taking the position that it the court's role to interpret the implementation, not to guess at the intent.
https://en.m.wikipedia.org/wiki/List_of_national_legal_syste...
Supreme Court: "For now, we'll presume LESS THAN OR EQUAL."
Legislature: "Wait, we meant LESS THAN."
We need a decision NOW. The Supreme Court supplies a decision NOW. The Legislature can change it.
Interpreting the implementation demands guessing at the intent on the edge cases. It can't not. Even if your preference is to always pretend the language is absolute.
It is actually the opposite. Textualists say that intent doesn't mean squat. Originalists will consider intent. Textualists say that intent is unknowable and therefore you must exclusively use the text of the law, regardless of how stupid that might seem.
Laws and contracts are so damn hard to read because they need to close every possible conceivable loophole. You get sentences that use multiple synonyms of the same verb because someone is going to come up with some strange incredibly-specific difference between them.
Imagine some parent telling their kid to not jump on the bed, and the kid says "I'm not jumping, I'm hopping!". That's a kid that's going to grow up being a Textualist.
> Textualists say that intent is unknowable
I think Textualists are claiming this in bad faith, knowing damn well that intent is very well knowable, but argue otherwise to advance their agenda.
In practice, textualism and originalism aren’t all that different, because most of the same indicia that originalists will look to for signs of “original intent” textualists will look to for signs of what the words of the text mean in their original context (textualists are not, as a class, blind to context). While different observers will weight the individual indicia differently, the variation within the textualist and originalist camps on this is more significant than that between the camps. The camps really mostly differ in how they tend to frame arguments from the same facts to the same conclusions.
That would require a wholesale redesign of creator's monopolies in software; CONTU basically said "oh yeah, judges can just use fair use to wriggle out of any market harms software copyright might cause" and Congress went with that.
Furthermore, Congress's actions over the past few decades have generally not squared with any sort of actual copyright reform. The last major actions I can think of were:
- Implementing the EU's reciprocal copyright extension so that Mickey Mouse could get more copyright protection in France (Sonny Bonno CTEA)
- Implementing an overbroad and policy-laundered set of protections for DRM that companies took to mean "all you have to do is put software in a thing and you can sue anyone for making parts for it" (DMCA 1201)
- Extending criminal copyright liability to filesharers (NET Act)
- Granting more copyright term extensions to old music recordings that weren't federally copyrighted until the 70s (CLASSICS Act/MMA)
The last thing I would ever want is to hear Congress's intent on any of these, as I would imagine it would sound something like "Fuck you, pay me". Australia, the EU, and the UK get a lot more shit these days for overbroad copyright laws, but this is mainly because doing so lets them rein in foreign tech companies. The US doesn't do that anymore because tech companies gained enough clout here to stop even more misguided copyright nonsense like SOPA/PIPA. However, with tech companies falling out of favor I wouldn't be surprised if Congress decides to start busting kneecaps again.
"Indirect" here just means calling a function or jumping to some address, rather than directly inlining some statements.
For the purpose of copyright, the term "computer code" does not include the signature of that function, or the address you jump to, only the actual code statements at that destination.
But they have no authority to enforce their opinion, and Thomas absolutely doesn't care. He didn't become a judge to rule on things he has no opinion on. For him, conflicting interest makes it that much more important to keep his hands in.
Thomas is an incredibly political beast, to the point that Scalia wrote him off as an unprincipled nutjob.
Speak for yourself. There are plenty of us that understand you can't take the human element out of this.
He simultaneously says that corporations have First Amendment rights to donate unlimited money to politicians, but have no First Amendment rights to moderate content on their social networks.
He's a hack that just does whatever is best for conservatives.
I explained very clearly what the contradiction in Thomas' rulings is which leads me to my conclusion.
You can have an opinion about whether that's right ... but its hardly simplistic.
Being simplistic would be having the view that he's a hack without any evidence.
I don't say he's a hack lightly. If you look at his decisions he uses one path of reasoning in one set of decisions and then uses the opposite path of reasoning to come to a different conclusion in a different set of decisions, depending on how the outcome needs to come out. And then he claims he's being textual. Its nonsensical.
Edit: TBF you're being very simplistic assuming my comment illustrates a worldview. What worldview is that? Look at my comment history. I'm generally free-market and maximal-corporate rights ... aligned with Thomas. I just think his reasoning is flawed.
So in effect, "following the letter of the law" enlarges a judge's discretion. The opposite of what you would expect.
So any coherent notion of "congressional intent" has to mean the intent a person reading the text would infer about a hypothetical coherent author. I don't know anything about this particular case, but it is not at all true in general that there are more ways for a reader to interpret the explicit meaning of the written words than there are ways for a reader to interpret the intent of the written words.
https://en.wikipedia.org/wiki/No_true_Scotsman
Have you spoken to any professional language or API designers about this case? Would all "true code hackers" agree that copyright shouldn't apply to software at all?
1. An important fair use test is market effects. 2. Amazon and others used to give Oracle huge gobs of money because they feared that APIs might be copyrightable and not covered by fair use. 3. After Google called Oracle on this, Amazon and others also started believing it was likely fair use and stopped paying Oracle tens of billions per year. 4. Therefore, Google copying the API was a major adverse market effect. 5. Therefore, copying wasn't fair use.
That's a shit argument. Watch me do a similar analysis in a more obvious way.
1. An important fair use test is market effects. 2. People used to pay gobs of money to watch the movie Transformers 2. 3. In a widely watched review of the film, I showed a 4 second clip of the movie where someone said "I am standing directly beneath the robot's testicles." 4. After this, nobody wanted to pay any money at all to watch Transformers 2. 5. Therefore, there was a major adverse market effect from my copying. 6. Therefore, copying wasn't fair use.
"Google’s limited copying of the API is a transformative use. Google copied only what was needed to allow programmers to work in a different computing environment without discarding a portion of a familiar programming language. Google’s purpose was to create a different task-related system for a different computing environment (smartphones) and to create a platform—the Android platform—that would help achieve and popularize that objective. "
...
"Here the record showed that Google’s new smartphone platform is not a market substitute for Java SE."
...
"Google copied these lines not because of their creativity or beauty but because they would allow programmers to bring their skills to a new smartphone computing environment. "
...
"the Court concludes that Google’s copying of the API to reimplement a user interface, taking only what was needed to allow users to put their accrued talents to work in a new and transformative program, constituted a fair use of that material as a matter of law. "
If the un-italicized is the new test, that's probably the most reasonable thing I'm going to read this month. And it's only the 5th.
"The fair use question is a mixed question of fact and law. Reviewing courts should appropriately defer to the jury’s findings of underlying facts, but the ultimate question whether those facts amount to a fair use is a legal question for judges to decide de novo. This approach does not violate the Seventh Amendment’s prohibition on courts reexamining facts tried by a jury, because the ultimate question here is one of law, not fact. The “right of trial by jury” does not include the right to have a jury resolve a fair use defense."
Or to put it another way, convincing a jury that something is or isn't fair use is very different than convincing precedent-bound judges, especially with this on the books as the controlling case.
In final impact, it seems like an incredibly good judgement for everyone: you can prove to a jury what was / wasn't copied, and then a judge will apply a standard fair use test over those facts, with a tendency towards allowing transformative use.
Legal protections against copying, room for progress, and (most importantly!) more certainty and standardization in how cases are decided.
Emily Barnet, 2020, Yale (2015)
Diana Li Kim, 2020, Yale (2017)
Arjun Ramamurti, 2020, Yale (2018)
Daniel Richardson, 2020, Virginia (2018)
Brittany Jones-Record, 2020, Stanford (2016)
David Scott Louk, 2020, Yale (2015)
Elizabeth B. Deutsch, 2021, Yale (2016)
Joel F. Wacks, 2021, Chicago (2018)
[1] https://en.wikipedia.org/wiki/List_of_law_clerks_of_the_Supr...
In other words, the clerks do the work of researching and fleshing out the finished opinion, but I don't think they have much influence on the rationale used to decide the case. I've heard stories of clerks having to write opinions they personally disagreed with.
I'm biased, but I don't think the technical elements of this case were challenging to an intelligent layman. I think most people smart enough to become judges can understand the concept of an interface that is independent from an implementation, which is all this case really required, along with quantitative estimates of the amount of code involved. So I doubt that he needed clerks to understand any of it.
By the very nature of the court's operations, the justices cannot be writing the 30 page opinion and doing all the research on every case. The clerks are the ones who will be writing most of the summary, determining how certain cases influence the current case, and laying out the draft logic. They'll have many sessions with the justice to test the logic and find edge cases, implications, and make sure that a decision affecting millions of people is sound. Basically debate and draft/redraft the opinion (with other justices + clerks as well) based on what they're finding as the drafting continues.
I would say the clerks are indispensable to the creation of the opinion's outcome.
Does this mean that companies copying the S3 API as a substitute for S3 are still untested territory?
My impression is that this is probably nuanced enough we need to read past the syllabus if we wanted to really unpack the reasoning. I can't tell which is the key part from which to make an analogy.
One could imagine an opinion supporting the same decision with less clear or precise language. As I understand the process, the opinion was frequently reviewed and advised by Breyer, but actually written by one of the clerks.
If anything, they are even better with age at not getting confused by increasing technical detail of our API era, and making sure that the principles of law cut through that. (and how to structure a decision so it's clear to everyone)
If you relied on a tech-heavy decision to be made, this would not be a Supreme Court issue.
The way that the Court and every one of the justices work is that he/she will draft out with the clerks the broad principles and approach that he/she wishes the decision to be crafted around. Which cases influence the precedent, which regulations take what role in the decision, what issues to "turn" the case on, etc.
It's the job of the clerks then to go research, summarize, and create the bulk of justice's position based on knowledge of the details. They (justice + clerks) then review and talk about the evolving draft opinion several times over the course of months, circulating drafts to the other justices (and their clerks) as well. And note, most of the facts/issues already came up in the lower courts cases and rulings, so there has already been some fair surfacing of the details of the dispute (and what other judges believe the important issues to be) as it made its way through the system.
The justices have many opinions per term to do this for, and you can be very sure that while the "authoring" justice has been briefed on (and very well has tested the ideas with the clerks in detail), the summary of how APIs work and their legal status is not based on the justice him/herself wading through license agreements and "figuring out" the structure of the code or its legal status.
So, that is not to say that the justices are ignorant of the details (far from it), but the level of detail needed to form the groundwork of the opinion is heavily shouldered and created by the law clerks. But the main conclusions of the opinion are definitely of the justice him/herself (with input from the clerks).
-- By the way, the clerks (you may not realize) already have had a role in getting the case even to be heard before the Supreme Court, in briefing and summarizing the underlying appealed case on why it should be ripe for a decision, so they already many of the issues at stake and how to think about them.
Maybe think of it like a software engineering manager and the individual developer. The manager can lay out the principles by which a certain piece of code is to be written, and the capable developer will identify all the issues, test cases, etc., and they will review it together at various stages. You would not say that either could have done it without the other. It's kind of like that (when software engineering works like it should).
Well that nukes it. The courts took how long to identify this precedented principle? It seems like the rest of the opinion is just there to ward off more of this tomfoolery for people that don't get it.
Obviously this is copyright vs patent law but it goes to establish that there's been a big problem with the lower courts on "computer laws". It's a nexus of the problem with jurisdiction-shopping (finding a lower court that wants to keep lots of cases coming in and is willing to pump out questionable decisions to do so) and just the legal system being about 30 years behind the times in general in terms of understanding computers and how innovative a particular idea may be.
Breyer also has a brother who was a District Court judge in the SF Bay Area who's undoubtedly had to deal with various tech cases. Not saying there's any kind of shared knowledge of tech within the Breyer family but just kind of interesting.
What you will likely see is in a couple years, one or two of the clerks start to appear as law professors or judges involved in such cases.
No legal question is resolved for sure until it reaches the Supreme Court, but most cases never make it there, instead being resolved by lower courts applying higher courts' precedents.
This is EXCELLENT news for anyone in software development. Yay for Fair Use.
The Court is apparently not familiar with much of my code :)
> The Copyright Act expressly protects computer code. It recognizes that a “computer program” is protected by copyright... And it defines “‘computer program’” as “a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result.” §101. That definition clearly covers declaring code—sets of statements that indirectly perform computer functions by triggering prewritten implementing code.
Thomas seems confused here. An API (declaring code) is not a computer program. A computer cannot execute declaring code - by definition - because it is missing the implementation.
Declaring code does not "indirectly perform computer functions". Declaring code does not perform anything. It provides a reference, nothing more, for a compiler to match one computer program (the API client) to another (the API implementation).
> declaring code would satisfy the general test for copyrightability.. they are expressed in “words, numbers, or other verbal or numerical symbols
It is common knowledge that mathematical formulae & equations, which are also expressed in words, numbers, and symbols, do not have copyright protection.
> Copyright protection is therefore not available for... mathematical principles; formulas or algorithms
https://www.copyright.gov/circs/circ31.pdf
> public static int MaxNum (int x, int y, int z)
This is literally a mathematical formula, hence does not have copyright protection.
Also, you are distorting the argument by making it about one method signature instead of thousands of interconnected types and methods that work together to present an ergonomic interface for the developer.
A table of baseball batting averages or telephone numbers is not copyrightable, no matter how good or bad it is organized.
There's a reason the Supreme Court didn't adopt the argument you are pushing and instead ruled on fair use grounds: It's a bad argument because a large API is clearly a creative work.
Two equally good programmers may come up with radically different interfaces. Whereas if given an interface and instructed to implement it, they are likely to converge to a similar implementation.
A formula is an idea. It describes the nature of something computable. It does not explain how to compute.
For example: https://en.wikipedia.org/wiki/Euclidean_algorithm
The programmer must understand the formula in order to write computer code that implements it. The result is a creative/expressive work which is copyrightable.
gcd(X, Y) = X if X == Y or gcd(X - Y, Y) if Y < X or gcd(X, Y - X) otherwhise.
Is this a formula? Should this be copyright-able?
It would have made perfect sense to Euclid.
Some computers can understand this and execute it as if it were computer code. That's amazing! Kudos to those compute language designers and compiler authors. But their ingenuity does not suddenly grant copyright protection to anything their clever compilers can now understand.
If you code GCD in a low-level computer programming language then of course you can claim a copyright on that code, but nobody owns the idea of the Euclidean algorithm.
It’s when you see an actual mathematical syntax that you realize how different programming really is.
Not try to be tedious here, just pointing out that actually programming is different than math, even for a language like Haskell.
public static int MaxNum (int x, int y, int z)
Now, if you've come up with some novel way to perform some computation on three integers and produce an integer:
- you might be able to patent that procedure.
- you might write some code that performs that procedure, and you would hold a copyright over that specific set of code
- you might, I suppose, name your algorithm 'MaxNum' and declare a trademark over it
But I don't think any of those could prevent someone from writing
public static int MaxNum (int x, int y, int z)
in another codebase.
- your patent protection might limit their ability to make a substantially similar implementation of such a function
- your copyright protection might prevent them from literally copying your implementation word for word
- your trademark protection might prevent them from passing off their implementation of MaxNum as if it were yours
But in no way does this have anything to do with the uncopyrightability of mathematics.
This standard doesn't really make sense, and the legal standard says nothing about executability. What about programs with external dependencies, or a code snippet? Those won't necessarily be executable in a self-contained sandbox, but I'd certainly consider them computer programs.
Also, per Thomas's dissent:
> The majority also belittles declaring code by suggesting it is simply away to organize implementing code. Not so. Declaring code defines subprograms of implementing code, including by controlling what inputs they can process. Similarly, the majority is wrong to suggest that the purpose of declaring code is to connect pre-existing method calls to implementing code. Declaring code creates the method calls.
He clearly has a much better understanding of APIs than some software engineers I've worked with.
Absolutely not. No points awarded.
Declaring code declares subprograms. They are defined by the implementation.
> A declaration provides basic attributes of a symbol: its type and its name. A definition provides all of the details of that symbol--if it's a function, what it does; if it's a class, what fields and methods it has; if it's a variable, where that variable is stored.
https://www.cprogramming.com/declare_vs_define.html
> the purpose of declaring code is to connect pre-existing method calls to implementing code
That sounds mostly right to me. Without declarations, the compiler cannot connect the function call to the implementation. Thomas ignores a crucial idea that decoupling definition & declaration enables multiple implementations for the same declaration.
> Declaring code creates the method calls.
That's nonsense. I have no idea what this means.
> That's nonsense. I have no idea what this means.
He's referring to how the workflow for an API generally involves gathering requirements, writing the "defining code", and then finally implementing the functionality promised by the interface. From that perspective, the defining code determines what implementation code is created, rather than linking up already existing implementation code.
public int max(int x, int y);
Is a program that tells a compiler or VM to add an entry to its public symbol table that allows it to compile or execute third-party code utilizing this function, and that the declaration, by itself, then qualified as a computer program and could be copyrighted, where would you draw a limit? Would two different programs that produce identical assembly instructions infringe on each other's copyright?
What about system calls for an OS? For example, Linux system calls have names, but they also have numeric identifiers. If someone copied Linux system call names in a new BSD-licensed OS, would they violate the GPL? What if they only copied the numbers?
It's interesting to think about. I'm glad this was the minority opinion.
Yup, for all intents and purposes an API is just a data exchange contract between different software.
Specifically I'm less motivated to read more of the PDF when the opening says "The copied lines are part of a tool called an Application Programming Interface (API)." I don't think any programmer would ever describe an API as a tool. A program implementing an API, or talking to an API, sure, but the API itself, is not itself a tool or program.
Declaring code in statement based languages is (1) a set of statements, is (2) used directly or indirectly in a computer, and it is used (3) to bring about a certain result. That hits all the points listed in 17 USC 101.
This is trivial to prove. Take a program that works and remove the declaring code. The program no longer works. That shows that the declaring code is indeed being used by the computer, and it is being used to bring about a certain result.
That the declaring code is not directly used in actually calling the API is irrelevant. The "certain result" the declaring code is used to bring about is the compiler producing output that works with the API.
> Take a program that works and remove the declaring code.
Actually, it will work just fine, because you the implementation necessarily has declarations in them, and you can generate declarations from the implementation.
But a program that only declares functions never brings about a result.
Declaring code is just the recipe for how to invoke implementing code.
If you allow null pointer references to a declared variable, then it certainly can.
>Declaring code does not "indirectly perform computer functions". Declaring code does not perform anything. It provides a reference, nothing more, for a compiler to match one computer program (the API client) to another (the API implementation).
I strongly disagree. We understand the obvious difference between declaration and instantiation, as declaration brings a variable into existence while instantiation specifies the variable's value. Declaring a variable is ultimately based upon available language primitives.
Whether or not he realized it, Thomas draws out a deep philosophical element of computing. Consider the creation of a self-hosting compiler. Once created, this compiler has an identity. However, creating this compiler required the usage of other software tools, each of which have distinct identities. Once the compiler operates, its creating tools become unnecessary to it, as the compiler operates independently (though the broader system may not). His phrase "triggering prewritten implementing code" has full-stack implications, whereas the majority opinion considers scope.
To connect to hierarchical processing model of programming, the majority opinion says a top-level processing block is special, whereas Thomas says no processing block differs from one another.
From a business perspective, I agree with the majority. From a philosophical perspective, I agree with Thomas.
A related concept which comes to mind is killing in self-defense. We may say killing is killing is killing, yet society acknowledges a limited set of circumstances where it becomes permissible. In both self-defense and this court case, the difference in permissibility is context within a broader system.
We reach the conclusion that in this case, where Google reimplemented a user interface, taking only what was needed to allow users to put their accrued talents to work in a new and transformative program, Google’s copying of the Sun Java API was a fair use of that material as a matter of law.
Also, while I hate to just repeat things that have already been said, I feel compelled to say
"What a relief!"
because this would have been a complete disaster if they had gotten this decision wrong. In fact, I'm not sure "complete disaster" is a strong enough phrase to reflect what it would have meant for the software industry if this had come down the other way. So getting this looming disaster out of the way is a tremendous relief.
Google implemented exactly enough to create the illusion of letting people use their Java talents then dragged their feet with a half broken out-of-date language environment.
And they did all this to save money, not some sort of noble rebellion or clever hack.
> Sun offered a licensing deal of between US$30 and 50 million. Schmidt said Google would have paid for that license, but they were concerned that Sun had also requested some shared control of Android along with the fee.
A pittance for Google but that vague "some control" sounds really bad right? Well fortunately there's a history here and we know from past licensing deals (J++) this control is enforcing interoperability with other Java implementation. And of course Oracle spells that out pretty easily:
> Oracle states that Sun refused because Google’s intention was essentially to fork Java to a Google version of the language, and to prevent it being inter-operable with other versions, an idea which was “anathema” to the “write once run anywhere” basis of the language.
Google got a cheap license and the only stipulation was "don't fuck up the Java ecosystem by having your OS run Java-but-not-really" but that was too much for them and exactly what they ended up doing!
I don't know why people are acting like this is some victory of open source. Maybe a victory for open source, but championed by a greedy corporation that fragmented the Java ecosystem for years.
I wish Oracle could have taken another angle here, they deserved damages from Google for this. Google literally pulled a J++ and got away with it.
I don't know that anybody is saying that Google did anything specifically Good or Just or Noble or anything. The celebratory aspect is more based on all the Bad Things that would have happened in the future if this decision had come down in favor of Oracle.
And I've seen plenty of people paint Oracle as some evil boogeyman like this is some good vs evil struggle.
Oracle wasn't trying to make Bad Things happen. They were seeking damages from a damaging situation, and if bad things had happened... I'd blame the patent trolls and judges that enable them.
Their insanity continues regardless of the verdict after all, and there are plenty of otherwise reasonable takes ruined by their existence.
I didn't say they were.
They were seeking damages from a damaging situation, and if bad things had happened... I'd blame the patent trolls and judges that enable them.
The issue at hand is about copyright not patents.
And note that I'm not saying that nothing bad can, or will, ever happen again. I'm just saying that the consequences of this decision coming down the other way would have been Very Bad, which makes the current decision a Very Good Thing in general.
“Don't anthropomorphize the lawnmower.”
But people were upset the lawnmower tried to take the hand at all
Google started out with the stated intent to not be evil but now they're allowing that possibly and are making good progress.
It would have become MUCH more dangerous to provide an alternate implementation of someone else's library or interface, which I believe would have have a profoundly negative effect on the entire software industry.
As it currently stands, APIs absolutely fall under copyright laws.
Yes, but now there is a very strong precedent establishing the idea that copying those copyrighted API's is OK anyway (under Fair Use) under at least some circumstances. And based off the way the SCOTUS decision was worded, it strikes me (admittedly, IANAL) that the set of circumstances that are captured by this are pretty large.
This opinion doesn't say so.
"We shall assume, but purely for argument’s sake, that the entire Sun Java API falls within the definition of that which can be copy-righted. We shall ask instead whether Google’s use of part of that API was a “fair use."
And even in this, they rather go with the easier fair use claim that is case-by-case.
Given the countless and fundamental APIs that are typically used in any program, do you not think that is a Bad Thing?
Given that most programmers have assumed that to not be the case, it would be very bad for existing code at the very least.
Also, given most programmers’ assumptions, I would not base much on that alone :D But IANAL, so do ask one, to be safe.
Google never promoted Dalvik as being a licensed Java VM implementation and never claimed it was a compatible Java runtime. The license was for logos and trademarks. As long as they didn't use those logos and trademarks, there's no violation of the license for those things. The API case is based on copyright, not trademarks or licenses so is a separate issue.
This is why Microsoft could lose their dispute with Sun over the MSJVM which was a non-compliant JVM implementation, but still come out with J# which was an implementation of the Java language running on .NET.
Microsoft licenses the Java trademarks and claimed the MSJVM was an implementation of the Java runtime, while breaking compatibility requirements for the license. Therefore they were in violation of the license. The .NET platform was never claimed to be anything to do with Java, so having Java code run on it in the form of J# was fine. The situation with Google using the Java language running on Dalvik is exactly analogous.
The license included using Java's name and trademark and that was for Sun's benefit, not Google. Google wasn't asking to call it a Java phone. That's why part of the testimony is actually Sun saying they'd pay for that
And the rest of your comment is completely missing the mark here.
You're saying MS was in the wrong with J++ because they licensed Java.
I'm saying MS was in the wrong because saying you're using language X then randomly not supporting parts of that language is a shitty thing to do when you have a large presence because then you start to fragment the language's user base.
Copyright be damned. (Which is exactly why I said I wish they could have taken a different angle)
-
Logo or no logo, for years Google said you program Android in Java.
Their "Java" did not track the language everyone else knows, using a strange smattering of features from 6 and 7 in this weird hybrid that hobbled along.
As a result there was plenty of confusion among developers about what worked on Android. As someone who has mostly held day jobs that involved Android for a decade or so now, I can confidently say it was problematic and Android dragging its feet while being such a large platform caused people to avoid using language features.
When Lambdas first landed for example, I remember multiple projects refusing to use them since there was no official way to support them on Android (retrolambda which was written by a former coworker of mine addressed this)
This is so simple, Android should have licensed Java, created a compatible implementation, and kept it up to date. Would it have been hard? Yes. Would it have been better for Android developers who ended up using wonky work arounds, people learning Java and dealing with two sets of rules, and the Java ecosystem as a whole? Also yes.
Like in Java 7 days Android didn't support NIO, randomly didn't support certain forms of exception handling, had random holes in library support (core Java libraries mind you, not the sun stuff)
The odds you could take a random XML parsing library for example and use it in an Android project were low. Random namespaces would be missing, cryptic errors tied to missing language support, the works.
Like you realize the idea of having a kinda-almost-the-same language being damaging is already known. J++ was not the same set of circumstances, but it shows that yes, you can make a language similar enough to benefit and at the same time be different enough to damage.
I mean literally QNX had better support through some vendor we were using at the time, but somehow Google couldn't do better?
But the dissent raises an interesting point. I think it shows how the crafting of legislation by people who are wholly ignorant of technology can create problems. While programmers recognize the difference between an API and it's implementation, Thomas makes the interesting point that the relevant legislation does not (page 4 of the dissent):
> Copyright law generally protects works of authorship. Patent law generally protects inventions or discoveries. A library of code straddles these two categories. It is highly functional like an invention; yet as a writing, it is also a work of authorship. Faced with something that could fit in either space, Congress chose copyright, and it included declaring code in that protection.
> The Copyright Act expressly protects computer code. It recognizes that a “computer program” is protected by copyright. See 17 U. S. C. §§109(b), 117, 506(a). And it defines “‘computer program’” as “a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result.” §101. That definition clearly covers declaring code—sets of statements that indirectly perform computer functions by triggering prewritten implementing code.
While it clearly is in the Court's prerogative to interpret law, there seems to be a pretty good case that the court didn't provide an interpretation for a gap in the law, it instead fixed a law that didn't make sense.
"We shall assume, but purely for argument’s sake, that the entire Sun Java API falls within the definition of that which can be copy-righted. "
No they specifically omitted saying this.
Since it's API's all the way down, this is needed to protect any application on top of the BIOS/OS/HAL.
Otherwise, very little would be protected by copyright.
However, it's entirely possible that "indirect" is a word with a definition that is different to our understanding in legal documents.
When the API definition is a small portion of a work, it is fair use to reimplement the api
Let me give you one example as an electronic musician. Once upon a time, Steinberg created an API for connecting programs which simulate musical instruments and musical effects (think reverb, echo, flanger, etc.) called VST. This API was always proprietary but everyone ending up using it, including the open source Audacity program which uses an open source re-implementation of the VST API, allowing it to use professional effects when editing tracks.
Well, Steinberg decided that VST2 — the one everyone has been using — was out of date and removed all downloads to the VST2 API, since they wanted users to upgrade to VST3. While a lot of professional music making tools have updated to VST3, others have not, and a lot of tools will never be updated. Steinberg no longer has a copy of the VST2 SDK available for download; they’re really trying to get everyone to update to VST3.
Now, with this horrible “Google vs. Oracle” precedent looming over everyone’s head that a company was allowed to copyright an API, Steinberg could had, in theory, said “VST2 is copyrighted, and Audacity is not allowed to use their own independent implementation of that API” (they didn’t in practice because they know it’s bad business; indeed VST3 is dual licensed, where GPL3 is one of the license options).
With this precedent, the Audacity team can more easily retain their independent implementation of VST2 knowing the legal precedent saying re-implementing an API is fair use.
It was always possible to release APIs as open-source. There's as much chilling effect about proprietary software as there ever was being careful about using licensed work, and that was never a problem.
On the other hand, the hunting season on companies providing software is now open. You're a startup providing a new database, or a well-thought library? Shit, you better take the VC money before someone else does and puts you out of business. And when a company like Amazon comes with an offer, you better not be in a bargaining mood.
Interesting to see SCOTUS citing Lotus v Borland, which was originally deadlocked at 4-4 (although Breyer seems to have voted in favour of Lotus back then). Does this elevate the precedential value of Lotus?
This case involved copyright, not patents. Copyrights are separate from patents.
https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_....
Prenda made its money by suing people who allegedly downloaded pornographic films online. Its targets frequently agreed to settlements worth a few thousand dollars rather than facing a courtroom process. These copyright trolling tactics netted the company more than $6 million between 2010 and 2013.
https://arstechnica.com/tech-policy/2019/07/prenda-law-porn-...
If his strategies had ended up a valid, legal option we would absolutely see trolls expanding into this. John Steele was testing the waters and got eaten by the deep acting as a warning for how not to go about this.
There's some DMCA takedowns and such still, but they aren't quite lucrative enough to show up on patent trolls' radars. Aquila non capit muscas and what have you. A several billion dollar copyright claim like Oracle's passing SCOTUS muster absolutely would have shown up on their radar though.
Prenda is an example of how misuse of copyright is already in the trolls' toolbox.
Since you think about this stuff you might find the latest on the Santa Cruz Operation interesting:
https://arstechnica.com/gadgets/2021/04/xinuos-finishes-pick...
Xinuos is the company that purchased the remnants of the SCO Group in 2011. The SCO Group, in turn, is a company most famous not for its actual products but for its litigation against IBM and Linux. That litigation began in 2003—partially funded by a very different Microsoft, only five years after the leak of the Halloween documents in which Microsoft acknowledged the "long-term viability" of open source software and discussed strategies to choke it out of the market.
Or prevent them from eradicating competing or even original projects by doing hostile rewrites or forks?
Wouldn't this directly contravene the findings in this case?
Java was a mobile OS before Android literally obliterated the market after copying Java. Arguably, if Android was fair use, everything is fair use and all software copyright is fundamentally defeated by this ruling.
He complains about the names of functions being "expressive content". Yeah, "max" and "toIndex" are real expressive.
Also, what the hell is this logic?
https://twitter.com/KardOnIce/status/1379080086880665606/pho...
The English common law system relies heavily upon judicial precedent. A ruling in this particular case that the copying of an API constitutes fair use will inform decisions in future cases of similar copying.
"Congress rejected categorical distinctions between declaring and implementing code. But the majority creates just such a distinction. The result of this distorting analysis is an opinion that makes it difficult to imagine any circumstance in which declaring code will remain protected by copyright."
I concur with Thomas (not in the connotation - he thinks this is a bad thing, I do not - but in the denotation). This ruling is such strong precedent that almost any API cannot be bound by copyright that no company is going to be willing to spend the money to raise the question.
In this particular case, Google's copying of interfaces was ruled to be fair use because its purpose was to allow Java developers to reuse their skills. This reasoning only holds for the declaring parts of the copyrighted work though. And that's why the distinction becomes necessary even if Congress rejects it as a primary distinction between copyrightable and non-copyrightable work.
That's also why I think the ruling is perhaps not quite as broadly applicable as some (including Thomas) are thinking right now. It may not cover code that isn't used by a significant number of developers. I haven't read the entire ruling, so I'm not sure whether it covers non-public interfaces that are nevertheless useful for interoperability. Such interfaces were at the center of past disputes (I think Microsoft's SMB protocol was one such case).
Open source code is still usually copyrighted. Nobody would trust closed languages and APIs unless they paid a fortune for them while open source with a grant would be safe to use.
In particular, social-media aggregators (one app to display your Twitter, FB, Instagram, etc.) may have new protections.
https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_....
The first phase of the case lasted from 2010 to 2015. Oracle successfully established that APIs are copyrightable, but their claims of patent infringement were rejected. Google petitioned the Supreme Court in October 2014 to review the case, but this was denied. A second petition by Google in January 2019 included the judgement that APIs are copyrightable. The Supreme Court agreed to review this part of the judgment in November 2019.
To the degree that SCOTUS has found that an API can be copyrighted, there is still room for copyright trolls to operate.
...enforcement of the Sun Java API copyright might give Oracle a significant share of these funds. It is important, however, to consider why and how Oracle might have become entitled to this money. When a new interface, like an API or a spreadsheet program, first comes on the market, it may attract new users because of its expressive qualities, such as a better visual screen or because of its superior functionality. As time passes, however, it may be valuable for a different reason, namely, because users, including programmers, are just used to it. They have already learned how to work with it. [...]
This source of Android’s profitability has much to do with third parties’ (say, programmers’) investment in Sun Java programs. It has correspondingly less to do with Sun’s investment in creating the Sun Java API. We have no reason to believe that the Copyright Act seeks to protect third parties’ investment in learning how to operate a created work. [...]
Finally, given programmers’ investment in learning the Sun Java API, to allow enforcement of Oracle’s copyright here would risk harm to the public.
If one were to apply the above logic to anti-trust instead of copyright fair use, one might wonder if the Court could find harm to the public in certain behaviors of e.g. a monopoly email provider or monopoly social networking site.
(A big argument against anti-trust enforcement against Google and others is that the Sherman Act is designed to protect consumers, not competitors.)
From 2018 (Oracle revives matter via appeal): https://news.ycombinator.com/item?id=16688521
Edit: Fixed, had written "Jury finds for Oracle", which was NOT what happened in 2016. Argh.
What happens after this, more appeals or is this like a proper static const readonly final?
This made me laugh out loud. Thanks
Most recently (that I'm aware of) is South Dakota v Wayfair. SCOTUS previously held that states couldn't impose sales tax on out-of-state companies. Subsequently, many states imposed "use taxes" which are essentially sales taxes paid by consumers on purchases they didn't pay sales tax already to get around this. Colorado passed a law which required out-of-state companies to essentially provide sales tax computation information to Colorado (but not sales tax itself), and Kennedy noted in his concurrence that maybe it was time to revisit the sales tax precedent. So South Dakota went ahead and passed a sales tax on out-of-state companies in direct violation of previous precedent, and SCOTUS promptly overturned that precedent when it heard the case.
The point in this case was, can Oracle overturn the "phone books cannot be Copyrighted" concept baked into tech law by the IBM v Compaq BIOS case. Seems the Supreme Court finally told Oracle the collection of method signatures from the Java base API are, indeed, a phone book.
> Re- viewing courts should appropriately defer to the jury’s findings of un- derlying facts, but the ultimate question whether those facts amount to a fair use is a legal question for judges to decide de novo. This approach does not violate the Seventh Amendment’s prohibition on courts reexamining facts tried by a jury, because the ultimate question here is one of law, not fact. The “right of trial by jury” does not include the right to have a jury resolve a fair use defense.
I'm not a lawyer so I don't know exactly what this means, other than the SCOTUS saying that it can override the jury decision.
It's worth noting that the higher court can reject your appeal. You're not entitled to be seen by the higher court, and if you can't come up with good grounds for why the lower court was wrong, the appeal will be rejected. The Supreme Court rejects a fair number of appeals (I think the majority of cases).
This is final though. There is no higher court than the Supreme Court to appeal to. At this point, the only reason it would change is if the laws change, or the Supreme Court reverses their decision later. It's extremely rare that they whole-hog reverse a precedent that they set, though.
My understanding is that a jury's primary task of deciding on the facts is final. The facts in a case like this seem to me to be things like deciding whether Oracle in fact holds the copyright, and whether Google's copy of the API is sufficiently similar for that copyright to apply to Google's copy.
Now as far as appeals go, you can appeal whether the trial was done properly, such that the jury was able to do its fact-finding job correctly. You can appeal what was then decided based on those facts (e.g. sentencing). You can appeal meta-questions, like whether a particular decision is a "finding of fact" or not to start with.
The question of whether "fair use" is the sort of thing that is decided by judge or jury is apparently somewhat contentious in this case; I just found https://www.law.uw.edu/wlr/print-edition/print-edition/vol-9... describing some of the issues there. Today's decision refers to this as well: it's (c) under "Held":
> (c) The fair use question is a mixed question of fact and law. Re- viewing courts should appropriately defer to the jury’s findings of un- derlying facts, but the ultimate question whether those facts amount to a fair use is a legal question for judges to decide de novo. This ap- proach does not violate the Seventh Amendment’s prohibition on courts reexamining facts tried by a jury, because the ultimate question here is one of law, not fact. The “right of trial by jury” does not include the right to have a jury resolve a fair use defense. Pp. 18–21.
which sure sounds like the Supreme Court effectively decided that the final determination of whether a use is "fair use" or not should be made by a judge, not a jury. Then they proceed to make that determination in this case in holding (d).
The idealized rule is that the jury is the final arbitrator of matters of fact, while judges (and appeal courts) decide matters of law. Ideals don't match reality cleanly, especially on matters like fair use which is "mixed fact and law." But additionally, you can sometimes appeal matters of fact by arguing that no reasonable jury could have reached the facts as it did (these are very rare, as I understand it, except in situations where mixed fact/law comes into play).
Some other points you're missing. First, you have to appeal on particular failures of law; you can't just appeal that you don't like the decision. In particular, if you try to appeal past the appeal court to a higher court, you can only make arguments that you made to the appeal court.
Another important thing is that appeal courts can push the case back down to the lower court to redecide based on clarifying law. That's what happened here, essentially. Google won on the trial, Oracle appealed saying that the judge incorrectly ruled that the API wasn't copyrightable (and the appeal court agreed with Oracle), which told the lower court to try it again with the correct ruling on API copyrightable. Google tried to appeal SCOTUS, who refused to hear it. Lower court had another jury trial, which found Google had fair use. Oracle appealed again to appeals court, which found that the jury couldn't have thought it fair use. Google appealed to SCOTUS, which just now disagreed with the appeal court.
"The fair use question is a mixed question of fact and law. Reviewing courts should appropriately defer to the jury’s findings of underlying facts, but the ultimate question whether those facts amount to a fair use is a legal question for judges to decide de novo. This approach does not violate the Seventh Amendment’s prohibition on courts reexamining facts tried by a jury, because the ultimate question here is one of law, not fact. The “right of trial by jury” does not include the right to have a jury resolve a fair use defense."
Considering that the votes were not close, I don’t think Oracle would try again. Likely they will pursue a substantially different strategy to try and extort Google.
I'm pretty confident that Oracle rolls over on this issue permanently.
SCOTUS altered the interpretation of the law, thus removing the legal justification for why the jury found infringement. Since they did not alter any findings of fact (they did not need to) this ruling is legally fine.
A jury can say you definitely did X, that court's judge can say X is illegal, and SCOTUS can then declare X is legal so it doesn't matter anymore if you did X.
They were then overruled by the Federal Court, which has now in turn been overruled by the Supremes.
It is a change in decision from the appeals court, not a change from the jury's decision.
> The argument centered on a function called rangeCheck. ... It was in Oracle’s interest to play up the significance of rangeCheck as much as possible, and David Boies, Oracle’s lawyer, began to argue that Google had copied rangeCheck so that it could take Android to market more quickly. Judge Alsup was not buying it.
> “I couldn't have told you the first thing about Java before this trial,” said the judge. “But, I have done and still do a lot of programming myself in other languages. I have written blocks of code like rangeCheck a hundred times or more. I could do it. You could do it. It is so simple.”
https://www.theverge.com/2017/10/19/16503076/oracle-vs-googl...
https://majadhondt.wordpress.com/2012/05/16/googles-9-lines/
Is this example correct? Can someone explain to me how this: if (toIndex > arrayLen)
is correct?
If the array length is say 5, and toIndex is 5, that should still throw an index out of bounds exception, right? But it would be acceptable here.
Here is Dijkstra's opinion on why:
https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
EDIT: as has been pointed out, the inequalities are correct. The original code can e.g. be found here, including doc comments showing the intended meaning of the arguments: http://www.groklaw.net/pdf3/OraGoogletrialexhibits/2012-04-2... (all the way at the end)
He learned Java for the case, but he was already an accomplished developer: https://www.theverge.com/2017/10/19/16503076/oracle-vs-googl...
SCOTUS rules on the legal and fundamental matter, not the subject. So if the attorneys for one side or the other are able to manipulate the judge into making a weak ruling (even one not in their favor), the appeals courts rulings will be impacted. In this case, the trial judge went above and beyond to avoid that kind of bullshit.
That David Boies? I guess law firms will represent whoever will pay, but it seems somewhat funny that he also represented The SCO Group in their litigation against IBM...
Disclaimer: I was previously employed by Amazon and currently Google. Opinions are my own, I'm not a lawyer, etc.
My understanding is that all of the APIs in question are shared between the (now-Oracle) JVM and the OpenJDK implementation. (Indeed, I think the actual implementation of the Java code in question is the same between the closed and open source versions, it's only the JVM itself that differs.)
Some of the argument was over whether the Apache licence inherited by Google from Harmony was valid, or whether Harmony itself was in breach of copyright (and therefore had no valid licence Google could use).
Once the courts decided APIs are copyrightable the argument switched to whether Google's was Fair-Use, with a jury saying it was, federal appeals court saying no, and thus it ended up at the Supreme court.
Here's a Groklaw [0] copy of an early (April 2012) Oracle argument asking for Jury instructions around the licence topic that explains it well:
"As made clear by Apache itself, Apache never had a license from Sun or Oracle for Harmony. Apache had no rights to Java technology that it could give to Google"
Google’s initial launch of their cloud storage copied not just the S3 API, but also the error codes.
The idea in that case was that when you try to implement something identical to the Java language and standard library, it doesn't matter if you call it Java or "Visual J++"; you are still implementing Java and thus in order to be able to do that you need to agree to Sun's terms (in that time, it was that your implementation needed to pass a testsuite and among other things needed to be "write once run everywhere", something the MS one definitely didn't as it was offering lots of non-portable extensions).
Now to my understanding the opinion here is that literally Sun was trying to do the same to Google (forcing them to ensure their implementation was compatible with Sun's, including being able to run Android software under Sun's JVM), which would have quite put a setback to Android at least as it was at that point (could you imagine Android forced to go with Swing?).
If I try to be fair, I find that in fact Android did succesfully pull the embrace-extend-extinguish strategy that MS was prevented to by legal reasons, and as a consequence basically killed Java on the mobile space (though Oracle has a lot of blame to share here). Perhaps the tides turned and now Google is seen as the lesser evil when compared to Oracle, while in the past Sun was seen as the lesser evil compared to MS. But is there any objective reason why the two rulings should have gone differently?
I am actually completely undecided about how I would have liked this ruling to go. I can see some of the repercussions of being able to copyright "header files" way too dangerous to ignore, but on the other side I have already seen the consequences of not being able to, and they are also bad.
Alien vs predator...
The real answer is that copyright is the wrong tool to go after what Microsoft did and the correct tool for that is antitrust. EEE is anti-competitive even if copying an API is fair use.
On the flip side, if Microsoft had been judged by the same standard, they might determine that Microsoft's reimplementation of an incompatible Java would have too much of an economic impact on the original to be fair use.
But Google (at least with respect to phone OS) was in the position of the startup, and Sun was the big market player. Now, Google had with ridiculous resources at its disposal, of course, but at the time not using a monopoly position to twist arms of carriers, for example. It's not anti-competitive to spend a lot of money to win.
Of course, things change....
Google however made sure to always be clear about "the Java Programming Language" or such safe phrase that makes clear that they're not the official thing.
The particular issue was that Microsoft was extending some of the Java language (and maybe com.sun?) classes. If you used any of their extensions, then you had code that could only be compiled with Microsoft's compilers, and you were locked in. (The "extend" phase, which is then leveraged for the "extinguish" phase.)
It's worth pointing out that the list of examples of "Embrace, Extend, Extinguish" on the wikipedia page of that name [1] contains zero actual successful examples of it working. Perhaps you have noticed that you aren't reading this page in an ActiveX control.
This is a boogeyman. Don't be afraid of it.
[1]: https://en.wikipedia.org/wiki/Embrace,_extend,_and_extinguis...
Looks like the successful examples were successful enough for everybody to forget about the originals. There is basically no other YP/Kerberos/SMB implementation in use that didn't follow from the MS copy. Netscape was successfully lead to bankruptcy. All the EEE days platform independent dev-tools were successfully lead to bankruptcy. All the EEE days competing office suites were successfully lead to bankruptcy...
You seem to be conflating "beat in the marketplace" with EEE. Netscape didn't fail because of ActiveX. They failed because web browsers and web servers became free.
Competing office suites struggle not because Microsoft extended some underlying protocol. Like it or not (and I personally don't), Office delivers an incredible amount of business value to its users.
Platform independent dev-tools were, and are, still around. But like the browser, it's tough to make a living selling dev tools when they are generally free.
Microsoft has been a very successful company for many reasons. It's not clear that "Embrace, Extend, Extinguish" is one of them.
I will also point out that this page does not contain the letters "Novell" anywhere within it.
Any non-trivial app always needed a lot of platform-specific code and API calls to get that native look and feel.
Microsoft lost because Microsoft had signed a contract with Sun, and was found to have broken the terms of the contract.
Google never signed a contract with Sun, so was free to act in ways that Microsoft was not.
I wonder if Microsoft's actions could have been ruled at the time as violating antitrust laws instead, if the copyright interpretation had fallen flat? Perhaps upcoming antitrust investigations into Google will look at their re-implementation of Java interfaces in the same light?
I'm sorry, but this smells like a bad faith argument.
https://www.independent.co.uk/life-style/gadgets-and-tech/ne...
In the case of the music project, it was for the protection of the community, but I can imagine such a system being used selfishly for software APIs.
Have you ever used code generation as part of software you have built?
Is there any reason why generated code could not be copyrighted as part of a larger system?
For example, suppose I define a data model for a public-facing API and then generate SDKs in various popular programming languages to interact with the public-facing API.
If I were a major corporation that owned such a public-facing API, then I would expect that the generated SDKs would carry the major corporation's copyright.
edit: Another example of generated code would be the code generated by lexer analyzer generator and parser generator tools such as lex (https://en.wikipedia.org/wiki/Lex_(software)), flex (https://en.wikipedia.org/wiki/Flex_(lexical_analyser_generat...), YACC (https://en.wikipedia.org/wiki/Berkeley_Yacc), and bison (https://en.wikipedia.org/wiki/GNU_Bison).
If you create commercial software that includes YACC-generated code, wouldn't the generated code be copyrightable?
The involvement of actual human creativity is required for a work to be copyrightable.
So human creativity is involved, but is not the direct creator of the SDKs. Does that count? I am not really sure.
I bring up the generated SDK example because I have used just such a system when I worked at a major corporation: I created a data model in Web Services Description Language (https://en.wikipedia.org/wiki/Web_Services_Description_Langu...) and used a company-owned tool to generate SDKs in various programming languages. All of the generated SDKs had the company's copyright notice in the generated code.
The code generated SDK is a derivative work of the human-defined data model - just like the binary for any piece of software is derivative of the source code. (Otherwise where'd the copyright for the binary come from?)
The generator's copyright (or the compiler's) doesn't directly flow in. (But if the generator/compiler incorporates pieces of itself, like a support library, that does. Also, the generator/compiler might have terms of use...)
If you write a generator that just generates random APIs, those are basically machine generated garbage and wouldn't be copyrightable. The human input to the generator is missing.
[FWIW, I had to research this due to an "ill-behaved" community member on an open source project a few years back; I'm not completely making this up out of thin air. That still doesn't make me a lawyer though ;)]
I think this is the key statement that will make a difference. If you want to copyright a larger system, generated code is not a problem. If you want to copyright an individual, generated piece of code, I doubt you'll get copyright for that. But IANAL either.
While I'm at it, in a similar vein though entirely unrelated, i sometimes think of ways to create jurisprudence in your favor: You try to emulate a situation to your disliking - e.g. aggresive data hoarding - and file suit to yourself, try to argue the arguments that your target would probably file, but just crappy enough that you actually lose. Do this often and stealthy enough and voila, you might have generated enough jurisprudence to actually file your final claim based on your previous "lost" lawsuits. I do think that this actually does happen at times, though.
The patent for Monopoly is https://patents.google.com/patent/US2026082A/en which expired in '52
There is also issues of trademark on the '-opoly' games... which was settled in '83 with https://www.americanbar.org/groups/intellectual_property_law...
> Finally, in 1983, the Supreme Court let stand an appeals court ruling that the word “Monopoly” had become generic, because purchasers associated the name with the product rather than with the source.7 Specifically, evidence showed that purchasers of Monopoly were motivated by their knowledge of the game, and not by its association with Parker Brothers. Directly as a result of this case, Congress amended § 14(c) of the Lanham Act, which addresses cancellation of a registered mark, later that year. Congress added language clarifying that a mark becomes generic only if its “primary significance . . . to the relevant public” is as the generic description of the particular goods or services, and that purchaser motivation is not used as the test.
---
There are clones of Monopoly because the patent expired long ago and the trademark was lost in 83. ... Which is also why McDonalds did its Monopoly game in '87.
Are you saying McDonald's needed to wait for the trademark to expire? Or that they had to wait for a new trademark to be established? Wasn't the promotion collaborative?
Looking at McDonald's Monopoly commercials from 87 [1] and 88 [2], there's a Parker Brothers TM in both years.
McD's probably waited until the trademark on Monopoly was sufficiently weakened for them to go out, license the other parts of it (as it was Parker Brothers(TM).
https://tmsearch.uspto.gov/bin/showfield?f=toc&state=4803%3A...
In particular - https://tmsearch.uspto.gov/bin/showfield?f=doc&state=4803:qp... is likely the one that they're referring to which covers the trademark on the board and game pieces - which is different than the game name.
Also note that many of those (now dead) trademarks were all filed in '85 - '87... after they lost the trademark in '83.
And IANAL, but I think that strategy could fall under https://en.wikipedia.org/wiki/Frivolous_litigation.
So does this case really boil down to the Monkey being free and not owned in that you can't take their copyright away, but you could if you owned the monkey?
I feel like the structure of our civilization is not stable, the focus and balance of capital power, the law and the ecological direction we are headed. I saw this play once and I didn't understand a bit of it.
That is "work for hire." You are the creative author of the code, but since your creativity is being applied at the direction of another, it is that person who owns the copyright instead of you. The Copyright Office has a document to explain how to decide whether or not your work is a "work for hire."
As applied to monkey selfies, it's possible that the human photographer who set the situation up owns the copyright instead, but this wasn't argued in court.
(Appeals courts can still settle case law, even if SCOTUS doesn't hear the case. There are several precedents that are set by appeals courts and not SCOTUS itself.)
A fixed, CCTV feed of a beach with a daily sunset is not copyrightable, nor is a non-human using a photo camera.
The installer or the owner of the equipment?
What's the difference if they leave the camera there for longer? They still chose the placement and the angle and the lens. In either case, the camera's electronics are deciding the minutiae of the image acquisition.
What would be the difference between a "generated text or melody" you present to copyright, to one you've written yourself?
What would be the mark of "automatic generation" that would be used to identify them as such and disqualify them?
None, but you wouldn't get copyright, much like you can present the works of others as your own but won't actually get the copyright if you're not the creator.
Second, even if you have used a generator tool, regardless of if you wrote it or just run it, you're the creator of the works it produced, and you can trivially get copyright for it, unless somebody else copyrighted the same work.
Half of Brian Eno's output is generated works, where he sets some rules on a music synthesis system, and lets it create a work. Never had any issue copyrighting them...
Sure, just as nothing is stopping you from walking into a store, taking something, and walking out without paying. It's when you get caught doing so that the trouble beings. If you get caught, not only do you not get the copyright, but you've likely committed fraud.
Proving that you're not the creator is another issue, which would probably make for an interesting case.
> Half of Brian Eno's output is generated works, where he sets some rules on a music synthesis system, and lets it create a work. Never had any issue copyrighting them...
That's somewhat different though. Setting rules makes it a predictable process, and you have a one-way system: you set the rules and you always get the same result. A generator that would generate all possible results isn't the same.
If you sifted through all those randomly generated things, found one that you like, and published it, things get fuzzy, I guess. Maybe the curation would qualify as the creative input.
Well, there is. If you get caught you get to jail.
Whereas if you get "caught" saying this generated melody is your melody, nothing happens. It's a totally valid thing to copyright. (And even if it wasn't, unlike the store theft case, there's no way for anybody to tell and prove it's not yours anyway).
But in any case, you appear confused as to this.
Whatever tool you can use to create a melody, the melody is still yours to copyright (unless somebody else came with it first and copyrighted it). You don't have to "think" of the melody or write it on the piano, or something.
In fact tons of melodies nowadays are written partially or wholly by compositional tools.
People using those tools have the regular claim to the output melodies, regardless of whether the tool is some DAW utility or "random melody" button (all of which exist), a music synthesis algorithm with some params and seed, or even an exhaustive, minimally creative tool to iterate over all possible melodies.
(Actually some musicians/coders did exactly the latter: https://www.vice.com/en/article/wxepzw/musicians-algorithmic... )
There's no rule "you can't copyright a generated melody".
If that was so, then no more melodies can be copyrighted after that group that was also mentioned somewhere else in the threads generated (essentially) all melodies, claimed copyright and then released them into the public domain. Alas, there is, even with people claiming copyright on individual generated melodies!
Again, I think the curation is relevant. You can certainly copyright a book, even though "it's somewhere in Pi". If you endlessly calculate fractions of Pi and check them for something interesting, I'm sure you can copyright whatever poem you find.
Well, that's true.
But
(a) nobody is going to cross-check their melodies against a new copyright claim,
(b) they are not going to claim infrigement against anyone,
So there's that. And even if they did, they'd be thrown out as a joke-submission (the content being "all possible melodies" etc).
But you can submit hundreds of generated melodies, copyright them, and succesfully sue people for infringing of them. The fact that they were generated doesn't change anything.
However, that would indeed require a ton more work to prove that you did not copy any of the generated work and truly did create yours by yourself.
It would have officially mean businesses and the US governments are locked by vendors and have no right to copy API in order to provide compatibility towards other systems.
Making « VendorLocking » legally valid in favor of the vendor.
Not gonna lie I was scared by the outcome of that judgement and the catastrophic defense of Google.
I’m now relieved !
The benefits of reimplementing APIs always flow both ways. I'm glad SCOTUS recognised this point.
That is exactly what was the “damage” Oracle sued for.
> The copied lines of code are part of a “user interface” that provides a way for programmers to access prewritten computer code through the use of simple commands. As a result, this code is different from many other types of code, such as the code that actually instructs the computer to execute a task
> As part of an interface, the copied lines are inherently bound together with uncopyrightable ideas (the overall organization of the API) and the creation of new creative expression (the code independently written by Google). Unlike many other computer programs, the value of the copied lines is in significant part derived from the investment of users (here computer programmers) who have learned the API’s system.
"The Google platform just got bigger and market power greater — the barriers to entry higher and the ability to compete lower. They stole Java and spent a decade litigating as only a monopolist can. This behavior is exactly why regulatory authorities around the world and in the United States are examining Google's business practices."
- Dorian Daley, Executive Vice President and General Counsel, Oracle
[1]https://www.prnewswire.com/news-releases/oracle-statement-re...
It's great for software, it'll be an interesting documentary someday. And congratulations to all the lawyers for making a ton of money.
https://news.ycombinator.com/item?id=26590524
Specifically, this thread about copying the readline API: https://news.ycombinator.com/item?id=26606328
Stallman's contention that a judge would look unfavorably on cloning the API signature because it could be viewed as subterfuge...seems very weakened here, if copying an API is fair use.
I suppose this also gives companies like Amazon a green light for clones of GPL software exposing an API that's identical.
In fact a good chunk of the case law cited today hadn't even hit the courts yet at the time Stallman made that statement.
The weird thing is it would of hurt Oracle as much as anyone. I have no clue how anyone w/any technical merit didn't understand that this was a footgun of the largest possible magnitude for them.
His reply was “without admitting anything specific, how do you know we haven’t purchased private licenses for anything you just mentioned?”
So you don't quite need a license for the shape of the plug, but you do need to pretend it's not something that it is.
> because again, a SCOTUS ruling is a proclamation to the people, once and for all, of what the law has been settled to be.
That is not how our common-law legal system works. Even setting decisions that the court has later explicitly overruled aside, when the court announces a new rule, that rule is not totally complete and set in stone. Later decisions frequently flesh out, revise, or reinterpret prior decisions.
Sun Microsystems was acquired in 2010... I guess I should give Thomas the benefit of the doubt that he intended the statement to apply to Oracle's owned IP & not be a historical account of the language's creation and creators, but this rubbed me the wrong way.
This doesn't make any sense. Justices vote in the majority while disagreeing with part or all of the majority opinion all the time. The mechanism for complaining about the majority reasoning is the same in either case: you write a separate opinion detailing your personal analysis of the case. That opinion is called a "dissent" if you voted against the majority and a "concurrence" if you voted with the majority.
There is no concept of "the dissent". Any dissenting justice is free to write one; it is routine for one case to have multiple dissents.
If you write a separate opinion while voting with the majority, that's a "concurrence", not a dissent, and those aren't mandatory either.
In this case it's "Hey, it's Oracle's code, end of story."
I noticed this when I started rereading the dissent with a s/Oracle/Sun Microsystems/g. I felt a bit more swayed when I started to recollect all my fond Sun memories: blogs, hobbyist customer experience, etc. and stopped thinking about my glowing hatred of Oracle.
The dissent does seem nuanced to me even though I am quick to dismiss it based on the premise and my superior technical knowledge and maybe a bit of my own biases that I can't quite completely ignore.
The dissent is worrying, though. For a pivotal case that would have had a profound adverse effect on the future of software development had it been decided the other way, there seemed to be a disturbing lack of appreciation of the fundamental issues in play, particularly the practical reasons that programmers separate interface and implementation and the implications of this for interoperability.
With this ruling, either software will be found to be entirely (or mostly) uncopyrightable, which is unlikely, or software copyright will turn into an even bigger legal morass that requires a team of top-tier lawyers just to understand which parts of your software are effectively copyrightable (or potentially infringing) and which aren't.
The Supreme Court should have found in favor of Oracle, and told Google to bring their case before Congress if they're so worried that API copyrightability would destroy the industry.
« Google’s limited copying of the API is a transformative use. Google copied only what was needed to allow programmers to work in a different computing environment without discarding a portion of a familiar programming language. Google’s purpose was to create a different task-related system for a different computing environment (smartphones) and to create a platform — the Android platform — that would help achieve and popularize that objective. »
« Here Google’s use of the Sun Java API seeks to create new products. It seeks to expand the use and usefulness of Android-based smartphones. Its new product offers programmers a highly creative and innovative tool for a smartphone environment. To the extent that Google used parts of the Sun Java API to create a new platform that could be readily used by programmers, its use was consistent with that creative “progress” that is the basic constitutional objective of copyright itself. »
This suggests to me that someone who copies a set of function declarations for the purposes of, say, creating a free-software clone of an existing product might not be able to rely on this decision.
They wouldn't need to rely on this decision.
The courts tend to frown on using IP law as a weapon against interoperability or legitimate competition outside the scope of what the IP law covers. If you get sued for copying Yoyodyne's API in order to develop an otherwise original piece of software whose purpose is to interact with other software that expects Yoyodyne's program, the appeals court is likely to smack the suit down citing Sega v. Accolade and Sony v. Connectix, and the SCOTUS (assuming it gets that far) is likely to agree.
One of Oracle's major arguments was that Android was not interoperable with regular Java, and in Oracle's position the fact that Google copied Java's declaring code just to screw Oracle over put Android outside the bounds of interoperability fair-use protection.
Using Stripe?
You're literally one-click away from our new Google Payments?
Just change this URL, and you're good?
I'm not as keen about the outcome as others.
It's good for open source in a way but I'm wary of big cos just wiping out smaller one's.
Also - does anyone with insight have something to say about open source APIs being copied, to get around copyleft?
Could GPL'd software now be 're-implemented' without concern?
What really happened here is that the Supreme Court did an end-run around the law to paper over a major fuckup by Congress. On the one hand, I'm glad that they fixed the problem. But the way that they did it fills me with dread for the future because it undermines the rule of law.
For the record, I absolutely despise Clarence Thomas and everything that he stands for. But in this case I think he has a valid point.
I think reasonable people can agree with Justice Thomas on this (sidebar: this is why I love reading SCOTUS rulings - they're generally wise people and both the majority and dissent sides are usually reasonable takes). The tests of "is it transformative" and "how much was taken" are probably the most subjective tests in the copyright precedent.
The precedential parts are unambiguous: Google's actions were fair use, as a matter of law (this is code to lower courts to not fuck around). The majority opinion did not answer whether APIs are copyrightable in the first place because it was unnecessary to settle the dispute.
The rest of it is obiter dicta. Thomas's objection, as is usually the case, is irrelevant.
IANAL, TINLA.
They didn't answer it. They assumed it. They couldn't reach the fair uses analysis any other way. No copyright, no infringement, no need to assert affirmative defenses like fair use.
> In reviewing that [lower court] decision, we assume, for argument's sake, that the material was copyrightable.
> We shall assume, but purely for argument's sake, that the entire Sun Java API falls within the definition of that which can be copyrighted. We shall ask instead whether Google's use of part of that API was a "fair use."
You can call all dissents irrelevant if you like. But Thomas' dissent addressed the issue of the case, and arguably more directly than the majority's. The Federal Circuit decision on copyrightability, for which the Supreme Court denied cert, still stands. Its importance, not its rule, is called into question today.
You seem to have misunderstood the idea of fair use. Fair use is a specific doctrine covering the acceptable ("fair") use of copyrighted works. Fair use of a non-copyrightable work would be, technically speaking, a contradiction in terms.
See, for example, the US copyright office's explanation: https://www.copyright.gov/fair-use/more-info.html The first sentence is "Fair use is a legal doctrine that promotes freedom of expression by permitting the unlicensed use of copyright-protected works in certain circumstances."
Furthermore, there is no requirement that fair use be non-commercial. It is more likely that the courts will find that non-commercial use is fair, but that is not a hard and fast rule. An easy example here is book reviews quoting passages from the text.
This is addressed in the decision on page 27. The Court wrote:
The text of §107 includes various noncommercial uses, such as teaching and scholarship, as paradigmatic examples of privileged copying. There is no doubt that a finding that copying was not commercial in nature tips the scales in favor of fair use. But the inverse is not necessarily true, as many common fair uses are indisputably commercial. For instance, the text of §107 includes examples like “news reporting,” which is often done for commercial profit. So even though Google’s use was a commercial endeavor—a fact no party disputed, see 886 F. 3d, at 1197—that is not dispositive of the first factor, particularly in light of the inherently transformative role that the reimplementation played in the new Android system.
Sure, but what that means is that I can do (say) movie reviews for profit and include clips from the film. It does not mean that I can re-broadcast the CBS Evening News with my own commercials.
Because of the way this decision went, I’m sure Google considers it a worthy investment and Oracle considers it a temporary setback as it pursues other extortion schemes using Sun’s Patents. I wouldn’t be surprised if they have a specific division of lawyers dedicated to finding novel ways of extorting wealth using Patents; this would likely just be one of the cases they were working on.
Come to think of it, from Oracles perspective it was definitely worth a shot, to throw a few millions (if that?) with a chance of winning billions.
Teams of high end lawyers over about a decade? Probably at least 10s of millions.
They bought Sun 12 years ago...not much time left to pursue that...
Excerpts:
The nature of the work at issue favors fair use. The copied lines of code are part of a “user interface” that provides a way for programmers to access prewritten computer code through the use of simple commands. As a result, this code is different from many other types of code, such as the code that actually instructs the computer to execute a task. As part of an interface, the copied lines are inherently bound together with uncopyrightable ideas (the overall organization of the API) and the creation of new creative expression (the code independently written by Google). Unlike many other computer programs, the value of the copied lines is in significant part derived from the investment of users (here computer programmers) who have learned the API’s system. Given these differences, application of fair use here is unlikely to undermine the general copyright protection that Congress provided for computer programs.
I would think this would crack ARM's control over their instruction set though. I can't imagine it'd be worth re-implementing literally the entire thing from scratch though when ARM will willingly sell you IP blocks, as opposed to Intel or ARM which will certainly not.
You're not going to find a lot in the west due to the patent issues (why follow that path when you're doomed to be sued into the ground), but there clearly is a desire to pursue x86 as an ISA (as opposed to going with ARM).
So the opinion effectively preserves the status quo in the software industry while sidestepping the question of API copyrightability.
* Google’s API copying can’t be fair use if they weren’t copyrightable in the first place.
* If you do copy an API because of it’s beauty and not for either interoperability with software or interoperability with developers then it seems that you would run afoul of copyright.
That's why I said it partly moots the issue, not completely. Yes, you could conceivably still run afoul of copyright in some cases, but at first blush, this seems like a precedent that will make it very unlikely that that would happen. I guess time will tell, but that's my initial perception. IANAL, of course.
So don't do that?
Why would you copy an API save to be inoperable?
If it's just to duplicate someone else's design, I think I'm okay with that potentially being a copyright violation.
What downside am I missing?
"We shall assume, but purely for argument’s sake, that the entire Sun Java API falls within the definition of that which can be copy-righted. We shall ask instead whether Google’s use of part of that API was a “fair use.” Unlike the Federal Circuit, we conclude that it was"
I love this analogy, and I'm going to use it to describe this case from now on. If I have a great idea for a new keyboard, maybe great new clicky keys or something, I have to make it QWERTY. I can't just come up with some random key ordering. And it has nothing to do with how good or bad QWERTY is as an idea. It's just that QWERTY happens to be what people have skills in.
And yes, if ease of use will be a differentiator why people like Apple (whether it's right or wrong), then so is the ability to learn is an attribute to be protected from theft.
I say all this seeing exactly where Swift is heading, and probably why Apple created the language that will run their unified APIs... because there's no other way to join except through their Swift gates.
APIs have been copyrightable (in the US) since 2014(or 15, not sure). This ruling only affects the fair use judgement, and makes no further statement on the question of copyright; meaning APIs are still subject to copyright.
Breyer's decision explicitly avoids deciding whether or not the SSO being copyrightable is good law, but it does essentially provide that it provides only thin copyright.
Am I right that this may essentially end Dart project at Google?
As far as I understand Dart was an attempt to have another Java in case that Oracle/Google conflict will not go anywhere.
As soon as Google will be able to use Java on dart platforms there will be no need for Dart.
Just guessing.
"Instead of creating its own declaring code—as Apple and Microsoft chose to do— Google copied verbatim 11,500 lines of Oracle’s declaring code and arranged that code exactly as Oracle had done."
I didn't read the whole opinion, but what is Google's excuse for this? If there's one way to do it, I don't think copyright should apply. But when there's more than one way, why should copyright not provide some protection? I guess just because it's tiny and contains little expression?
Regardless, it seems like very poor judgement to not do a cleanroom implementation here.
They _did_ do a cleanroom implementation, that's the whole issue that makes it an interesting case: are APIs fair use?
The whole point was interoperability
Re-implementing an API is how we got clone PC's when Compaq cloned the IBM BIOS interface and associated ISA bus logic which made Intel based DOS home computers cheaper and affordable for ordinary people.
That is true.
> The only way things could change now is if Congress/President passed a new law
That isn't true at all; the Supreme Court is free to change the law by itself. Someone could sue over the same question and get a different result overruling this one.
https://en.wikipedia.org/wiki/List_of_overruled_United_State...
I am not a huge fan of Google's antics in general, but in this case, I am glad they won.
https://frequal.com/java/SupremeCourtOracleVsGoogleRuling202...
focusing on two areas: * Google had the ability to make their own language and APIs for Android * The chilling effect on future language/API innovation
> the next excuse for not updating Android Java to latest versions.
The only two companies that ever had issues with Java owners were Microsoft thanks to J++ and Google with its Android Java.
Lots of companies have produced their own Java version, without any issue.
Sad that things have gone this way and Google isn't being hardly punished for what they did to Java ecosystem with their special flavoured Java and by giving Sun's fatal blow.
Thankfully they never thought of buying Sun to own Java, as it would have been yet another project on their graveyard, looking to how they handle it on Android.
But yeah lets not get distracted and join the Oracle hate mob.
While the Apache project is not a company, it definitely had issues with Sun over Apache Harmony's Java certification (I'm not confirming or denying that this was part of IBM's proxy wars with Sun).
Incidentally, Apache Harmony is what Google used to jumpstart not-officially-Java compatibility with Android.
> Sad that things have gone this way and Google isn't being hardly punished for what they did to Java ecosystem with their special flavoured Java and by giving Sun's fatal blow.
Speaking of "special flavoured Java" - what Google did with Android was an improvement over the fragmented mess that was Java ME. Good God, I remember Sun-approved, vendor-specific extension, so Samsung/Nokia/Sony-Ericsson each had its own API for the same functionality - e.g. checking for connectivity. Additionally, the API could be subtly different for each phone model from the same vendor. You either had to create different build pipelines (1 per vendor, with overlays/facades), or do an ungodly amount of reflection in your runtime logic. So much for "Write Once". Sun was never interested in licensing Java SE on mobile, I don't see how Google could have killed them when they weren't even competing on "your phone as a full-blown computer"
I loved Sun Microsystems; they were idealistic, geeky, and made very cool, albeit expensive gear. I suspect their idealism made them hop onto the open source bandwagon without due consideration for long-term sustainability. They open-sourced the OS (OpenSolaris), open sourced the application stack (Java, perhaps reluctantly), while their server hardware was being disrupted by x86; how were they going to make money? They were not long of this world - Linux, commodity x86 and open source Java Application Servers killed Sun. IBM was in a similar place at the time, and they shifted focus to consulting.
> But yeah lets not get distracted and join the Oracle hate mob.
I've been part of that mob for a long time, fuck Oracle for how they treated Gosling, how they handled the JCP, and mishandled OpenOffice (until it blew up in their face). I didn't care for MySQL, but it seems to have been ok so far.
Now excuse me while I will compile some stuff in Java 16 with the SIMD preview API.
Sun could have fixed it by availing Java SE on mobile devices and forcing vendors to implement the same APIs in the same java.smartphone.* packages - (they already had a Java TCK!), but they were not prepared for the smartphone era, sadly. Look at the CLDC[1] classes and tell me how one could write apps that could possibly compete with the iPhone apps in 2007.
1. Sadly - but predictably, Oracle nuked java.net which had documentation on CLDC 2.x/MIDP, I managed to find CLDC 1.1 documentation, the classes are surprisingly sparse, so J2ME was probably worse than I remember. https://docs.oracle.com/javame/config/cldc/ref-impl/cldc1.1/...
Now if we only could get the SC to invalidate software patents in general.
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.
The great sigh of relief I was unexpectedly gifted this morning upon seeing this at #1 was a nice surprise. Very important precedent, good job.
> Unlike many other computer programs, the value of the copied lines is in significant part derived from the in- vestment of users (here computer programmers) who have learned the API’s system.
This decision doesn't appear to speak to why the 11,500 lines were actually important, other than to 'steal' developers away from Java - which in effect is poaching without the hard paper trail and paystubs.
So in the end, I find this setting us all up for the real battle... the utility of APIs and languages, which will bring us back to settle squarely what is a 'utility' & 'design' patent, and what is a copyrighted material.
I'm curious to know who will take it up -- I doubt anyone of consequence will be copying APIs after this.
How would it been possible for Google to do this without just taking the API definitions.
Could they have just use compiler errors?
In what circumstances would non-fair-use copyright then apply?
- https://www.theverge.com/2021/4/5/22367851/google-oracle-sup...
So what if APIs were also patented?
Constitutional issues are somewhat of a mix of the political and legal. SCOTUS tries to be apolitical, but by its nature it can override Congress on Constitutional matters, and therefore it's at least somewhat political.
But cases like this are legal. Political credit and blame for this decision should go to Congress, not SCOTUS.
Of course, those interested in the legal process itself may give credit or blame to the justices for their legal positions.
This case was originally granted back in 2019. It was scheduled for oral argument in March 2020, but was postponed at the last moment until October because of the pandemic. Being postponed at the last moment, it was fully briefed well over a year ago, and the justices likely knew how they would rule in the case for a long time. (It's unclear how much of an impact oral argument actually has on influencing the decisions). That it took so long for a decision to come out--this is the last October hearing to get an opinion--strongly suggested to me that this would be a messy case with several overlapping concurring and dissenting briefs.
It is not. It is a simple 6-2 decision, with a single majority opinion and a single dissenting opinion. I'm reading between the lines here, but it seems pretty clear that Breyer (the majority opinion author) does not believe that APIs are copyrightable in the first place, but doesn't argue that point as he probably does not have enough other votes to agree with him. It's plausible that Breyer had a lengthy section on why APIs weren't copyrightable but that was pulled due to the other justices in the majority rejecting it. We can't know what the voting would break down as, but a 3-3-2 breakdown of "API is uncopyrightable; API is copyrightable, but this is fair use; API is copyrightable, this is not fair use" does not strike me as implausible. (There's not much in favor of this breakdown, note: that I lay it out like this is as much wishful thinking as anything else).
Thomas's dissent--I'll focus on that first--essentially makes two main arguments. The first is that API is copyrightable in its own right (Breyer's opinion assumes that it is for the fair use analysis but doesn't say that it is). The second argument is that Google's copying of the API cannot be fair use. A lot of that argument appears back-reasoned from "Google copied so much of the API and they made so much money off of it, how can it possibly be fair." In a broader sense, however, it's a different mode of fair use analysis than Breyer argues for. Thomas essentially views copyright as a property interest, and fair use is a narrow limitation on property interest. The API is an entity in and of itself here, so even though the API is a tiny fraction of both the original and reimplementing code, you need to look at the amount of the API itself that is being copied to judge how substantial a portion it is. Although when he turns to consider the impact that an independent implementation has on the market for the original, it's not the market of the API itself that matters but the market of the entire implementation.
Now going back to Breyer's opinion, he treats fair use rather differently. First, Breyer essentially invokes the idea that different kinds of copyrighted material deserve different amounts of protection. He draws a distinction between declaring and implementing code, and notes that since only declaring code is being copied, it pushes the factor analysis much more towards being fair use than otherwise. In contrast to Thomas, Breyer notes that commercial use isn't automatically non-fair use, and lists a few examples of where commercial use can indeed be fair use. Also, Breyer pushes hard against the idea of copyright being about property interests, noting that the Constitution expressly provides that copyright is for the progress of science and arts. Whereas Thomas places primacy on the importance of the effect of the market, Breyer instead contends that it's the least important factor here.
All the way back at oral argument, Thomas surprised me with the most insightful question: the fair use factors in the law are very explicitly a nonexhaustive list, so what other factors might exist to sway fair use analysis? At opinion time, Thomas is instead the one to declare that none other exist, while it's Breyer who rather strenuously comments that fair use analysis is not exhaustive, although he does not include any other factors in his analysis.
What's the overall impact, then? APIs may or may not be copyrightable--SCOTUS does not decide. But Breyer essentially suggests that APIs have at best "thin copyright"--a lot of their use may be inherently fair use (the same analysis Breyer does here can reasonably be copy-pasted for a lot of API reimplementation cases). What's more radical is the effect it has on fair use analysis. Breyer states that appeal courts have to reconsider fair use on appeals if juries find a use to be fair or not (that's an easy part of the opinion to miss). Breyer upends the traditional notion of how to balance fair use factors yet again. Essentially, he suggests that the analysis of fair use is dependent in large part on what kind of work is being copied, and the balancing is dependent on the kind of work. He also rejects a lot of the traditional emphasis on market or potential market analysis for fair use. This is somewhat disclaimed for wider application to non-code cases, but you can bet there is now going to be a lot of appeals surrounding fair use over the next few years.
I'll add that Thomas points out that if Breyer wants to talk about "thin" copyright, he should have discussed it within the copyrightability context, not skirting and discussing it in the "fair use" segment. If Breyer does so, Thomas argues, Breyer would find that "thin" copyright is still copyright, and Google will have no argument left to support fair use. All the remaining facts (such as competition, loss royalty, etc.) would support non-fair use.
Again I’m not a lawyer and I know there’s nuance and precedent in the law I just am having a hard time with the seemingly obvious-ness of this case.
Some examples to share how I am thinking of this:
1. Procuring land, paying contractors, buying materials, etc., doesn’t entitle you to rents in perpetuity on say an apartment you build?
Or 2. if I produce music — until that music ages out and becomes a public good — and I own the masters and all the rights to it having put in the work and the time and the money etc., am I not entitled to all the fees from licensing it to be played and consumed?
I am having a hard time seeing how it’s not a sound argument given that it seems very clear that Sun Microsystems put in a lot of work and effort and time and money to get Java off the ground and here Google comes and copies it even when there was an easy way to get a license.
Oracle could launch a new case but it would have to rely on entirely different merits. If Oracle did have such other grounds for a suit, they would have included them in this case.
Time to end this one now: https://news.ycombinator.com/item?id=26692575
This marks jurisprudence
What kinds of actions and motivations by Google could have led to a determination that the use was not fair?
Or is Embrace/Extend/Extinguish as practiced by the big tech companies now always protected by fair use?
We see the majority trying to preserve flexibility in fair use throughout, even going so far as to head off arguments that this decision affects others:
> We do not say that these questions are always relevant to the application of fair use, not even in the world of computer programs. Nor do we say that these questions are the only questions a court might ask.
> The fact that computer programs are primarily functional makes it difficult to apply traditional copyright concepts in that technological world. ... In doing so here, we have not changed the nature of those concepts. We do not overturn or modify our earlier cases involving fair use. ... Rather, we here recognize that applications of a copyright doctrine such as fair use has long proved a cooperative effort of Legislatures and courts, and that Congress, in our view, intended that it so continue.
We see Thomas leading this question in dissent:
> Because the majority's reasoning would undermine copyright protection for so many products long understood to be protected, I understand the majority's holding as a good-for-declaring-code-only precedent.
Fair use is a mishmash of vague, impressionistic factors and a long list of cases from which to argue by analogy. It's not sharp-lines law. It's finger painting.
Which is why lawyers so rarely recommend that people rely on fair use in any really meaningful way, outside areas where there have been a lot of court decisions, or where strong industry norms have evolved between repeat players.
What will Java look like at Google in 2030?
"But as long as your system isn’t heavily over-provisioned, you can expect to see average GC pause times of around 0.05ms (50µs) and max pause times of around 0.5ms (500µs)." https://malloc.se/blog/zgc-jdk16
The ART features are not exposed to the language design. The JVM features in addition to the order of magnitude performance impact it will have (cf previous comment) needs to be supported in order to maintain interop with future JVM languages versions. (cf previous comment)
It's good and healthy for a language to have multiple implementations no it's much healthier to have one that reap most of the benefits through collaboration. Hence why Android try to merge its patchset in the Linux kernel instead of duplicating it's million commits.
Sure, HotSpot might have some features ART lacks, but ART has features that HotSpot lacks, so it's a wash. Technical excellence unfortunately isn't an obligation. Or at least until the system becomes unsustainable (Cf interop) but then when it comes it is too late.
It's worth noting - the two dissenting justices were Clarence and Alito, who are both baby boomers over the age of 70, both old school conservatives. Of other two conservative justices, Kavanaugh and Gorsuch (who are also on the early end of Gen X), both sided with Google.[1] I was not expecting that. I thought they would have aggressive views with respect to the possibility of copyright infringement.
Funny moment during the case - Clarence compared Google copying Oracle to a football team stealing an opponent's playbook. That's a really bad analogy and demonstrates a lack of understanding in open source software.
Oh, and before I forget - f*ck you, Larry Ellison.
[1] Justice Barrett came in too late to participate in the decision, I wonder where she would have sided.
How about special-cased ad blocker integrations that stub ad vendor APIs? I feel like that would also run afoul of these increased copyright protections.
Actually, I've seen uBlock Origin's font blocker actually break font rendering on PDFs in Firefox in the past (maybe still today?).
https://github.com/JoshCheek/clisp/blob/master/doc/Why-CLISP...
* Some small functions were directly copied, but nothing major
Also if Sun was still around would people be rooting for them instead of Google? Oracle isn't exactly easy to love.
I'm not looking for pound keyboard replies from people that disagree, I'm just curious if there are others that have the same feeling.
The SCOTUS decision cuts through the cruft and reaches the right finding in this case. It shows that the Supremes can can pay attention and do the right thing.
So a computer program instructs processors to do things while books do not necessarily instruct neurons to do things. This seems like a leap. I could write a book with NOP for every word or I could write a program with NOP loops. Are these really instruction to do things? Like so, books do instruct people (aka knowledge).
Google took tons of APIs from a platform and implemented them into... a platform.
If you think designing thousands of classes is not substantial that's a very different argument, different from fair use.
Fair use means yes, APIs are copyrightable, but this is transformative use. And, to anyone with a clue in software dev... no it's not.
It's basically like taking someone else's script as-is and shooting a movie from it, and the court deeming this use of a script "fair use".
Disclaimer: IANAL
The wholesale expropriation of an API is not the same thing as taking a small snippet of a copyrighted work for analysis, commentary, criticism, or scholarship. It is core the value of the work.
Indeed, it's the most important part, because it defines the functionality of the product. It is what the customer sees and interacts with. It is the means by which the customer gets value. You can completely swap out the backend behind the API and the customer will still get value. Change the API and the value goes away.
From a legal perspective, this decision is 100% wrong. The plain language of the law makes that clear.
What should have happened here is that Congress should have passed an amendment to copyright law allowing for fair use of an API. They should have done so after a free and full debate, with due consideration to all economic consequences.
It is not for our black-robed, un-elected overlords to make this decision.
If I specify that my company takes orders that only have certain header columns and must have specific format in certain fields on the bill of goods, is that /specification/ (not the full text I wrote, but the facts of the specification itself) copyrightable? Why? I don't see that the abstract facts of a specification of interoperability should receive any kind of copyright.
My comment is about process, not policy.
See Baker v. Selden, which despite it's age is still good law.