Mono (and DotGNU) Considered Harmful


During the last few days, there have been a lot of heat around the inclusion (or exclusion) of Mono, an implementation of Common Language Infrastructure (or, in short, .NET), in various important distros (exclusion from Fedora, but inclusion in Ubuntu and Debian). Something even bigger escapes most people’s attention: DotGNU, yet-another-.NET-implementation, is considered to be one of the high priority in GNU Project.

 This prompts me to think: Is .NET that important? Can Linux and GNU thrive without it? Do FOSS (Free and/or Open Source Software) communities need it? As I look at this matter more closely, the answer is the reverse: No, not only .NET not bolster GNU/Linux as a platform, but it is actually harmful to the spread of FOSS in general, even if no patent problems involve.

First, let us recall the most important attack of Microsoft on FOSS: the lack of innovation. According to Microsoft (and the majority of the “industry” at large), FOSS does not have innovation. It is purely about “scratch your own itches,” which can be translated roughly as “copy features from proprietary software.” Of course, any serious FOSS user knows that this is not true (from whole projects like TeX and Emacs to small details like plug-in system for Compiz, FOSS is full of innovation, meaningful innovations that actually boost users’ productivity). However, Mono and DotGNU say a different thing.

Remember, .NET is from Microsoft. Okay, that is just another copy of technology from Java, which is open-source, but in general, it is from Microsoft.Well, even Java is not as open-source as Sun wishes to claim, but it grows into open source in the end, so let’s count it as such. However, .NET is not. Although it is a standard, in people’s mind, .NET is Microsoft’s innovation. They created it, standardized it (sort of), and continue to improve it. Therefore, it belongs to Microsoft.

Thus, when FOSS implements .NET, it is very easy to say: “hey, they copy it from Microsoft.” You may or may not agree, but just think about how easy it is to frame the situation as such. FOSS must steal from proprietary software to develop. This implies that FOSS is but a hippie movement, without real ability, and must dependent on “professional developers” writing proprietary software to continue on. Now, try to argue against that. Hey, you guys steal .NET idea, remember?

This further implies that there is no good enough tools on GNU/Linux platform, so people there must port .NET to the platform. Before opening an argument against this, remember that, unfortunately, Microsoft still controls the media at large. Thus, similar to how they conduct “research” proving “Windows’ superiority”, making a claim that GNU/Linux as a platform is weak, lack of innovation, and without powerful tools is oh-so-easy. The audience, who have rarely stepped out of Microsoft’s world, have every reason to believe this story. Hey, they have proof.

By the way, I have just been discussing only one harmful effect of Mono and DotGNU. That’s, of course, far from all. Let’s look at another.

As a matter of fact, FOSS and Microsoft are at war. Ideology war over the better way to build software, financial war over control of the market, and spiritual war over the love of users. So far, FOSS has been winning, for a simple reason: innovation. Best programming tools are traditionally from Unix/Linux systems and FOSS world, then gradually spread into Windows. C/C++ are from Unix. grep, sed, Emacs, Vi, etc. are from Unix. Best implementations of these are the open-source ones. Oh, TeX and LaTeX are from Unix and FOSS. Perl, PostgreSQL, Xen, Python, etc. are from FOSS world. In general, we have the initiative, and Microsoft constantly plays catch-up. Well, they have money, and the media, and the market, all of which FOSS is gaining.

However, .NET is from Microsoft, and if FOSS embraces it, we will have to play catch-up. True, if Microsoft radically changes the platform, it will break with thousands programs. However, if it gradually improves .NET, FOSS will have to play catch-up. And this is no good. Remember that the goal of these projects (Mono and DotGNU) is, first and foremost, complete compatibility with Microsoft’s .NET, and it is painful to do so. Heck, these projects sometimes even need to replicate bugs! Just like how Wine is struggling, Mono and DotGNU will struggle. Meanwhile, Microsoft will happily add new features and bugs. Excuse me, but Microsoft has never understood “removing weaknesses and restrictions that make new features appear necessary.” Its forte is patching and piling feature on top of feature. Good luck catch-up with that.

Lastly, Mono and DotGNU will forever be second-rate. This is the very reason that I don’t use OpenOffice: no matter how good it is, it still feels second-hand, something copied from something else. Instead, I rather use LaTeX and GNU/Emacs, which provide me with first rate editor and presentation. Similarly, Mono and DotGNU cannot be the same as .NET. They will always feel incomplete, inadequate (remember, some people love to exploit a platform’s bugs, and good luck being compatible with that), and cheap. Now, try to convince a programmer to a incomplete, inadequate, and cheap platform.

Of course, you may always argue that new projects can work with Mono or DotGNU, and not feeling that kind of things, or not having to model after .NET’s bugs, or whatever. However, consider this: does GNU/Linux platform really need yet-another-VM? Seriously? FOSS, for example, does not really need a VM: you have the source code, for God’s sake. What can be more portable than the source code, in human-readable and understandable format? Don’t want to recompile for each individual platform? Well, use Perl or Python or Ruby. They are good. At the very least, use JVM, it is free (well, as if you need to do that. If you program is good, distros will happily compile for you). Or, use Parrot. It’s brand new, but very powerful. Why bother kissing up with Microsoft?

In the end, what do Mono and DotGNU give GNU/Linux? Compatible with Windows? Well, OS/2 tried that, you know. And, as I argued, it’s impossible anyway. New tools? Well, not necessary. Proof of better software model? The reverse. What else? A lot of arguments and flames back and forth, crack between members of the community, vulnerability for Microsoft to exploit. Is it worth the effort, the price, the crack, the insults, the time, to add just-another-tool, a rather unnecessary one? 

 Thus, Mono and DotGNU are harmful.