Hacker News Reader

Comment by bitwize | Hacker News Reader

All the more reason why the Supreme Court should rule in favor of Oracle.

Wait, why? Won't that outcome turn FOSS into a legal quagmire?

As now everyone will rush to copyright "common" API signatures, and lawsuit troll anyone found in violation of the copyright?

"I see your FOSS uses `parse(string)`. We own the copyright on that API, please buy a license or we'll sue."

So then every API would become i.e. `umvi_parse(string)` to avoid paying. I'm sure all sorts of auto-prefixer tools would pop up to help automate this, but still...

It probably wouldn't be that bad: there's already copyright doctrines for situations where something is so commonly used that it can't be protected, or where there's only one reasonable way to express a particular idea. Plus, copyright protection is usually not extended to extremely short phrases or snippets of text, so even in an "APIs are copyrightable" world, "parse(string)" is probably OK. (Of course, I only said probably, which is part of the problem.)

The Oracle argument (and as things currently stand in their case, the accepted argument) is basically that the API taken as a whole can be protected even if each individual function name can't, so you could protect the "Java API" but not "compare(a, b)". The idea of copyright arising from "structure, sequence and organization" is well established in the computing context as well as others (for example, you can hold copyright in a compilation even if the individual things being compiled aren't themselves copyrightable).

Still, API copyright would lead to all sorts of uncertainty at least at first, and certainly puts compatible implementations or reimplementations in the crosshairs, so I'd really prefer an Oracle loss here.

> The Oracle argument (and as things currently stand in their case, the accepted argument) is basically that the API taken as a whole can be protected even if each individual function name can't

And let's be honest, that does make some sense. We've all designed APIs that were particularly elegant and that we were proud of as something almost artistically beautiful. Surely APIs as a whole can constitute some kind of intellectual property.

I'm not sure if copyright is the right way to protect APIs, mostly because copyright lasts for an absolute eternity in software engineering timeframes. But I do think that there ought to be some protection against others copying an API (unless you license it e.g. as open-source), although interfacing with an API should always be allowed.

Are other types of interfaces copyrightable? I think that should be what sets the precedent.

For example, would I be able to create an airplane with the same cockpit layout (same button/lever positionings, etc) as Boeing so that pilots don't have to learn a completely different layout to fly Umvi brand planes?

And the nightmare of determining who owns the APIs in things like SQL, BSD, POSIX, libc, speadsheet functions, the cairo and HTML canvas path APIs, HTML DOM, and more. Not to mention compatibility projects like wine, DOSBox, and various emulators. If printf is copyrighted, it will affect C, PHP, python, the command line application, and others. Then there are things like where C# is clearly influenced by Java.

The whole programming landscape would need to be audited.

A large majority of those APIs are protected by ISO, ECMA, OpenGroup with their respective copyrights and many of them aren't available for free, specially ISO ones.

You just them as free beer, because a couple of developers have decided to put their money for you, specially the ISO ones.

Such a hot take. This is not reddit. Please expand on your thoughts and articulate it clearly. I've not yet heard of a single convincing argument in favor of Oracle.

The CAFC's rulings spell it out pretty plainly. There is sufficient original creative work in the choices underpinning the design of the Java APIs that they are eligible for copyright. There are no external forces compelling the Java APIs to conform to the exact shape they now hold, and the same systems and processes could be expressed in other ways. Therefore, the "system or method" exemption to copyrightability does not hold for the APIs.

A number of industry professionals have also made this argument. See Eugene Spafford's amicus brief for an example: http://www.supremecourt.gov/DocketPDF/18/18-956/133474/20200...

By copying Java's APIs in a non-interoperable way, Google has diluted the Java ecosystem and sown confusion amongst users of the language, thus diminished the value of the IP held by Oracle, and Oracle is entitled to damages.

The CAFC's ruling was only clear because of the amazing amount of 9th circuit precedent they left out, going off and making their own law for some reason.

Perhaps you could explain how you think that would help? Without an explanation you comment is quite the low effort drive by.

Reply on news.ycombinator.com