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.
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 basis(1)
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?
- 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.
- 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”.
- 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.
- 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.
- 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.
- API re-implementations without licensing with the original API creator are very common in the industry(2), 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).
- 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.
- In Oracle’s world, Android is a crime against open source(techcrunch.com)
- Jury Hears Closing Arguments in Oracle-Google Copyright Case(sci-tech-today.com)
- The Oracle-Google Case Will Decide the Future of Software(cacm.acm.org)
- Oracle denies buying Sun to sue Google over Java(venturebeat.com)
- 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. [↩]
- 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 [↩]