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.

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.

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.

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.

This is similar to when federal courts have to apply state law.

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?

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.

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.

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.

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.

iOS is a good example though. Windows Mobile had not yet come to dominate the market.

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.

[1] https://www.fastcompany.com/27743/nothing-netscape

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.

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.

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.

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.

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".

>> 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.

  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?

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.

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 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.

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.

Majority Opinion: "We do not presently wish to venture an opinion on how this person died, but we can say authoritatively that the accused was not at the location the death took place at the time it took place. Therefore, even if a murder took place, the accused is innocent of murder"

Thomas' Dissent: "We can not decide the person is innocent of murder unless we decide whether a murder took place or not. Further, here are all the reasons I think the accused murdered the victim."

Majority Opinion: "We assume for the sake of argument that the deceased was murdered; we then argue that the accused did not do it, and rule that the accused is innocent."

Thomas's Dissent: "The facts of the case that support a conclusion that the deceased was murdered also support a conclusion that the accused did it. So if you are assuming that the deceased was murdered, you should also conclude that the accused is guilty."

"I didn't commit murder at all" doesn't have the same relationship to some hypothetical murder, rather it's claiming there's no link there at all.

The analysis does feel like it puts the cart before the horse and possibly ends up implying or easily being argued as implying a statement I think they were trying to avoid opining on absent developments in the lower courts.

I get why they would do that, but it doesn't make it less strange and I would worry that this could be analyzed to say, in effect, that APIs should all be subject to copyright.

It wouldn't even be the first time a Supreme Court ruling one way on IP had been turned on its head, either. That has happened a lot with software patents, for example.

Yes, I agree.

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).

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.

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

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

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.

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.

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.

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.

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.

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.

I'm waiting for an ambitious attorney to figure out how to frame this as poaching talent from an ecosystem to bring to another.

Translated into developers speech: this is some sort of early return. ;)

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.

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.

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.)

    if (!isFairUse(workUnderInvestigation) && copyrightable(originalWork)) {
      bigCopyrightPayout();
    }

This is false; Google appealed on both copyrightability and fair use, and the Supreme Court agreed to hear both issues.

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.

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.

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.

Sanity prevailed! This judgment could have had devastating consequences and turned software development into a copyright nightmare.

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.

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.

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.

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."

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.

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.

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.

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.

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.

[1] https://en.wikipedia.org/wiki/Eldred_v._Ashcroft

[2] https://www.legalaffairs.org/issues/March-April-2004/story_l...

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.

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.

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.