Hacker News Reader

Comment by Scarbutt | Hacker News Reader

Not a Java dev but what are these proprietary Java APIs? doesn't oracle jdk and openjdk share the same APIs?

I think the article is incorrect. I suspect they meant "implementation" rather than "APIs". As I understand it, OpenJDK has the same APIs (otherwise Google wouldn't be able to just switch to OpenJDK).

The article is a trainwreck. There is no difference between the Oracle Java API's and the OpenJDK API's.

There are, actually. The Oracle JDK has some features that the OpenJDK does not. Look at the 'commercial features' to see what: examples include the resource management API, AppCDS, Flight Recorder, a few other things I forgot.

Yes, but the context of the article was in relation to the 37 API SSO's Oracle accused Google of copying.

I think it's like this: Google copies Java's API. Oracle sues Google, claiming "You copied our API! It's copyright! You're infringing!" Google says, "Fine. We'll stop using your copyrighted API. We're going to copy the API of OpenJDK, which is GPLed so we're completely free to do so, and which just happens to have the exact same API. Good luck suing us for that one."

And the actual Android API doesn't change...

They're not "copying the OpenJDK API".

They're changing the Android Java runtime to actually use OpenJDK rather than its own proprietary implementation of the Java APIs.

Which is, perhaps, all that Oracle wanted all along.

Ater all, everybody wins from this.

- Android developers get up-to-date Java APIs that aren't years behind other Java platforms.

- Google gets to spend its engineering resources on things that matter specifically to Android rather than endlessly duplicating, and playing catch-up, to the OpenJDK platform.

- And Oracle gets a major industry player behind Java rather than fragmenting it and creating a slightly-incompatible variant.

Google's implementation isn't proprietary, it is Apache licensed. I think the idea of the parent comments holds. The irony is exquisite. Google is solving their copyright infringement problem by copying & distributing vastly more Oracle code.

It's not necessarily ironic. Oracle (or specifically Sun, which Oracle purchased) chose to create and distribute OpenJDK. They didn't choose to create Google's competing implementation, which perhaps they view as fragmenting the Java ecosystem.

Sun actually released the OpenJDK in response to the implementation that Android uses (Apache Harmony, not "proprietary Google").

https://en.wikipedia.org/wiki/Apache_Harmony

That's true. It seems that alternatively Google could have relicensed their implementation as GPL and not have had to make any technical changes at all. Which shows that the only reason Google was maintaining their own implementation, and why they went through the lawsuit was just to keep GPL license out of their Java code. Seems nonsensical.

Google could not relicense APL code they did not write to GPLv2. The Java implementation is a subset of Apache Harmony, which they did not create from scratch.

Oracle maintains ownership of the OpenJDK project, which is the point here. Google simply relicensing its reimplementation of the Java APIs would not change the fact that the reimplementation is infringing under the law.

> Java APIs would not change the fact that the reimplementation is infringing under the law.

That's not an established fact at all. There is a whole lawsuit going on about it, if you haven't heard. If the final ruling is that APIs can be copyrighted, I'll change careers and never buy/condone the purchade of an Oracle product for as long as I live.

My exact thoughts as well. Perhaps they have to use OpenJDK instead of their own implementation in order to use the protected Java API?

They do but there might be an important point embedded here. The OSS implementation is licensed for free use. That implies the API is authorized for that version. The two issues go hand in hand Im guessing.

from my understanding, openjdk is insulated from the supposed copyrighted api issue, though they still struggle with obtaining a test suite that can certify their implementation as "compatible", to some degree or another.

No, OpenJDK is the actual reference implementation. It's Apache Harmony that couldn't get the TDK.

ah, thanks for the clarification

So why didn't they go this direction at the start?

OpenJDK didn't exist in the early days of Android, so it wasn't an option.

Sun/Oracle created OpenJDK, effectively "open sourcing" Java in response to the popularity of clean-room Java reimplementations like GNU Classpath and Apache Harmony.

Why Android did not choose to adopt OpenJDK until now, however, is a mystery known only to Google. Maybe it was just a lot of work, technically speaking, to do so.

So far APIs cannot be copyrighted. There have been lawsuits over APIs but no decision that protects APIs from being used by other people and companies.

GNU/Linux for example uses Unix APIs and Mac OSX uses Unix APIs, so if APIs are copyrighted then they would be sued for using the Unix APIs without permission. Then they would have to remove Unix APIs and lose Unix compatibility.

Sun went after Microsoft and others over Java IP before Oracle bought them out. Sun used a lot of money on lawsuits and ended up losing money to the point that Oracle bought them out. This is the same as when SCO was suing over GNU/Linux using Unix source code. It usually doesn't work and costs more in court costs than any settlement or rewards.

> So far APIs cannot be copyrighted. There have been lawsuits over APIs but no decision that protects APIs from being used by other people and companies.

So, are you not familiar with the very very pertinent to this _particular_ platform recent case of Oracle v. Google?

Cause, yeah, that did that. It's a disaster.

I was not aware that Oracle won. Can Google appeal it?

Google appealed to the Supreme Court. They declined to hear the case.

> So far APIs cannot be copyrighted. There have been lawsuits over APIs but no decision that protects APIs from being used by other people and companies.

What about the decision of the Court of Appeals for the Federal Circuit in Oracle America, Inc. v. Google, Inc.? [1]

[1] http://www.cafc.uscourts.gov/content/oracle-america-inc-v-go...

The way I read it, it is not just the APIs but Google copied source code from Java for use in Android:

With respect to the 37 packages at issue, “Google believed Java application programmers would want to find the same 37 sets of functionalities in the new Android system callable by the same names as used in Java.” Id. To achieve this result, Google copied the declaring source code from the 37 Java API packages verbatim, inserting ORACLE AMERICA, INC. v. GOOGLE INC. 11 that code into parts of its Android software. In doing so, Google copied the elaborately organized taxonomy of all the names of methods, classes, interfaces, and packages— the “overall system of organized names—covering 37 packages, with over six hundred classes, with over six thousand methods.” Copyrightability Decision, 872 F. Supp. 2d at 999. The parties and district court referred to this taxonomy of expressions as the “structure, sequence, and organization” or “SSO” of the 37 packages. It is undisputed, however, that Google wrote its own implementing code, except with respect to: (1) the rangeCheck function, which consisted of nine lines of code; and (2) eight decompiled security files.

> "Google copied the declaring source code..."

That is, Google copied the API. That's the declarations. That includes the package, class, and method names (and signatures) - that's what an API is in Java.

That's how I read this case as well. I've always been confused by the "API copyright" panic: If Google hadn't copied Oracle's source files (albeit interface-only source files) nearly verbatim, there would have been no liability. You're free to reproduce an API to provide to your clients; you're not free to take the interface files I wrote to provide the API, edit them a bit, and ship them as your product.

If I'm getting this wrong, I'd appreciate an explanation why.

There's no other way to "reproduce an API" in Java than to copy the names of methods, classes, interfaces, and packages verbatim. Otherwise, it would not be a compatible API.

The numbers in the telephone book are not copyright-able. You are perfectly able to produce a book of phone numbers in the same order and distribute it. However, if you were to photocopy an existing telephone book then you would be violating copyright.

Google did not produce their own compatible files containing the list of methods, classes, and interfaces. They copied Oracle's files.

> Google did not produce their own compatible files containing the list of methods, classes, and interfaces

No, that's exactly what Google did.

Google didn't copy any of Oracle's files -- except for 9 lines of code in rangeCheck and a few tests, none of which are central to the case.

IANAL. Was that a decision that APIs were copyrightable, or that the trial judge couldn't definitively rule that they weren't?

[Edit: Ah, I see that this was answered by phonon in a post parallel to the parent. The appeals court ruled that they were. Note, however, that the Supreme Court declined to listen to an appeal by Google at this time. The Supreme Court did not rule that the Appeals Court was correct. Therein lies some hope...]

As I understand it, that's not how it works. When the Federal Circuit issued its decision saying APIs are copyright eligible, Google appealed to the Supreme Court, claiming the decision was incorrect. The Supreme Court, however, declined to hear the case, strongly implying (or maybe directly indicating?) that it thought the decision was correct. As such, there is no hope, at least as far as this case is concerned.

>The Supreme Court, however, declined to hear the case, strongly implying (or maybe directly indicating?) that it thought the decision was correct.

As the court emphasized in Missouri v Jenkins (1995), "[t]he denial of a writ of certiorari imports no expression of opinion upon the merits of the case" (https://www.law.cornell.edu/supct/html/93-1823.ZO.html)

Ummm... "For the foregoing reasons, we conclude that the declaring code and the structure, sequence, and organization of the 37 Java API packages at issue are entitled to copyright protection. We therefore reverse the district court’s copyrightability determination with instructions to reinstate the jury’s infringement verdict. Because the jury hung on fair use, we remand Google’s fair use defense for further proceedings consistent with this decision. "

https://h2o.law.harvard.edu/collages/15772

And just to save others some time, "declaring code" is defined in this footnote:

'Every package consists of two types of source code— what the parties call (1)declaring code; and (2) implementing code. Declaring code is the expression that identifies the prewritten function and is sometimes referred to as the "declaration" or "header." As the district court explained, the "main point is that this header line of code introduces the method body and specifies very precisely the inputs, name and other functionality." Id. at 979-80. The expressions used by the programmer from the declaring code command the computer to execute the associated implementing code, which gives the computer the step-by-step instructions for carrying out the declared function.'

Reply on news.ycombinator.com