6-2 majority decision, which is pretty one-sided and really good news for open source.
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. 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.
 Justice Barrett came in too late to participate in the decision, I wonder where she would have sided.Reply
I like the outcome from a public policy perspective. The policy the court has imposed is good for the industry. But let's make no mistake -- this is legislating from the bench.
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.Reply
I am glad Oracle didn't win. It seems to me that they bought Sun just to sue Google. I'm still bitter over for how they destroyed Sun... it's a shame that they didn't have a better steward.Reply
Ok, so what is Oracle's next move then?Reply
I don't quite know how to say this but, is it possible to be happy about the outcome but have a feeling that it was probably legally not quite straightforward. I mean everyone (or most) on here is probably pleased with the outcome, but extremely biased?
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.Reply
Guess thats it for Fuchsia and FlutterReply
I had forgotten about this for quite awhile, given the pace at which these cases operate at.
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.Reply
"(e) The fact that computer programs are primarily functional makes it difficult to apply traditional copyright concepts in that technological world."
So the opinion effectively preserves the status quo in the software industry while sidestepping the question of API copyrightability.Reply
So not only a good decision, but one that was decided 6-2, with the younger judges (left and right) among those 6. It looks like it could be a solid majority on the side of sanity on this particular issue for a long time (knock on wood).Reply
I would imagine if the ruling went the other way, IBM might want to talk to all the BIOS companies. Luckily, that didn't happen.Reply
Now Google, Microsoft and Oracle can go ahead and copy little startup's APIs, or even 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?Reply
The interesting question is how broad this fair use ruling is. According to the Supreme Court's other fair use cases, fair use is highly fact-specific and therefore case-specific.
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?Reply
I cannot tell you how happy I am to hear this. My heart sank when things seemed to not go well for Google.Reply
From the dissent: "In the 1990s, Oracle created a programming language called Java..."
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.Reply
Does this mean Fuchsia/Zircon are effectively dead? I got the impression Google was keeping them as a backup in case this lawsuit went badly for them.Reply
Does this mean that frameworks like WINE are now illegal if Microsoft so desires?
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.Reply
Page 44 has Thomas’s dissent with Alito concurring. Worth a read as well, even just to see the opposing arguments.Reply
Well worth a read. "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."Reply
Is this a final judgement? Is it over now?Reply
I love this outcome. But what are people's thoughts on the analogy between a software platform and a "factory floor"? That seems wrong to me; the "factory" is more like the IDE, not the platform.Reply
Not a programmer.
If I find a service that provides and API and I want the existing developers (customers) who use the service to be able to use a competitive service and the original API is re-created in order to provide compatibility with the second service. Is this OK?
The original API is part of a commercial service, the re-created API will be a commercial service, but not the entire service just a compatibility layer.
This seems to change part of the debate on "Extracting the abstract syntax tree from GCC" that happened here recently:
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.Reply
I’m super conflicted because I think I side with Oracle here and I never seem to. Java had an established API. It had a license. Google could have licensed it and the end result would have been the same: Java apps on Android. Weren’t there even Google brass worried about this in emails? It seems to me Oracle is due license fees but SCOTUS ruled otherwise and I guess that’s overall better for the industry.Reply
Makes me wonder how much Goldstein & Russell get paid to win a case like this. Worth every cent, I assume.Reply
I don't understand why people uses such stupid font style -_-Reply
That's good for practical purposes, but they still didn't rule on APIs being copyrightable or not to begin with? It's a bit weird to say "it's fair use" but not say "it's not copyrightable in the first place".Reply
This will be great for developing nations.Reply
I am not a lawyer. Is it finished ? Has Oracle completely lost ? I really do not like very much Oracle.Reply
I love how the Us supreme court judgements are written using low level terminology that most anyone can understand with little prior knowledge. Some countries use legal and complicated jargon that its hard to follow.Reply
So does this ruling actually mean anything or can Oracle challenge this too somewhere else?Reply
Had the ruling gone in Oracle's favor I can imagine some greedy company trying to procedurally-generate every API and copyright them all similar to this project which tried to copyright all musical melodies:
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.Reply
> 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.Reply
From the dissent:
"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.Reply
The bits where they emphasise that the copying was "transformative" as part of the "Purpose and Character of the Use" analysis are interesting:
« 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.Reply
Does anyone have a good estimate of what this case cost Oracle and Google, especially in terms of legal fees, and where that money went ultimately?Reply
Why would Google do this in the first place? The reason is that they did not have time to figure out what capabilities might be needed in their own solution. So copy the API from someone's other competing product and then later, put code behind those API calls. Is it theft or cheating? Kind of, I suppose. It saved them time from having to engineer the API surface.Reply
I hope Oracle is ordered to cover Google's legal expenses for all of the lawsuits (related to this).Reply
Although I applaud the effect of this decision, I can't help but agree with Clarence Thomas that the reasoning behind it is not sound. It waffles back and forth between arguments for fair use and arguments that APIs are not (or at least should not be) copyrightable in the first place. You can't have it both ways. If APIs are copyrightable (and a plain reading of the text of the law appears to indicate that they are) then Google's copying was clearly not fair use. The purpose was clearly commercial, not educational or a parody. The API was not merely a fact or an idea, it was a specific embodiment that required effort to produce. And the copying clearly had a negative impact on the value of the original.
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.Reply
Does oracle have any moves left to counter this decision? Or are we finally clear of this litigation that has been hanging over us for so long?Reply
I'm sooo relieved that this is over!Reply
Just exhaled the biggest sigh of relief I've ever had when reading the title. Holy cow. Thank fucking god.Reply
Now while I eat my hat, I am waiting to see what will be the next excuse for not updating Android Java to latest versions.Reply
A good ruling.
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.Reply
So what does this mean for the future of Java, now that Oracle won't be able to milk Google with licensing fees?Reply
"The record also showed that Java SE’s copyright holder would benefit from the reimplementation of its interface into a different market....the jury also heard evidence that Sun foresaw a benefit from the broader use of the Java programming language in a new platform like Android, as it would further expand the network of Java-trained programmers...and because there are two markets at issue, programmers learning the Java language to work in one market (smartphones) are then able to bring those talents to the other market (laptops)."
The benefits of reimplementing APIs always flow both ways. I'm glad SCOTUS recognised this point.Reply
The comments on this case always seem a bit confused to me.
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.Reply
I have a workaround. I was thinking that an adapter socket can be patented. And use by others cannot be made declared under fair use.
So what if APIs were also patented?Reply
This has impact beyond APIs. The Supreme Court says copying User Interface is fair use.
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.Reply
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaReply
Can I copy one line from the Beatles catalog “she loves you yeah yeah”. I represents such a small % of their overall lyrics.Reply
> In this way, the declaring code’s shortcut function is similar to a gas pedal in a car that tells the car to move faster or the QWERTY keyboard on a typewriter that calls up a certain letter when you press a particular key. As those analogies demonstrate, one can think of the declaring code as part of an interface between human beings and a machine.
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.Reply
Was following this on slashdot. Kids grew up in the meantime.Reply
Now for all the money MS is paying to Oracle for C#...Reply
Regardless of how you feel about the legal question, if you read the whole thing, it’s interesting to see how much the justices differ with regards to their respective grasps of the technical and business issues. In particular Thomas’s dissent includes many very relevant business and technical facts that Breyer’s opinion doesn’t even mention. For example Java SE vs Java Micro Edition, advertising business model vs licensing model, the inherent creativity of designing an API, Apple and Microsoft’s competing products, etc.Reply
For better or worse, the same arguments ( "API is copyrightable" ) is what was used in the past to prevent 98's Microsoft from doing embrace-extend-extinguish to Java with their "JavaVM with P/Invoke'd Win32 API".
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...Reply
So does this mean one can already interface with a GPL program/library and ignore it's license? Is this the end of the GPL dual-license business model?Reply
I am very glad to see this. Having a “you can abuse copyright to have proprietary control over an API” precedent on the books had a chilling effect for programmers.
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.Reply
Every time I see a big thread I smile knowing dang is going to have to write some comment about how they're working on thingsReply
Thomas and Alito dissented - these two are always on the wrong side of history.Reply
Judge William Alsup learned to code for this case, and was therefore able to avoid a lot of the BS being peddled around the significance of some of the code:
> 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.”Reply
This is not a Constitutional issue. This is a purely legal decision based on a federal statute passed by Congress.
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.Reply
Oh my God. What a relief.Reply
A summary for those who don't want to read the entire thing:
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.Reply
Google's an LLC?Reply
It's interesting to me that they ruled that APIs are copyrightable, but that copying them is a fair use.
In what circumstances would non-fair-use copyright then apply?Reply
"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, OracleReply
While the result is a big relief, I think it's not as decisive as I'm noticing some headlines (and commenters) are claiming.
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.Reply
> Those 11,500 lines, however, are only 0.4 percent of the entire API at issue, which consists of 2.86 million total lines
This marks jurisprudenceReply
I'm so relieved. This could have forced such dramatic changes in how we develop software. And any other decision would have been a crippling blow to FLOS software.
Now if we only could get the SC to invalidate software patents in general.Reply
Threads are paginated for performance reasons (yes we're working on it), so to see the rest of the comments you need to click More at the bottom of the page, or like this:
(If you've already seen a bunch of these, I apologize for the annoying repetition.)Reply
Sanity prevails. This is incredibly important for _literally every programming language_!Reply
Let's assume Google was in the wrong here - for the sake of argument.
How would it been possible for Google to do this without just taking the API definitions.
Could they have just use compiler errors?Reply
I found this section (pp. 33-34) particularly interesting:
...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.)Reply
I found this description of an API surprisingly good compared to earlier courts. It's not quite literally true, but it makes sense.
> 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.Reply
> "Google copied approximately 11,500 lines of declaring code from the API, which amounts to virtually all the declaring code needed to call up hundreds of different tasks. Those 11,500 lines, however, are only 0.4 percent of the entire API at issue, which consists of 2.86 million total lines. In considering “the amount and substantiality of the portion used” in this case, the 11,500 lines of code should be viewed as one small part of the considerably greater whole. As part of an interface, the copied lines of code are inextricably bound to other lines of code that are accessed by programmers. 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."
Sanity prevailed! This judgment could have had devastating consequences and turned software development into a copyright nightmare.Reply
this is a matter of opinions, and the jurors voted based on their own flawed understandingReply
The SCOTUS decision on API Fair Use is the correct one. Students of intellectual property law and computer programs will find the briefing for the Supreme Court fascinating. I find it hard to see how the Circuit Panel that overturned the original pro-Google decision to Oracle's favor in the light of the arguments and evidence provided. The briefing for the Cert, particularly the amici, is worth reading. Oracle tried to move the argument into the public square by encouraging "experts" to write damning op-ed articles for news outlets and for the semi-technical press about the evils that Google did. Often their articles misplayed a shallow understanding of the issues and history of the Oracle/Google dispute.
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.Reply
"The doctrine of “fair use” is flexible and takes account of changes in technology. Computer programs differ to some extent from many other copyrightable works because computer programs always serve a functional purpose. Because of these differences, fair use has an important role to play for computer programs by providing a context-based check that keeps the copyright monopoly afforded to computer programs within its lawful bounds."
This is EXCELLENT news for anyone in software development. Yay for Fair Use.Reply
So Oracle's reason to buy Sun failed? I am happy.Reply
Now can they please use a modern jdk on Android? It's about timeReply
> Google had appealed a 2018 ruling by the U.S. Court of Appeals for the Federal Circuit in Washington reviving the suit
Once again the CAFC was dead wrong in its maximalist IP ruling.Reply
I hate analogies... but will use one here... 'copying' an API, to me is a bit like copying the look&feel of a product. There used to be similar lawsuits alleging 'look and feel' violations awhile back between Microsoft and whomever (I don't recall anymore), most if not all of these bombed. If Google had lost this one, then the next step would be copyrighting a typedef-ed struct with "proprietary" Google data in it...
I am not a huge fan of Google's antics in general, but in this case, I am glad they won.Reply
Oh, I forgot this little apocalypse was hanging over our heads. It's good to see some sanity.Reply
From the dissent:
> 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).Reply
"The fourth statutory factor focuses upon the “effect” of the copying in the “market for or value of the copyrighted work.” §107(4). Here the record showed that Google’s new smartphone platform is not a market substitute for Java SE. The record also showed that Java SE’s copyright holder would benefit from the reimplementation of its interface into a different market. "Reply
I wonder if Google will continue to move away from Java even after winning this ruling.
What will Java look like at Google in 2030?Reply
How who Apple react if some company copied, then implemented their iOS API on their mobile device, so they could run Apples hundreds of thousands apps?Reply
First of all, very good news. Second of all, what does this mean for Fuchsia, Dart, and related projects? I always assumed they were a hedge against Google having to pay exorbitant licensing fees to Oracle. Now that the threat has disappeared, will those projects be sunsetted too?Reply
This is one of the most important legal decisions in the history of software. The US Supreme Court has basically just saved the whole software industry (and FOSS projects) from being wrecked by patent trolls.Reply
This is a pretty unfortunate ruling and I have some questions about the shoddy claims made in this document (the one suggesting Oracle benefitted from its platform being ripped off without license is particularly rich, especially considering it was the death warrant on Java as a mobile platform entirely, right before mobile became huge).
But what can we expect from the fine folks behind Citizens United?Reply
Hopefully this is a crack in the armor of the x86 monopoly - after all what is an instruction set but an "API for processors"? The novelty is in how you implement the instruction set, not the actual API that says "this instruction takes A and adds it to B", that is purely a matter of compatibility.Reply
Does anyone have any insight into how the justices are educated about a case like this? I guess this applies to many cases, involving a variety of industries, but it's especially clear here that making a decision requires a technical understanding of the stakes. How are the justices made to understand what the different concepts meant? from reading the ruling it's clear that they have a very good understanding, and it's impressive for non-programmers, most of whom are older and did not grow up with technology.Reply
All thanks be to GodReply
I 100% agree that this is the right outcome. Any other outcome would be a nightmare for software developers and would inhibit the development of products.
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.Reply
Does that mean that we can use portions of copyright code/text with no repercussions?Reply
This appears to be the "money quote":
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.Reply
> Computer programs differ to some extent from many other copyrightable works because computer programs always serve a functional purpose.
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).Reply
It's interesting reading Thomas' dissent. As per typical Thomas appears to be arguing that it's the letter of the law that matters, whereas it's the majority opinion that the motivations and substance of the law are primary.
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.Reply
After experiencing 'good' and 'bad' API design, I'm really hoping that people who invest in creating great APIs get to benefit from their hard work even after this.
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.Reply
Honestly this stands contrary to almost every principle of fair use (transformative work of different character for the purpose of comment, parody etc.).
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".Reply
"On the other hand, Google’s copying helped Google makea vast amount of money from its Android platform. And enforcement of the Sun Java API copyright might give Oracle a significant share of these funds. It is important, how-ever, 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. See Lotus Development Corp., 49 F. 3d, at 821 "
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?Reply
From a quick scan, the majority opinion here seems reasonable. I suspect it is what almost everyone working in programming would have considered the "right" answer.
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.Reply
Which of Breyer's clerks drafted this? They clearly understand many tech issues and I hope they find their place on some Federal circuit to herald an era of logic in tech law.
"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. "Reply
Thinking out of box.
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.
I feel conflicted about this decision. I've added some analysis here:
focusing on two areas: * Google had the ability to make their own language and APIs for Android * The chilling effect on future language/API innovationReply
For me, the problem here is that there is no logically consistent way to rule in favor of Google without undermining the concept of software copyright itself. APIs are creative expression: at a basic level, it is possible to change the names, the order, and to some extent the type of parameters and achieve the same result. It is also possible to change the structure of the API itself at a large scale in such a way that the programmer still can do what the API purports to provide, in a completely different way. Therefore, if one were to call APIs merely functional "declaring code" that cannot be copyrighted, then that would put all software code at risk of being called such. The idea that, say, a certain algorithm can be expressed in many different ways lies at the heart of how we justify making such expressions copyrightable.
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.Reply