Googlephobia Paints The World Red

This is an open letter to Chris Fisher from Jupiter Broadcasting (and friends) regarding the recent tirade against Google “winning” the court battle against Oracle for the use of the Java APIs.

A short summary for the uninitiated:

After Oracle bought Sun including their Java implementation, they sued Google who implemented (some of) the Java APIs for use in the Android operating system, for copyright infringement in some source code, copyright infringement on the API definitions themselves and a couple of software patents they held about how to implement some Java behavior. Round one: Some source code was ruled infringing, APIs were found non-copyrightable  and patents were found not-infringing. Round two: A federal court (that normally rules on patent issues) held the ruling of copying (for Oracle) and patents (for Google) but ruled APIs copyrightable and Google infringing on that. Third round: a jury found that Google’s use of the Java APIs was fair-use and no damages should be awarded.

After the last jury decision, there was a lot of back and forth on the internet, notably one Ars Technica article (“op-ed”), by an Oracle lawyer claimed that the result boils down to nullifying any and all open source licenses:

if you offer your software on an open and free basis, any use is fair use.

Then we come to Chris Fisher – as the host of his Linux Action Show podcast, he has spoke out against Google many times in the past, but this tirade in the discussion of the Oracle vs. Google action in the most recent Linux Action Show #419, really demonstrates well the extents of his Googlephobia (LAS #419, 0:46:42):

How many times am I gonna take it up the ass from Google? How many times? Is it when they compromise with the carriers on updates and customizability so that way they can compete with the iPhone? Is it when they stoled [sic] from Sun because they knew Sun was a weak company and that Sun couldn’t defend themselves and they could roll them? Is it how they continued to screw consumers and haven’t gotten Android and the massive fragmentation and the update problem under control? Is it how they steal all of our information when we don’t give it to them voluntarily and when we do give it to them they absorb absolutely everything they can and build profiles around us?

(I can debunk every one of these points, but I don’t think I have to – I believe this message speaks against itself well enough.)

I think that the fact that Chris Fisher, one of the most staunch supporters of free and open source software is buying the stupid Oracle position that copying API definitions is tantamount to copying software source code, especially knowing what he knows about how Oracle conducts itself (having covered many of their stunts on The Linux Action Show and TechSNAP podcasts), is just sad. I kind of stopped listening after that bunch of vitriol, so some of the points I make below may have been covered later in that LAS episode – I’ll have to sit and bear through the rest of it later.

