A Brief Introduction to the Java and .NET Patent Issues
Let's start with Java. With Java you have two options for licensing. First, you can use (possibly with your own modifications) the code from OpenJDK. Second, you can make a new implementation of Java, based on the Java specification.
There is no explicit patent license covering OpenJDK. OpenJDK is covered by GPLv2 and it is generally believed that when one licenses code under GPLv2 that license includes an implicit patent license. In 2004 Dan Ravicher, senior counsel for the Free Software Foundation, warned about the weak patent guarantees for BSD and GPL and recommended attaching patent grants.
This means the scope of the implicit patent license is unclear. On the one hand if all you do is use OpenJDK unmodified you should be completely covered. On the other hand if you made such extensive changes that it is no longer recognizable as Java and now infringes some Oracle non-Java patent, you would probably not be covered by the implicit license. Where exactly you cross the line from covered to uncovered is very fuzzy and unclear.
If you go with the option of making your own implementation, then there is an explicit patent license. That license covers you if you implement the complete specification, and if you do not make certain prohibited changes (adding fields and methods to the standard classes, putting new things in the standard namespaces, stuff like that), and if your implementation passes the "Technology Compatibility Kit".
The big problem with this is the TCK requirement. Sun could (and did) withhold access to the TCK from people who were doing things it did not like with Java. No TCK, no patent license for your implementation. In 2007 Geir Magnusson of Apache issued an open letter complaining about the Harmony project was unable to "acquire an acceptable license for the Java SE 5 technology compatibility kit."
Neither of the above options would work for Google. They couldn't go with the OpenJDK option for a couple of reasons. First, it is GPL. The handset makers and the carriers want to add proprietary features to distinguish themselves from their competitors, and Google felt Android would have a hard time getting accepted if it was under a license that did not allow this. Second, Java SE (which is what OpenJDK implements) is not really suitable for devices like phones. If Google morphed the code to be more like Java ME, they would be in that fuzzy area where no one would be sure whether or not the implicit patent license covers them.
Implementing their own Java following the Java SE specification, and then extending it (carefully avoiding making any changes to the parts that the patent license prohibits changing) might have worked--but they would still have the TCK problem. That path too would be a very rocky road, since Sun wanted Google to simply license Java ME.
Hence, Google went with using Java syntax and semantics, but not using the Java VM. No patent protection.
Now let's compare to .NET, and whether or not Google using Mono would have been safer. Microsoft's patent license for independent .NET implementations is the Microsoft Community Promise. Like Sun's patent license, it does require that you implement all mandatory parts of the specification. Unlike Sun's, there is no particular test that you are required to pass, and limitations on enhancing things. Implement the mandatory things in the spec--you are golden. (If you do enhance things, those enhancements won't be covered by the promise, of course, so some care is still required).
So right off the bat the patent situation is better--you don't have to get Microsoft's approval of your implementation in order to get your patent license. This fits in much better with what Google was trying to do.
Mono implements the mandatory parts of the spec, plus enhancements. Some of those enhancements are implementations of Microsoft .NET frameworks that are not part of the spec, such as WinForms. Those parts of Mono could have patent problems, so if Google had used Mono those would best be avoided.
Google might have still had to modify Mono to make it more suitable for small low-power devices like phones. That could take them outside of the ECMA/ISO spec, and into patent risks. However, there is a thing called the .NET Micro Framework from Microsoft, which kind of corresponds to Java ME. Note the license for .NET Micro Framework: Apache2. That license comes with an explicit patent grant. If Google had made Android based on a mix of Mono and code from .NET Micro Framework, they could likely have made it so all parts are covered against Microsoft patents--the Community Promise covering all the ECMA/ISO standard parts and the patent grant with the Apache2 licensing covering the enhancements for mobile.
What it really comes down to is that Microsoft followed the normal rules for opening up a technology. They submitted both the C# language and the .NET infrastructure to an independent standards body. They provided a patent license that covers implementation of those standards with no restrictions other than the common and normal restriction that you have to implement the required portions of the standard.
Sun did not follow the normal rules. They refused to submit Java to an independent standards body. They put strings on their patent license for the standard that effectively required you to get their approval of your implementation before you could get a license. Later, they did release OpenJDK under GPL, which was an improvement, but they did not accompany it with an explicit patent license, so no one knows just what you can do with OpenJDK (beyond using it unmodified) without running the risk of a patent suit from Sun/Oracle.
This decision was made when Sun was very weak…
Regardless, they had another big reason to go with Java even knowing all of the above; Sun was simply not in a financial position to sue Google. If they had gone with Microsoft that was certainly not the case. In fact it would be very much in Microsoft's best interest to find any excuse to sue Google and block Android.
Of course they could not have predicted that an entity like Oracle would acquire Sun and so the game is afoot.
Except if they had implemented Mono
Re: This decision was made when Sun was very weak…
java can run on the CLR/CLI too. it's simple, much simpler that java to JS as google did with GWT. they'd have to replicate some libs though. some are easy (just recompile the java code), some would be tricky (reflection!), but then, the problem is whether there are patents covering the libs...
Re: Except if they had implemented Mono
how about using linux? MS threatens linux with >200 patents, now who boycotts linux because of that? but mono is dangerous because the OCP might not be safe enough? give me a break!
there's only one solution: abolish sw patents. everything else leaves the entire industry vulnerable.
Re: Except if they had implemented Mono
I do agree that software patents are a blight on the industry. I am not hopeful that they will be abolished anytime soon, but maybe when the US starts really falling behind in IT, someone in power will finally start to do something about them.
Wow what a poorly written article
First of all, only C# 2.0 is an ECMA standard. It's now 5 years old and misses all the features of C# 3.0 and 4.0. Like Lambda Expressions, LINQ, etc. There are no announcements to put C# 3.0 or 4.0 under the ECMA and I would think it will never happen.
You should also read what the FSF have to say about the community promise, in the part of the patents.
The Community Promise only extends to claims in Microsoft patents that are necessary to implement the covered specifications. Judging just by the size of its patent portfolio, it's likely that Microsoft holds patents which a complete standard implementation probably infringes even if it's not strictly necessary—maybe the patent covers a straightforward speed optimization, or some common way of performing some task. The Community Promise doesn't say anything about these patents, and so Microsoft can still use them to threaten standard implementations.
So even if Google implements C#/.NET they are still under threat from MS to be sued of any technology that goes beyond the basics of C# 2.0/.NET. Android is a direct competitor to Windows Mobile 7. If Google would use C#/.NET that would like to put the gun in the hands of the bank robber and give him the ammunition, too.
Last, how can you say the .NET Micro Framework is "kind of" Java ME? .NET MF is a very low level framework for embedded devices with not more then 300 KB. Compare this to Java ME features, like File Connection and PIM, Location API, Mobile 3D Graphics, Java Bindings for the OpenGL ES API, etc.
Re: Except if they had implemented Mono
Not in public, but they answer individual requests. If you have the slightest idea of how insane the patent system works, you cannot seriously doubt that MS has a few patents that Linux infringes on. Whether these patents would hold in court is a different question though (prior art...)
OTOH, where's the list of patents that Mono infringes? I've never seen it. My guess is that >50% of patents that Mono might infringe are held by Sun/Oracle. Now will we stop using any VM technology at all? Hardly.
Also, you have to differentiate between CLI (OSP coverage), open source .NET components (patent coverage via apache/Ms-PL licenses), non-covered implementations like WinForms and genuine Mono components like Gtk#
The OCP is binding and cannot be revoked. Not even the SFLC disputes that. Where do you get your information from? So, bottom line, MS could sue Mono's CLI implementation over patents, because of the OCP, and even if some laywer found a way, everyone would consider this a breach of trust -> really big image problem. Nobody would consider a patent lawsuit against any other technology including Linux a breach of trust - they always said they might.
The whole patent argument against Mono is a big piece of fud. There's always some residual risk in patents, but nothing that would make Mono more exposed than any other complex piece of technology.
Re: Wow what a poorly written article
What the FSF says is what you'd expect them to, given who they are and who MS is. No patent grant goes beyond covering implementation of a specific functionality, the Java grant does not even go that far. What do you expect? The FSF's reading is that, if you get sued and invoke the OSP, that MS could just say, OK, but you could have implemented it in another (less efficient) way, so the OSP does not hold. I'd like to see that argument made in court *eyeroll*
BTW, aaaaaaa aaaaaaa, InfoQ has a real-name policy, which has always kept the trolling low.
Stuart Williams Aug 02, 2015