Glyn's article was published by Computerworld UK.
To sum up the key points, RMS stated the following in the interview:
- Due to patents held by Microsoft on its .NET technology, the availability of two .NET implementations (Mono and DotGNU) under free software licenses doesn't mean that free software developers should, according to RMS, write code for the platform. His call on the free software community: "You shouldn't write software to use .NET. No exceptions." RMS says that Microsoft could one day use patents against free .NET implementations.
- RMS thinks that the C# ("C Sharp") programming language should also be avoided. He makes a distinction between that one and .NET because C# was "standardized by a standards committee" and Microsoft made "a stronger commitment" concerning patents than for alternative implementations of other elements of .NET.
- As a requirement for RMS to encourage the development of free software on free implementations of .NET, Micosoft would have to "make an ironclad commitment that its present and future patents will never be used against implementations of DotNET."
RMS's utopian advice runs counter to commercial logic and fails to advance the cause of software freedom
Adopting his advice would be an utterly stupid decision for any developer from a business point of view, which is actually normal because RMS's agenda is all about software freedom and not at all about commercial success. But even from a non-commercial free software point of view I think this kind of advice doesn't make sense in the world in which we actually live.
The only alternatives in terms of programming languages and platforms that could perhaps be supported under RMS's premises would have had to be open-sourced in exactly the same form more than 20 years ago (without even the smallest modification made ever since) and then the new software one writes on top of it today wouldn't be guaranteed to be truly free software for another 20 years. 20 years is the potential life expectancy of a software patent, and I'll explain the logic of this further below.
So unless someone wants to waste 20 years or even an entire professional life of 40 years just for the sake of an ideology, it's better to reject such utopian advice and take a realistic perspective on patent-related risks.
There's no particular reason not to develop software for .NET (as compared to any other platform on this planet), and free implementations of .NET such as Mono and DotGNU aren't really less free than a free Java application server or a PHP interpreter for Apache.
RMS focuses on the lesser risk and ignores the greater one
The fundamental mistake made by RMS in the aforementioned interview is that he narrows the whole patent-related risk down to only one company (Microsoft), which actually has a stronger commercial interest than any other in the world to make the .NET platform popular and to ensure developers succeed with the applications they build on top of it. And we all know how much competition there is between platform companies for the hearts and minds of developers. More importantly, Richard completely ignores the fact that hostilities against Mono and DotGNU could also come from other patent holders.
Even if one sides with RMS concerning what the greater risk is and rejects my business logic for the platform company itself being most likely to want the best for its application developers, no one can reasonably deny that there's a huge number of patent holders other than Microsoft whom RMS fails to take into consideration. That mistake is sufficient all by itself -- regardless of how to assess the different risks -- to prove RMS's advice concerning C#, .NET, Mono and DotGNU wrong in the sense that there are also patent risks concerning any other programming language or platform out there.
Yes, free software is incompatible with patents, but software patents exist on pretty much every kind of software technology and therefore I don't think one can make the case that free .NET implementations or software written to run on them is inherently less free than other software available under the same licenses.
Time heals the wounded and invalidates patents
In the patent minefield that exists, there's no such thing as a reliably patent-unencumbered programming language or API (application programming interface) except for a hypothetical scenario of no practical relevance. That scenario is one in which all patents that may read on the platform have either expired or can be easily invalidated.
Since software patents (at least in the jurisdictions I know) have a maximum term of validity of 20 years and patented ideas must be new by the time of the application (or they can be invalidated later on the basis of "prior art"), one can argue that if software was published (as open source) more than 20 years ago, all patents will either have expired or the published source code (which should be time-stamped to prove its vintage year) could be used as prior art to take down younger patents on the same technology.
Therefore, free software developers would have to use free platforms that are more than 20 years old (and were published as free software back then, not just later). The applications they write couldn't be guaranteed to be patent-unencumbered for another 20 years after the publication of their source code.
In other words, the price to be paid for a guarantee of being patent-unencumbered is to be decades behind the evolution of technology, and to be extremely patient relative to the duration of a human professional life.
The pragmatic alternative is to regard free software as a great idea and a wonderful vision, but to understand that patents make all software potentially non-free, regardless of whether the patents in question are held by Microsoft or anyone else.
The solution proposed by RMS (an "ironclad commitment") would be desirable but insufficient
At the end of the interview, RMS made the proposal I mentioned in item 3 of my summary of his position at the beginning of this posting. He said that Microsoft should make an "ironclad commitment" not to use current or future patents against free implementations of the .NET API.
I, for my part, would very much welcome such a commitment. But I disagree that it would make all the difference that RMS suggests it would make. It wouldn't solve the problem of third-party patents. Every other current or future software patent holder in the world would also have to make that promise in order for RMS's vision to materialize.
The second part also applies to platforms for which the original developer makes an "ironclad" patent promise. Even a free programming language like PHP can infringe and almost certainly will infringe on some third-party patents out there, unless you take a programming platform that was open-sourced more than 20 years back (as I explained further above).
So I strongly recommend to focus on how patent holders actually use their rights. In that respect, I will comment on Microsoft in greater detail in some other posting, but I can already say at this stage that there simply isn't any evidence of Microsoft using patents in a way that would drive companies out of business or jeopardize the existence of FOSS projects.
Don't cut off your nose to spite your face
RMS also refers to Eben Moglen's assessment that Microsoft's Open Specification Promise "is not something we can rely on." I can see why Richard and Eben say so. But I can also see reasons for which one could say the same about (to name but a few examples) Red Hat's patent policy, the promises Oracle made concerning the acquisition of MySQL (without wanting to comment on what Oracle is doing now), Google's vague assurances concerning WebM, the Open Invention Network's arbitrary scope of protection, or IBM's broken patent pledge.
Concerning IBM's pledge, I remember that RMS also commented on it unfavorably back in 2005 when it was made (not as aggressively as I did, but it was clear that Richard also rejected that approach). So he's aware of the fact that vendors don't make those public commitments in an "ironclad" form. That's a general problem and it's not particular to .NET, C#, Mono and DotGNU. Nor are the other concerns voiced by RMS specific to those technologies.
That's why I think a decision to write software for .NET, or to implement .NET interfaces in free software, isn't a statement against freedom any more than using any other current platform: Java, PHP, you name it. But acting in accordance with RMS's advice would be a self-imposed restriction of freedom, for no good reason.
With the greatest respect (which he deserves), he sometimes proposes to cut off one's nose to spite one's face.
If you'd like to be updated on patent issues affecting free software and open source, please subscribe to my RSS feed (in the right-hand column) and/or follow me on Twitter @FOSSpatents.