We also got this from Michael Dominick, the co-host of another Jupiter Broadcasting show – Coder Radio (#207 0:40:32):

And they admitted to copying the code, I mean they admit to literally copying and pasting.

Which they did not! Its just the Googlephobia speaking out and makes these people say the most horrible things without any basis1

What bothers me the most is that basically all the commentators buy into the Oracle viewpoint of “copying APIs”==”copying software” which is annoyingly incorrect – copying large creative works such as a software program is one thing, and taking simple lists of function names and argument types and reimplementing them with different software code, for compatibility, is something completely different. And while the former one is obviously bad, the latter is a practice that accepted in the industry for basically as long as there was an industry.

The huge elephant in the room, which for some reason no one (I heard talking about it) sees, is that copying API definitions is exactly what several of the most common software suites we use every day do, for example Wine and Mono. Wine is using a direct copy of all the Microsoft Win32 and Win64 APIs. If you harp on Google for copying the Java APIs, what is stopping Microsoft from suing all the small businesses that work on Wine into oblivion? Worse than that – so many open source software that we take for granted today have started as alternatives for a commercial product – Open/Libre Office (which implement the Microsoft Office document APIs), KDE (implements the look and feel of the MS-Windows UI), PostgreSQL (basically a copy of Ingres, a dual licensed commercial database) and many many others. If you are saying that what Google is doing is wrong, you are basically negating a huge portion of the open source ecosystem.

Lets stick to the facts, for a moment, shall we?

  1. Contrary to Oracle’s claim that Google “copied thousands of lines of Oracle’s computer code”, Google was ruled to only copy 9 lines of source code, and mainly because there was no way to prove that its just a matter of reimplementation of the same trivial functionality (as I discuss below), and being that the damages of conceding that point is are so small, Google have just let it go.
  2. No one argues that Google have copied some API definitions (37 according to Oracle) from the Java language specification, which is an open specification that grants automatic license to be implemented without limitation – as long as the implementation is “complaint” and “complete”.
  3. There were some discussions within Google – as has come out during the trial – that some people have thought that in order to “play nice” with Sun it may be advisable to get a Sun license for Google’s use of the Java language specification, especially given that Google’s implementation is likely not going to be considered “complete” or “complain” by the owner of Java.

Its that last point, I believe, is where most people get stuck about and inflate it into “Google has illegally copied Java” and “Allowing the copying of the Java APIs is like undoing all copyleft licenses into basically public domain” (if they even consider the facts at all, and not just their personal vendettas). Which is taking it just a bit out of proportion.

Given that:

  1. There was no way Android (inc, and later Google) could have fit the entire Java API into a mobile operating system at a time (and make it to market at any reasonable time line and price point), given at how enormous the full spec is.
  2. Most of Android Java code originated from the (now defunct) Apache Harmony project, that while it did not pass (and could not have passed) the complaincy tests for Java, was none-the-less blessed by many proponents of Java such as IBM, and was not treated adversely by Sun.
  3. API re-implementations without licensing with the original API creator are very common in the industry2, especially if you consider file formats as an API (which Oracle does, speaking about the Java class binary format) where you have many many programs that load proprietary formats created by others without licensing (commercial or otherwise).
  4. The Legal consensus, as can be seen in both copyright laws (such as the DMCA) as well as opinions by courts and advocate organizations is that reverse engineering for the purpose of interoperability and compatibility is allowed.

Then Google’s decision, after failing to negotiate a license for their use of the API, and seeing that even Sun executives did not think that Google need a license, make a lot of sense and looks entirely unlike “stealing from Sun” as Chris Fisher puts it.

One can take Oracle’s view that re-implementing part of the Java language specification is a violation of the Java language specification “open and free license” and allowing Google to get away with it under the fair use doctoring opens all “open and free licenses” to such, and worse, abuse; or one can understand that re-implementing APIs is a time honored and fair use practice and not to confuse the two distinct issues of re-implementing APIs and copying software source code.

  1. I understand where Michael Dominick is coming from – In regard to the only implementation source code copyright claim that reached trial: the array range check function, which is 9 rather trivial lines of code, and which Google initially claimed wasn’t copied but after being ruled against switch to claiming that it was exempt because it was such a small piece – likely for judicial technical reasons, Joshua Block, the engineer who wrote the code in question, after being hammered in court about it for several hours was quoted to say: “I think the similarity of the signature, the fact that, you know, the three arguments are in the same order and have the same name, you know, is a strong indication that it is likely that I did [copy]”. But given that the concept of array range checks is almost as old as programing, that Joshua Bloch was also the same person who wrote that code in Sun’s implantation while he was being employed by Sun, and that the Judge in the 1st and 3rd cases has taught himself Java to see if that code is rather trivial and then said that there are not many other ways to implement the same function – given all that, I believe that its a case of just the same person, implementing the same requirements under the same constraints, even several years apart, if the task is small enough he is very likely to write it the exact same way. []
  2. I’ve already discussed a couple of them, but here are a few more: Amazon Aurora and MariaDB are reimplementation of the MySQL API; Google Chrome and many other browsers reimplement the Netscape plugin API; Media players often reimplement the WinAMP plugin API, e.g. MediaMonkey, XMMS; ReactOS, like Wine mentioned below, reimplements all of Microsoft OS APIs; Apache HTTPd’s mod_isapi reimplements the Microsoft IIS API; Many graphics packages implement the Photoshop plugin API, e.g. Paint Shop Pro, GIMP and many others []

2 Responses to “Googlephobia Paints The World Red”

  1. Oded:

    Continuing to listen to Chris’s rant, I have more comments:
    1. He definitely did buy the Oracle narrative, hook line and sinker, to the point that he says “I wish Oracle would win”, and damn the implications to free reimplantations. This issue is not about dual licensing – is just what Oracle would like you to think.
    2. What does the GPL gave to do with anything? The license in question is the non-software license of the Java spec. The only thing that is GPL in the whole damn thing is the OpenJDK distribution, which didn’t exist when Google did what it was accused of doing, and that Google switched to last year (under full compliance).
    3. Google should have taken a license to get security updates for zero day vulnerabilities. Seriously ?!? What part of “reimplantation” did you bit understand? Different code, different vulnerabilities. The rest of that argument details into fantasyland about some Java CVE that supposedly needed a patch in Android.
    4. Google destroyed net neutrality by working with Verizon? Can you possibly be more disconnected from reality? Google kick-started the whole net neutrality thing by competing against Verizon on the network block allocation thereby forcing the FCC to define wiress networks as open networks:
    5. The thing with the Google engineers emails that is being repeated over and over is blown way out of proportions. As a software engineer, I’ve done IP compliance for several companies (some of which easily as large as Google) and I learned 2 things: (a) engineers either worry too much about licensing or don’t care at all, they rarely understand the concepts and when a license is actually needed, especially when we go into those murky “free” and “open” waters; and (b) that executives often understand even less and always prefer to over-license. The fact that some people, even top executives, in the company discussed licensing and thought that they’d need to pay some money to make everyone feel better, is not a proof that a license is actually required. If Oracle can produce an email from a lawyer that says something like “after analyzing the situation I think we need to get a license” (discussions of the likes I have been involved as part of my work), *only then* it would mean anything.
    For a rather long summary of all the email discovery in favor of Oracle, see Florian Mueller’s FOSS Patents blog , though do note – while Florian Mueller says that his blog is “not affiliated with any party in any way whatsoever”, he was a paid consultant for Oracle at the time.

  2. Oded:

    After hearing the rest of the Coder Radio discussion, I have these additional comments:
    1. Again regarding the email, I think it bears to be very clear on this: the fact that some engineers or executives thought that it is a good idea to get a license, or even required to get a license, does not mean that it is *actually* required to get a license – and the court definitely agreed.
    Compare for example, a “pay as much as you want” sale (there is stuff like this, also with real world products), and you thought “Hmm.. maybe I’ll pay them some money”, but then decided not to – even if you sent your original thought in an email to the entire world, that by itself does not make you a criminal if you eventually decided *not* to pay for something was offered for free.
    2. IPs copyrightable, licensed, or not – they keep going back to it, and I’ll keep asserting that it doesn’t matter: reverse engineering APIs is a time honored practice, and it is usually left to the court to decide if its OK or not on a per-implementation basis, where the court sometimes favors the original owner and sometimes the reimplementation. In the US the consensus is that it is fair use to reverse engineer APIs, except if an EULA forbids it – which isn’t the case here, so it should be allowed. Hey, and what do you know – the court agrees.

Leave a Reply