
EU Court Of Justice: No Copyright On Computer Functionality Or Languages - grellas
http://www.groklaw.net/article.php?story=20120502083035371
======
grellas
In my view, the Oracle v. Google case may be headed in the same direction.

Judge Alsup has let the case go to the jury to determine whether the
"structure, sequence and organization" (SSO) of the Android platform infringes
either the compilable code or the documentation of 37 of the 166 total API
packages constituting a part of the Java platform. But the judge has reserved
for his exclusive determination, after a verdict is entered, whether such SSO
is even protectible under U.S. copyright law. In instructing the jury, the
judge merely told the jurors to _assume_ for purposes of their deliberations
that the SSO was protectible under copyright and to decide the case based on
that assumption. This means that, if Oracle loses on the verdict, its
copyright case is dead. If it wins, then and only then will the judge need to
address the ultimate legal question of whether the SSO can be protected by
copyright at all. If the case does reach that point, he will be able to decide
the question based on a full presentation of evidence by both parties and that
in turn will make any decision he renders far less vulnerable to being
overturned on appeal.

I am not saying that the judge will necessarily support Google in its claim
that APIs should not be covered by copyright. I do say that Judge Alsup is
nobody’s fool and is playing this smart, letting Oracle play out its case in
full and only then stepping in to say whether its case is even legally
supportable.

Of course, the judge could also have rendered a definitive ruling one way or
the other in the pretrial phase. But there are some areas of law where the
principles are pretty clearly articulated but get knotty in their application
and this is one of them. Yes, U.S. copyright law, like EU law, specifies that
something that is functional or a system or a method of operation, etc. cannot
be protected by copyright. But what exactly does that mean in the factual
context of APIs and programming languages? Maybe those extremely well-versed
in what APIs are and what they do can answer that clearly for others who are
also well-versed. But in a court of law, a lot can get lost in translation
and, in the absence of a clear factual record, skilled lawyers have all sorts
of room to confuse and confound the issues as they apply abstract legal rules
to a murky factual record. Because of this, the judge is letting it play out
through a full jury verdict while reserving the right to rule definitively on
the issue until after the verdict.

In this context, Oracle has plenty of reason to be nervous. If it loses before
the jury, it loses; if it wins, it still may lose. And, as for the case being
a bad precedent, that remains to be seen depending on how the judge and any
appeals court may ultimately rule on this issue. For the moment, U.S. law
remains sane on this point and nothing bad has happened as yet apart from an
overbearing company _attempting_ to pour vast resources in hopes of gaining
short-term advantage to the long-term detriment of the developer community.

~~~
azakai
> This means that, if Oracle loses on the verdict, its copcyright case is
> dead. If it wins, then and only then will the judge need to address the
> ultimate legal question of whether the SSO can be protected by copyright at
> all.

Isn't this bizarre though? I'm not a lawyer so I guess I am ignorant of how US
courts work, but shouldn't it be clear whether there is even a relevant law
for something before a jury is asked to make the effort of figuring out if a
law applies in a particular case? It won't be just a matter of SSO is
copyrightable yes/no, it will be more complicated. But the jury won't hear any
of that before saying yes or no.

Shouldn't what the law is be first determined, and only then whether it
applies to a particular case?

~~~
Natsu
In the case where APIs are not protected, it doesn't matter what the jury
thinks, there was nothing for Google to infringe. So there's no need to ask
the jury about that and you can have them just assume that APIs are protected,
because that's the only time when their verdict will matter.

------
hxa7241
This is ultimately more by luck than judgement. Because the main legal
perspective is utterly, fundamentally flawed. The notion that there is a
principled difference between idea and expression simply does not work with
software. In software _everything_ is an abstraction, which means _everything_
has some generality. There is no dividing line anymore.

The idea/expression rule of thumb only made sense because it was a simple
proxy for actual market effect. And there is the nub of the matter: no-one
really wants to measure what the real market effects are for any of these
rules. The law is unhinged from reality. It is just stupid.

For copyright to make sense, we should get rid of all the lawyers and remove
it from the legal domain. Copyright is really a matter of data measurement and
analysis. If the negative effects of restricting and paying for movement of
information are outweighed by the positive effects of creating information,
let us measure that . . .

We built the internet, but then we want to rule it as if it were a small stack
of manuscripts. It is ridiculous.

~~~
rprasad
The difference between idea and expression of software: Idea=the abstraction
Expression=the code, UML diagram, compiled binary, etc.

It's really not that complicated.

~~~
harshreality
When two people independently construct the same code with only trivial naming
differences, what then? Is that a copyrightable expression or is it an
uncopyrightable idea?

The problem I think GP is citing is that it's unreasonable when one piece of
code violates copyright for carrying out some function, and another piece of
code does not violate copyright for carrying out that function, even though
after being run through some automated transformations (for example, an
optimizing compiler), the machine code for the two pieces of code is near
identical.

One person uses a for loop, another uses do while, another uses recursion.
Copyright law doesn't care that they all do the same thing; one could be a
copyright violation while the others are not.

If you abstract copyright to apply to the functionality of the code, you turn
copyrights into patents. If you don't, anyone can tweak code to be literally
different while having the same function.

~~~
rprasad
The _code_ is expression. Neither can enforce the code against the other; both
can enforce against third parties (with registration).

Machine code cannot be copyrighted under U.S. law. It is not an issue in the
Oracle/Google case.

You cannot abstract copyright. It is a codified legal doctrine (i.e., an
expression), not an abstract set of ideas. On that note, however, the abstract
idea behind copyright law (protection of intellectual property) is the
justification for patent and trademark laws.

------
pella
<http://news.ycombinator.com/item?id=3918443>

------
petitesecs
This is great news

~~~
excuse-me
It's irrelevant- the non-copyright status of an API/language specification is
already well established in europe.

The war is over whether you can subsequently block these with patents on the
concepts underlying the API

~~~
bad_user
Copyright and patents are entirely 2 different issues.

This trial is very important because Oracle is suing for both and because
copyright protection is much, much stronger than patents.

The differences: patents expire in 20 years, copyright is basically unlimited;
patent infringement is hard to prove, copyright infringement is easy; patents
are easily invalidated, while copyright is pretty clear (except in this case);
getting a patent is expensive, while copyrighting something is essentially
free, etc...

~~~
excuse-me
And copyright protection of interfaces to block interoperability has been
struck down so many times it's explicitly written into the EU convention
(article 4 IIRC)

Oracle could conceivably get a ruling on the 'Java' name but using copyright
to block somebody else doing an interoperable implementation has been defeated
before

I'm sure Oracle knows this and is simply going to trial in the hope of a
random verdict (it happens) or to get Google to reveal lots of documents that
can be used in a future patent / monopoly / trade case

~~~
taligent
Except that Google isn't trying to interoperate with anyone.

So not sure if your points apply.

