Second Oracle v. Google trial could lead to headaches for developers
arstechnica.com
arstechnica.com
WHY?? And here I thought Microsoft was coming around. Fuck these assholes (and EMC and NetApp too). What do these people have to gain by letting the ruling stand? It just makes interop harder. And here they are tapping into the Linux API shamelessly[1]. Shame on you fuckers.
[1] http://arstechnica.com/information-technology/2016/04/why-mi...
- Microsoft benefits when Google's mobile platform is hurt.
- Microsoft has many APIs so why the heck would they want to overturn a decision that puts them in a position of power?
If those weren't enough, Google has poached Microsoft talent for years. Maybe there are people at Microsoft who just don't like Google and will work to screw them over. Most likely though it's more to do with the two reasons I listed above.
Plus, a little too much emotion in your post. Hard to believe you can feel any emotion about this whatsoever let along being basically pissed off. This is super boring tech news.
Briefly, they believe that the district court went too far in declaring that APIs are not subject to copyright in general. Instead, they believe that APIs are subject to copyright under existing statutes and precedent, but that there are various doctrines (fair use, merger, and others) that can allow copying for interoperability.
[1] http://cdn.arstechnica.net/wp-content/uploads/2013/02/MSFT-O...
If Oracle wins then in a way this might actually be good for open source; software developers would seek out the path of least resistance: APIs that could be licensed freely. This could simply extend the push of open source code further to APIs.
Oracle developed Oracle database before IBM offered standardized free royalty-free licensing, so Oracle's core product, according to Oracle's legal theory, belongs to IBM.
Google is in difficulty here because they didn't use Java for purposes of interoperability; their version isn't even compatible. If they had, Oracle would have no case.
The appeals court left open the question of whether Java being easier for developers because they already know Java counts as a fair use defense.
It might count, and then Google is free.
If Oracle wins then in a way this might actually be good for open source; software developers would seek out the path of least resistance: APIs that could be licensed freely.
That is why the FSF supported Oracle before the supreme court.
Were it grounded in reality, Oracle's claim that copyright law gives them proprietary control over any software that uses a particular functional API would be terrible for free software and programmers everywhere. It is an unethical and greedy interpretation created with the express purpose of subjugating as many computer users as possible, and is particularly bad in this context because it comes at a time when the sun has barely set on the free software community's celebration of Java as a language newly suitable for use in the free world. Fortunately, the claim is not yet reality, and we hope Judge Alsup will keep it that way.
As for their brief against Google's petition to the Supreme Court[2]:
SFLC and FSF take the position that the decision below is wrong, but that certiorari should not be granted for three reasons: (1) the decision of the Federal Circuit merely mispredicts what the Ninth Circuit would do if it had been the Court resolving Oracle's appeal from the District Court's finding that the application program interface declarations at issue are non-copyrightable; (2) the decision rests on narrow factual grounds; and (3) there is no public interest in continuing to adjudicate this dispute because Google can now and could have used all material at issue under the terms of the GNU GPL v2.
What to make of this? It's a bit convoluted. On the general issue of proprietary APIs, the FSF supports Google's position. But they think the judgement against Google from the Federal Circuit court carries virtually no value as precedent, as they say in their brief[3]:
Despite the manifestly erroneous character of the decision below, the petition for writ of certiorari should not be granted. The precedential weight of a decision so evidently mispredicting the law of another Circuit is essentially nil.
Now independently of the Oracle v. Google dispute, they would prefer if Google were using the GPL license for Android. Wouldn't it be nice if the bad Federal Circuit judgment could incentivize Google to use the GPL, without affecting other cases? I think that is the tactical advantage the FSF saw in opposing Google's petition to the Supreme Court. And it might have been a good call, as Google is indeed switching to the GPL Java implementation[4].
[1] https://www.fsf.org/news/fsf-statement-on-jurys-partial-verd...
[2] https://www.softwarefreedom.org/news/2014/dec/08/sflc-files-...
[3] https://www.softwarefreedom.org/resources/2014/google_v_orac...
[4] http://arstechnica.com/tech-policy/2016/01/android-n-switche...
They could have still done a "Motorola" with Sun, but that's hindsight speaking.
Oracle has much less direct investment in datacenter operation that could suffer from unwanted influence of in-house hardware than Google.
1) they will win a lot of money in the near term but it will greatly diminish the popularity of Java/JVM in the long run because most tech companies shudder at the thought of having Oracle be the slumlord of their core program language.
2) there will be a painful transition of FUD and lawsuits but open source languages/libraries will be ultimately become stronger in industry b/c the licenses can easily be extended to API rights. Restrictively or vaguely licensed code will be looked up on with greater suspicion.
The only code that was alleged to be copied were a few test files (which weren't even distributed) and a 9-line function called "rangeCheck".
There was a second copyright claim on the APIs, but Oracle didn't claim the code was copied, just that the reimplementation had the same "structure, sequence and organization" (that is, same names and arguments).
In both those cases, it allows code to be written that targets both, so I would think interoperability would be a strong argument. But is that not the case for Android as well?
In this case the reimplementation is in Scala, but it could be argued that the "structure, sequence and organisation" definition of copying could apply.
If there is any chance this could be ruled as infringing copyright, then Oracle would have a powerful platform lock-in, and every line of code targeting their API's would contribute further to that.
[1] https://github.com/scala-js/scala-js/blob/master/DEVELOPING....
Once AWS becomes a monopoly (which should happen anytime in the 5 to 6 yrs), the only way to challenge the gorilla would be to build an API compatible competitor.
This ruling would make it illegal.
Google's primary difficulty in this case is convincing the jury that they have a fair use defense, when their version of Java is technically incompatible.
Becaiy Google can pull the same defense - interoperability on Android. If Google loses, then it's going to be hard to get something like this off the ground again. In fact, every "porting" project is in danger.
One approach is for Google to say, "Developers expect a reasonable platform that they are familiar with. To give them that, we had to use Java (or C# or similar)."
In other words, it is an interoperability defense, but for compatibility with developers, not devices or software.
The only reason Google went with creating its own implementation was that ARM, Samsung, etc would not have worked with the licensing of Sun Java. This is fairly well documented and actually came out during document discovery. Today Android has so much market dominance that it can basically whip everyone into submission.
What I'm essentially saying is that at this point, it has already become much harder for something like a Wine for OSX to be created. Because developers will have to prove "fair use" in court... which is a huge huge intimidation stick. If Google and Android are finding it hard to prove fair-use defense - how easy it going to be for the rest of us.
Thought experiment - what would be Wine's fair-use defense ?
You're wrong, that hasn't change at all as a result of Google vs Oracle.
Thought experiment - what would be Wine's fair-use defense ?
Interoperability, see for example Sony v. Connectix
There is absolutely no difference between what Google is doing and what happens in the software industry every other day of the week. Using an API for interoperability and to reuse code developers have written backed by their own implementation. The thing is so laughable because the only reason you use an API...is to interoperate.
Oracle knew fine well what can of worms it was opening here when it came up with the notion that everything else would be fine with 'fair use', but the definition of 'fair use' has to be defined - and thus far it hasn't. It exists only in the minds of Oracle's lawyers who know zip about software. Every legal troll in existence will crawl out of the woodwork on this one. No, Sony vs Connectix tells us nothing here, which shows just how clueless you are.
This was all done and dusted in the 90s with DR DOS amongst other things.
Huh? Wine exists solely for interoperability, the defense is "I have this lawfully obtained program and I want to run it on my OS". Which doesn't and can't apply to Android, because Android won't even run standard Java programs.
My point is that the defense is very nuanced ....
There is a specific defense for interoperability. So yes, you might be able to use someone else's design for something like a hose connector or an electrical plug but not improve on it - if you're using their design to interoperate with their stuff. IANAL.
Which means absolutely nothing.
So yes, you might be able to use someone else's design for something like a hose connector or an electrical plug but not improve on it - if you're using their design to interoperate with their stuff.
Again, total nonsense. There are countless implementations of various development software out in the world right now that renders that load of extremely wishful thinking null and void.
Like I've said elsewhere, lawyers might think they can package these cases up into nice, neat boxes but they can't.
There is a reason why countless attempts to make APIs copyrightable have been overturned in the 80s and 90s.
I keep seeing this as Oracle's defence, but it is neither here nor there. There are countless APIs in the world used where the result is not compatible with anything else that uses that API, or a subset of it, or whatever. The C world is full of incompatible compilers and those that use various subsets.
Oracle desperately wants to try and box this up into nice, neat exceptions and use cases and anyone with a single ounce of technical knowledge knows this is pure nonsense.
It doesn't make sense to you because you misunderstood the case, and the legal argument. Oracle doesn't need to make a defense, it's already been ruled that Google is infringing.
Now Google has a chance to offer a fair-use defense, and a reasonable fair-use defense is to say, "Google infringed for purposes of interoperability." If they could demonstrate that, then they would win the case.
So when people say Android won't even run standard Java programs, they are giving evidence that Google's interoperability defense will not work in court.
Nope, it's Oracle's lawyers making technology judgements they are out of their depth to make.
Oracle doesn't need to make a defense, it's already been ruled that Google is infringing.
....and it will be shown to be nonsense and overturned, as it has been decades ago. You can't copyright or be defensive with APIs. If this is true there is no software industry, despite your desperate protestations that this is all about Google and Oracle and everyone else is fine.
"Google infringed for purposes of interoperability."
Ha, ha, ha. The problem is if this is true then the 'infringement' doesn't actually mean anything. It is up to Oracle to define why this infringes fair use, not the other way on I'm afraid. Why you use an API is very, very clear.
So when people say Android won't even run standard Java programs, they are giving evidence that Google's interoperability defense will not work in court.
Again, you keep repeating this crap. There are countless developer tools and compilers out there that implement subsets of APIs and build on them for code reuse and interoperability. What you compile won't necessarily be transferable between implementations. Your desperate wish for this not to be so will not make it so I'm afraid.
The fact that what Google has is not strictly compatible with Java is neither here nor there....because it isn't Java.
Let's hope that if this goes badly, the rest of the world retains some sense of sanity and doesn't allow intellectual property laws to be used to restrict essential principles like interoperability.
So, what terrible things would happen? Most programmers agree it'd be terrible. I trust the masses. But for discussion's sake could someone provide a concrete example or two?
Somewhat related, I believe ARM's instruction set is protected. Probably by patents? I've always felt that source code should NOT be patentable but SHOULD (and is) be copyrighted. Where an API falls and how to draw that line I'm not sure.
In the case of a website, let's assume that you created ws.com, and that you developed an API that answered 'A' when you call ws.com/A, and 'B' when you call ws.com/B. Then you could sue anyone who'd develop a different website that behaves the same way even though the implementation itself may be completely different.
If someone wants to clone wordpress then maybe they should just design their own API. If the Wordpress API is that good then maybe it's worth licensing.
I don't even know where Cloning WordPress came into your thought process. WordPress runs on top of Apache/nginx. That is what responds to ws.com/a. Interoperability is incredibly important, unless you want to go back to having to run a specific Web browser for every other website that isn't using Web standards / rfcs.
If the current craze of IP-as-offensive-weapon were the trend back in the days where basic vehicular controls were being defined, I think we would have seen some similar behavior from car companies - (and in my opinion, their case would be more defensible than Oracle's software API copyright protection).
[1] http://www.freshpatents.com/-dt20140403ptan20140095029.php
[2] http://www.freshpatents.com/-dt20140403ptan20140096003.php
Edit: typo
The braking API isn't "bool braking;". And acceleration isn't "float accel; // [0,1]". Those systems are wildly complex. Ford's copyrighting of their API does nothing to prevent another manufacturing from making their own.
And there's absolutely nothing wrong with that, which is part of what makes the Oracle assault so disgusting.
Thing is Oracle got screwed in the first place, they shouldn't have thought they could "buy" the language.
Personally, as a Java developer from 2005-2012, I never associated Java with Oracle. I can't imagine that I'm the only one. Even now, when I need a JRE or JVM, I navigate to http://java.sun.com/ instead of wherever it is I'm supposed to go.
Imagine a spectrum - on one side, there are no protections, and people can copy ideas, implementations, etc. For some industries this is no big deal, but for others it would seriously harm the production of new ideas/products, because it remove any financial incentive. Take writers for example: While I think the US copyright terms are stupidly long, I wouldn't want to live in a world where the only books written and published were done so as labors of love.
On the other end of the spectrum is a collection of hard, strong rules governing the use of any other ideas. On this end too few new ideas/products are made, because it is in the short-term financial interests of those that have the lock on any market to prevent competition or disruption. We have several industries quite close to this end of the spectrum.
The happy place for society is in-between these areas. Lower barriers of entry for potential competitors, so that they can compete. Does this mean that some of these competitors would benefit from the hard work of those that came before? Absolutely! But the alternative is making the barriers to entry too high, so that no competitor can gain traction because they can't be better in all ways and produce an industry interested in compatibility overnight. (Witness Linux and device drivers for a good example)
The reason govt offer protections for various areas is NOT to benefit a small number of companies or individuals (in theory) - it's to benefit the whole of society, in the long-term (which should include those companies and individuals, along with future companies and individuals).
It's not about protecting that which is _that good_, but about pushing us towards _even better_.
So despite all the hype, this case is unlikely to have a huge effect on the software industry.
Which hasn't been defined in this case.
So despite all the hype, this case is unlikely to have a huge effect on the software industry.
Oracle might try and paint that picture, but I'm afraid it will. There can be no software industry if APIs are subject to copy-write, and if they are, simply using them always comes under fair use. That's why....you use them.
If there are any difficult terms you don't understand, look them up in Google. Build yourself some understanding and you'll say less stupid stuff.
Your understanding of how software works is non-existent, and knee-jerks legal rulings will not change that I'm afraid sweetheart.
In the case of UI, there's a good chance that, to the extent that the piece that is copied constitutes a method of operation, that piece is not copyrightable. For example, in Lotus v. Borland [1], the court ruled that the organization of menus and keyboard macro commands for the sake of compatibility was not copyrightable. However, certain more "artistic" things like icons and such are copyrightable.
[1]: https://en.wikipedia.org/wiki/Lotus_Development_Corp._v._Bor....
If that's a poor example then ok. My question asking for _good_ examples stands firm. As obviously don't have one to say!
I've found many programmers think of APIs as ways of interacting with remote systems, usually via http/json/REST. Personally, I think of an API as things like an argument signature in a library, or even hooks in an OS.
To me, API literally means a programmatic interface to some code. How you write code to interact with other code.
[Not that you said anything differently, I was just trying to expand a little on the different perspectives of 'API' I have encountered.]
Personally, I go with the most general usage of API: an interface to interact with programmatically.
Because its possible that that was the reason the Supreme Court declined to hear the appeal, its certain that should Google lose at trial on the fair use issue, they'll be back up the appeal chain not only on that issue, but also attempting to raise the copyrightability issue with the Supreme Court again. Which may be more inclined to take and decide the issue on a final decision (and, depending how long things take to get through the courts, and what happens in the political sphere, may be a substantially different court than the one that refused the case previously, anyway.)
Also, since the patent claims are now gone from the case, I think the inevitable (whoever wins) first appeal from the trial court will now go to the Ninth Circuit and not the Federal Circuit, and its quite possible that the Ninth Circuit will rule differently on the issue than the Federal Circuit did.
It's also true that courts are expected to come to the right conclusion for the right reason. If a company spent years telling people they were free to use some particular API, then sued them for doing so, it would be important to distinguish between a case where the API isn't copyrightable and a case where the API is copyrightable but that people had permission to create derivative works based on that API. For some reason, many people are unable to make that distinction when talking about things around the water cooler.
If it is done via a Foundation with an API/ABI that is freely available to use - then use this.
But never adopt a framework created by a corporation if you can avoid it. And that includes .NET. While the current corporation may be benign, some other rapacious and unethical corporation might buy them out - then you are screwed.
I believe that APIs are copyrightable. It should be up to the creator to specify licenses that suits his agenda. I believe, if API users care about it and like to build a business on top, only APIs and standards with Copyleft licenses will thrive.