1) This isn't binding precedent nationwide, like a patent ruling would be, and most copyright cases aren't going to end up in the Federal Circuit. The other Courts of Appeal will have their say in deciding the issue, and with any luck a circuit split could result in Supreme Court review. In particular, I'm not sure they're going to buy the Federal Circuit's merger doctrine analysis.
2) The court repeatedly mentioned that Google copied 7,000 lines of declarations verbatim. I wonder how many gaps are in the reasoning of this case to stick a knife through in cases where there wasn't such literal copying.
I meant that open source projects that reuse API declarations or parts aren't typing them themselves, they are copying those API declarations verbatim from somewhere.
Ray's point what if they didn't copy, it may not be an issue, but they all do copy.
Here's a related but not exact example of what typically happens that i actually happened to have open in another window:
https://github.com/andreacimino/gql4j/blob/master/src/main/j...
Notice the comments. These are taken, verbatim, directly from the definitions in Google's GQL reference.
Because it's a parser, there are no declarations, only a grammar implementation (which, BTW, would also fall under this precedent).
However, you'll see the same thing in open source projects that do API implementations as well.
Person A reads the declarations and writes down what they do, without mentioning any function names or argument names.
"This function returns the index of a character in a string."
int findIndexOf(String s, char c);
Now, at this point, what you have is something functionally the same as Java's String object. Do this for all classes. Call this bundle something like AlterJava. (Or YerksDiddy if you really worry about the name.)
Then someone writes a tool that translates Java into AlterJava. It's an easy thing to put into the compiler chain.
I'm skeptical of these "just hop through this hoop and you aren't breaking the law" ideas when other people make them, so feel free to tell me I'm missing something.
EDIT minor edits
This was much discussed in the early days of the PC; if memory serves, it's basically the approach that was taken by the first successful cloner of the IBM PC BIOS [1].
[1] http://en.wikipedia.org/wiki/Phoenix_Technologies#Cloning_th.... Also http://www.linuxinsider.com/story/33839.html
Do you have examples of FOSS projects copying code while not abiding by the license?
Again, I really think you're taking this out of proportion. This decision does not affect you if your implementing an API in accordance with the license.
Some people keep saying that this decision is bad for FOSS, but they can't come up with examples of FOSS that will be affected (there are probably a few projects, but nothing that will shake up the industry).
Citation needed?
"AFAICT, GQL is Apache licensed"
This page (https://developers.google.com/appengine/docs/python/datastor...) is not Apache Licensed.
It's "Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 3.0 License,"
Given they haven't complied with the license (no citation, no attribution), calling this a "licensed use" is quite a stretch. It's actually pretty clearly not a licensed use.
"This decision does not affect you if your implementing an API in accordance with the license."
Which open source projects rarely do ...
Really, do you think the TOS of most of these websites or software allow you to make your own implementations? Are most of them who do get "licenses" being careful about actually following license requirements?
As to copyrighting a language:
The appeals court makes a clear distinction between the Java programming language (i.e., the commands/keywords that are free for everyone to use) and the APIs, and finds that only three of the Java APIs in question are basically part of the Java language, but "Google could have written its own API packages using the Java languages", which, as the opinion notes, "Google chose not to do".
http://www.fosspatents.com/2014/05/oracle-wins-android-java-...
Do you think this is a licensed API? Your "nobody will sue tiny projects" thought is contravened by history.
Here's one: http://en.wikipedia.org/wiki/Jacobsen_v._Katzer
We'll strongly disagree as to where this decision will lead. Thankfully, I know i'm not the only one worried.
Also, fosspatents is not a legal decision, nor did you actually cite anything that backs up your claim: Your claim was the decision says the language was not copyrightable. It says no such thing. What it says is "It is undisputed that the Java programming language is open and free for anyone to use."
This is because it was licensed, not because it is uncopyrightable.
I didn't know about the Katzer case, but I still see no danger to the FOSS community and ecosystem by the new ruling. All it would do is require developers to clearly specify the license for their APIs. Cloning of proprietary APIs is most certainly not a cornerstone of FOSS today (unless, that is, Linux is in actual danger, in which case I'll change my position).
"Cloning of proprietary APIs is most certainly not a cornerstone of FOSS today (unless, that is, Linux is in actual danger, in which case I'll change my position)."
I would disagree, but I can't say more, sadly.
He is loyal to his employer but his analysis and projections are often contradicted by facts.
Perhaps Google didn't comply with OpenJDK license because it didn't exist when Google used Java Apache Harmony implementation.
And even if they were, if the originals were copyrightable, there's no copyright-relevant difference between "typing them themselves" and "copy and pasting", both are verbatim copying (and, even not doing a verbatim copy and merely doing a "derivative work" based on the existing API would be -- barring fair use or other explicit exception -- a violation of copyright if the API, as such, was copyrightable.)
So I'm imagining a bunch of Java classes loaded into memory. They're objects, and they have methods, and those methods refer to methods in other objects. Creating this state of memory is functional, and definitely not protect-able. Now, the interface declarations, then, are just a description of this state of memory. A method has a particular name or a particular set of parameters but those are just a description of the functionality, and there is no other way to precisely describe that state of affairs. The closest analogue I can think of to an API is a phone book, and the names and addresses in a phone book are not copyrightable, although higher-level structure might be.
I think the court got stuck on the verbatim copying and that prevented them from seeing things this way.
Though both making verbatim copies and making derived works are exclusive rights of copyright owners so that doesn't really reduce the impact of API copyrightability on API reimplementations,
And what is copied verbatim are just the headers
If you are using different languages that compile to a compatible target, or if you are using the same language that admits different literal declarations expressions that produce the same interface, it is possible to have an API reimplementation -- for the same target platform even -- that does not involve verbatim copying of even the headers/declarations.
For example, in C, this would involve function name aliasing which is usually a compiler specific extension. This might give you name compatibility, but to get struct-level compatibility, you'd have to copy the exact layouts due to padding issues.
In C++ it's even harder, due to when vtables are emitted, etc.
My java knowledge is old (java 5), so i don't know if they made it possible.
Objective-C, I believe it would only be possible if you used the runtime reflection methods directly. I don't think you can easily do it with just headers (corrections welcome!) etc
And that's the crux of this case... is an API copyrightable?
Apple's decision to stick with (objective) C is turning out to be a really smart move. That it runs 2x faster than java is another bonus.
Bottom line: you can use java but don't get stuck so bad you can't refactor out of it. And don't trust Oracle. Regardless.
Also, what's being litigated here is not Java-the-language but Java-the-core-API-interfaces.
You could refactor your way out of those, just provide alternate versions of java.io, java.lang, etc, new redesigned core APIs.
It would break core Java compatibility, but Android is so big, most people would port their Java libraries, and in the end, Oracle would be hurt more, since they rely far more on server-side Java, but most of the world's Java programmers would be migrating to writing mobile apps, probably with non-Java backends, or Java + new Core APIs.
http://en.wikipedia.org/wiki/Unix
is owned by "The Open Group"
http://en.wikipedia.org/wiki/The_Open_Group
One of its purposes is to provide Single Unix Specification (SUS) certification.
http://en.wikipedia.org/wiki/Single_UNIX_Specification
Mac OS X is SUS v3 certified (I don't think iOS is) and can call itself UNIX, and there is 0 danger of anyone suing you for implementing POSIX API or SUS. You just can not claim you are providing a UNIX without getting certified. This is why Linux is UNIX-like OS and not a UNIX.
This has never been litigated before. Past UNIX copyright wars were fought over copying actual code between Unix and clones. No one has ever tested whether API reimplementation of Unix is copyrighted. Implementing as public spec won't save you. Java has a public, open, specification and was clean-room reimplemented in much the same way that Linux is not Unix, Android Java is not Java.
Claiming there is 0 danger in being sued sounds like naively wishful thinking, especially with Apple's deep pockets, there are plenty of lawyers out there looking for ways to crack that nut.
Oracle's claims here are rather ridiculous, and even Oracle doesn't believe Swing or J2ME apps are appropriate for today's smartphones. It's a red herring of compatibility that no one cares about or wants to be compatible with.
What makes Java valuable to most developers is byte-code portability, the widespread use of the language, the core APIs (not the GUI), and the developer tool chain.
The Sun licenses for Java go back to a time when they had a dream to displace Windows on the Desktop with all native desktop apps written in Java. That reality was delusional, but Java succeeded brilliantly on the server.
My personal opinion is not about what is legal, but what I think is ethical and justified. The current system is broken and needs to be reformed.
You seem to want to defend the status quo. That's your prerogative, I think you're advocating for a world that makes everyone worse off, but we can agree to disagree.
Google's use of the Java APIs is different; Google intentionally makes it so that Java applications do not run on Android and Android applications do not run on Sun's JVM. Google is not trying to implement those APIs for the purpose of interoperability. A finding that Google's appropriation of those APIs for their own runtime environment is not fair use is not a finding that WINE's use of Windows APIs in order to enable interoperability is not fair use. What's at stake here is more narrow than what several posters have surmised. You can argue that what's at stake here is still important, which is a discussion worth having, but posts in this thread about (for instance) how the PC compatible market wouldn't be allowed to exist under this ruling are mistaken.
And why would it not be copyright infringement to implement a full API, but is copyright infringement to implement a subset of one?
When Phoenix cloned the PC bios, they did it on the assumption that if they reverse engineered the complete API specification, and then had a separate group of engineers perform the implementation, there would be no infringement, because no one in the history of computer science thought API interfaces could be copyrightable.
IBM was powerless to stop them, and clones flourished. With this precedent, would Phoenix have attempted the clone? Would IBM have not sued over copyright infringement of their interface?
Pretty much all clean room implementations since then have proceeded on the basis that implementing someone else's API, even against their wishes, is not an infringement. It's been the default assumption for decades.
To act like this Court decision has not flipped over decades of practice is putting way too much trust in the companies out there to show restraint and not unleash a tidal wave of copyright suits.
Not quite. The freedom to re-implement Unix APIs was litigated. If I recall correctly, it was settled rather than won (that is, there was not a court decision but rather a settlement agreement).
Blanket statements like "ObjC is 2x faster than Java" is... well, a blanket statement, and in general, wrong. It depends so much on what, precisely, you're doing, how you're doing it, the compiler and JIT implementation, etc.
Go, Erlang, Haskell, C++, Rust
The reason for using Java is the corporate penetration and being the de-facto language for thousands of developers. I seriously think that Java as a language is old and hard to use (hello Clojure & Scala) and on the top of that owned Oracle is the biggest patent troll in the history of humanity, so even implementing the APIs can lead to lawsuits just like the example above.
Now the only question is, why the hell do we still implement new things in Java in 2014? Time to wake up, get a language that is free by every meaning free has and bury Java for good. Is this hard? Definitely is, but if we don't start it today when can we stop Oracle from suing your startups because you implemented an API. Changing US law seems harder. :)
Go has about 0.0001% of the third party library base that Java does. Many of which are essential for large scale enterprise development. It's why languages like Clojure and Scala have become a lot more popular because they leverage the ecosystem.
No one will move just because of some insignificant lawsuit.
Virtually none of the 'go' job ads have anything to do with programming.
This is a "let's send the US back into stone age!" kind of decision.
You mean like how Dalvik is Google's BSD (Well, Apache 2.0) licensed clone of Oracle's GPL licensed Java? (http://www.fsf.org/news/fsf-welcomes-gpl-java.html) :)
The issue at hand was that Oracle specified that any implementation using their Specifications license be compatible, and the Dalvik implementation is not compatible.
So it isn't that Oracle is going back on their word, it is that Google did not follow the rules of the license.
It's more proper to view it as a right.
See:
Dr. Seuss Enters., L.P. v. Penguin Books USA, Inc., 109 F.3d 1394, 1403 (9th Cir.1997);
Supermarket of Homes v. San Fernando Valley Bd. of Realtors, 786 F.2d 1400, 1408–09 (9th Cir.1986)
In this case however the biggest damage is that they reversed the ruling that APIs aren't copyrightable. Is there any way that Google can reappeal it in a higher court, or it's a final decision? In Europe APIs were ruled uncopyrightable some time ago, but somehow this didn't help in this case.
Whether that happens or not, they can also appeal it to the supreme court.
Suffice to say, my completely personal view is that it was appealed to this very court for a reason. Normally, this is the court that hears all patent appeals. Because the original lawsuit involved patent claims, they have jurisdiction, even though there are no patent claims being appealed.
Otherwise, it would have gone to the 9th circuit, who, i suspect, would have been more favorable.
A fair use defense means that something happened that would otherwise create liability, but doesn't because of some (often policy) reason. Making something an affirmative defense has procedural implications. But "rights" can be implemented as affirmative defenses. For example, truth is an affirmative defense to defamation in the U.S., even though it's closely connected with free speech rights.
EDIT: But see dragonwriter's very pertinent comment about defamation cases involving matters of public concern, where falsity is an element of the claim rather than an affirmative defense.
The practical distinction is that it's easier to dispose of cases on a motion to dismiss when something is a required element of the claim versus when it is an affirmative defense.
This is wrong, at least on matters of public concern, specifically because it is connected to free speech rights, both for public figures and private figures as plaintiffs, who bear the burden of showing falsity rather than the defendant having the burden of showing truth.
See Philadelphia Newspapers v. Hepps, 475 U.S. 767 (1986); New York Times v. Sullivan, 376 U. S. 254 (1964).
Second, not too many open source projects implement proprietary APIs. FOSS today does not get its value from producing fully compatible clones of proprietary software.
Third, proprietary software vendors will face the choice of limiting the use of their APIs (i.e. copying) by OSS and risk reduced adoption, or allow it to get wide adoption and offer a superior implementation. I'm not sure most would choose the former.
So with the state of FOSS today, I don't see how such a decision changes much. I would very much like to hear if people have counterexamples (other than WINE).
The jury ruled infringement in the Oracle - Google trial
Jury was deadlocked with 9 juries supporting fair use and 3 saying that there was not fair use
The gpl exists to promote the creation of open source software, not to keep people from using open source. Just because this makes it more enforceable in no way makes this good for open source.
IE Say FredCo has C++ and Java clients for their API. You decide to make and publish a Ruby client. If you use the same Structure, Sequence, and Organization of the API (IE you use the same API), congrats, the court thinks you are infringing copyright.
This is the simple version. Think about compilers and ABI's and SQL extensions and all sorts of things, and you can see this decision is truly terrible for open source.