In my continuing attempt to listen to pro-mono points and address them, we have a question to consider!
In which zekopeko makes a proposition
In a comment to my Totally Awesome Rocks and Excellent article “Ubuntu Free Speech Zones”, zekopeko makes a very interesting proposition:
MS position certainly is “entrenched” on the market, but as we can see it’s slowly but surely being eaten by FLOSS solutions. And in part thanks to Mono, whether you like it or not.
This is a powerful proposition, and deserves serious consideration.
In which a zealot who is not part of the real community zealously expresses his zeoltry with zeal
BEWARE! Crazy zealot beliefs coming up. This is what I think when I’m not eating babies and trying to destroy Freedom single-handedly:
- Microsoft has a much larger influence than FLOSS on the computing industry.
- Microsoft influence needs to be reduced.
- Microsoft influence is likely to decrease over time, for many reasons.
I know that is some crazy juice negative hateful talk, and I can only hope you are seated for the next part, because I’m really going to let the freak flag fly:
- FLOSS has a much smaller influence than Microsoft on the computing industry.
- FLOSS influence needs to be increased.
- FLOSS influence is likely to increase over time, for many reasons.
I know that is some insane stuff there, and I probably deserve to be roundly condemned for such “faux community” ideals. Why it’s almost if I had …shudder… principles! Here are some logical extensions of my belief:
- I am generally opposed to those things that help Microsoft.
- I am generally supportive of those things that help FLOSS.
- I am generally supportive of those things that hurt Microsoft.
- I am generally opposed to those things that hurt FLOSS.
Well, now that you have seen how irrational I am, I can only hope you will read on.
In which a few facts are established
- .NET is a key Microsoft technology / initiative / mouthwash / salad topping.
- Microsoft discussed standardization before doing it.
- We can know some, but not all, of Microsoft’s motives.
From these facts I think we can derive some logical conclusions:
- Microsoft is aware that .NET is a valuable technology for Microsoft.
- Microsoft did not standardize portions of .NET for no rational reason whatsoever.
Am I going to fast for anyone? You in the back with the gnome cap and the drool, pooping in your hand and flinging it at that poster of Richard Stallman, still with us?
In which some insight is given
Let us look directly at what some people in the Microsoft camp internally thought about the release of .NET to the Unwashed Masses:
Bill Gates (2001):
We have to spend a lot of money to make sure the openness of C# is well understood and that it is accepted at a level that allows our innovations to have traction. [...] The strength of this platform and the innovation around it is the key element in preventing commodization by Linux, our installed base and Network Appliance vendors.
It is important to understand when Bill Gates says “well understood” he means “thought of the way Microsoft wants”. He uses this exact euphemism frequently. He also likes to say “innovation” when he means “proprietary closed extensions”.
Charles Fitzgerald, Microsoft GM (2001):
[Working on cross-platform .NET CLR] is terrifying. A x-plat strategy is not a winning strategy.
[...]
[The .NET CLR cross-platform strategy is] potentially worse than that – we both validate x-platform and then demonstrate conclusively we not prepared to deliver on it.
Srivats Srinivasan, Microsoft PM (2001):
We understand the need for DMD to proliferate the format … however, if it is at the expense of our embedded OSs, I fear that it can hurt us in the long run. Especially when you consider that part of enabling the .NET vision is to embed our OSs in devices of all forms going forward – hence our apprehension.
Graham Clark, Microsoft GM (2001):
I would like to understand the x-plat strategy, because I don’t get it and nor does anyone in the field. It doesn’t seem to make ANY sense.
By putting CLI into ECMA, we are inviting x-plat implementations. With Rotor we are even doing some work on Linux and Solaris.
For enterprise customers/partners, wanting to build enterprise apps, all this is meaningless as there is no mechanism to provide transaction (and other core services) support on these non-Windows implementations. J2EE clearly has a mechanism, albeit faulty, to enable these x-plat services.
I can think of four explanations for our current strategy (as I and the field see it):
1. There is something happening to provide these applications services x-platform that I don’t understand (based on Joe [Long]’s proposition, I doubt it is this).
2. We think that our customers/partners/analysts are stupid and that they won’t see our approach as insufficient for real enterprise apps.
3. We are going to evangelize to IBM and others to plug their own transaction services under CLI on Linux (without specifying how). Joe’s proposal is to tell them how.
4. We haven’t thought thru a strategy that will make sense after anything more than a superficial inspection – if so why are we doing all the Rotor work?
If the answer is (2) then we have learned nothing from the past 5 years and J2EE will continue to kick our butts. I would rather see Microsoft say x-plat is BS rather than make a half step (Rotor, CLI) that will confuse everyone and lead to continued distrust of our motives for doing it.
Dan Neault, Microsoft GM (2005):
Maintaining Gap vs. Linux
1. Keep network effect with Applications
- Migrate applications to .NET framework
- BUT keep framework proprietary to Windows
- Patents required to implement clone
[...]
Maintaining Gap vs. Linux
- The .NET framework contains the latest developer platform for the future, and it must be licensed like Windows. Subsets have gone about as far as they should go in the standards bodies, but we need a compact subset for phones and TVs. It was noted that we have to be careful because once the horses are out, they are out forever. At the right royalty, we can have discussions around technology beyond this.
[...]
- The plan in that images, inks, and still formats will not go to Linux like some of our digital media formats will. This would mean that if someone downloads images, it might violate patents. There was a discussion of a new format where as one takes pictures, the pixel resolution compresses.
[...]
[...]Strategy Axioms
Technical Axioms
- Invest in formats/protocols (ensure we are not blocked; gather IP advantage if possible)
Eric Rudder, Senior VP (2005)
As many of you may know, we’ve actually kind of broadened the product portfolio of Visual Studio, targeting all the way from the low end with students and hobbyists, kind of competitive in that Linux space, making sure that every developer has a copy of .NET and is trained in writing .NET solutions. We introduced the low-end version we call Visual Studio Express, so we have Visual C# Express, Visual Basic Express, and Web Developer Express. These products are still in their beta phases, but we actually had more than a million downloads of Visual Studio, which is quite healthy for a developer tool. I think it will really help us in our competition with open source.
These are all court exhibits or public statements made not by janitors or interns or mouthpieces hired to spin doctor Microsoft’s image; these are decision makers. They are Microsoft, and this is discussion that went on for years surrounding the relase of parts of .NET for standardization.
No matter what level of supervillian-like nefariousness you care to read into such quotes, you will surely agree that the decision to standardize parts of .NET was throughly considered by Microsoft before doing it.
In which a point is made
Why exactly do you think Microsoft decided to standardize parts of .NET?
There can be no doubt they discussed the ramifications of such an action. Do you think that Microsoft would act against its own best interests?
Then it is reasonable to assume that Microsoft thought standardizing parts of .NET was in Microsoft’s best interests.
We should be able to stop there, but I know my Gentle Readers clamor for ever more elucidation. Plus, I’m not leaving until the poop-flinger in the back does.
Alright, one may say, Microsoft released parts of .NET because it was in thier best interests? So what! Mono still helps Linux and Open Source development! So neener neener to you, Mr. Mono-Hater!
Fine, Mono may indeed help FLOSS to some degree. The question is, does it help Microsoft more than it helps Linux? This is an important question, because if you help your competition more than yourself, you are in effect harming yourself.
What is Mono doing?
We know Mono must help Microsoft. Microsoft would not have allowed for the ECMA standardization if they did not come to the same conclusion.
Here are some ways Mono helps Microsoft:
- Spreads Microsoft standards
- Spreads Microsoft mindshare
- Increases FLOSS dependency on Microsoft
- Good PR value for Microsoft
- Mono apologists are often obliged to defend Microsoft
- Mono evangelists are often obliged to be Microsoft evangelists
- Divides, distracts and delays the community
- Makes it easier for FLOSS developers to develop on Windows
- Provides some nice FLOSS applications for Windows
- Provides developer tools
- Helps in Microsoft’s fight against Flash
- Helps in Microsoft’s fight against Java
- Decreases effort in general for non-Microsoft tools
Think on that. When a Mono developer stands on stage with a huge slide that says:
“Moonlight is an Open Source implementation of Microsoft’s Silverlight technology … and it is awesome”
They are evangelizing Microsoft. They are promoting Microsoft. They are increasing Microsoft’s mindshare. That is good PR for Microsoft. Microsoft actually pays some people money to do that! That is actually a career for some people!
Now, here are some ways Mono helps Linux that are unique to Linux (i.e. not covered in the above list):
- Provides partial compatibility with some Microsoft offerings
There are almost no unique benefits to Linux from Mono. Microsoft enjoys almost every benefit that Linux does from the Mono project, as well as some unique ones. I think it is quite clear that Mono benefits Microsoft more than Linux.
A difficult question
Consider this: Say that Microsoft released .NET for Linux in the same manner they did for Windows. Do you think that it would enjoy the same adoption, enthusiasm and support that Mono enjoys?
If you answer is not “Yes. Absolutely”, then you are acknowledging that ideals and ethics do matter. Quit pretending like people that have them are some sort of embarrassment holding Linux back.
That is the problem with a purely “pragmatic” approach. That is the problem with preaching that “users just want something that works”.
An easier question
And now, I think we can return to zekopeko’s original thesis: Microsoft’s position is slowly being eaten away in part by Mono.
I reject that. I do think that Microsoft’s position is slowly being eaten away; but I do not think Mono is playing a significant role there. I think that Mono helps Microsoft at least as much, if not more than it helps FLOSS. So, it can not “eat away” at Microsoft’s position, because it is in fact bolstering Microsoft’s position.
So I ask you, should the community support something that harms it?

#1 by Lex on July 25th, 2009
“It is interesting to see that many stuff in the feed are actually Iron Python evangelism, with Icaza showing a lot of work to promote it over the real python”
What exactly is the relationship between Icaza and IronPython? Is he contributing to that project? If not, it seems he is just promoting anything Microsoft and that would make him lose some more karma points.
#2 by Jason on July 25th, 2009
@zekepeko,
So now you see it my way!
#3 by zekopeko on July 25th, 2009
I imagine that is how the anti-mono-fundie crowd see it. I’m going to take your comment with /s.
#4 by Richard on July 27th, 2009
@Lex,
So they first translate the app + Mono to Java bytecode, and execute that. There’s only Java bytecode executing at this point, yes? Yes. Does this contradict anything — anything at all — that I’ve said? No, it doesn’t.
… which is absolute, unmitigated rubbish. Conversion from MSIL to Java bytecode is done in Step 1. It is 100% reliable. The “key component” is not Mono; it is the MSIL-to-JavaBytecode translator.
Please, do me and everyone else a favour, and just ask someone neutral — a Computer Science professor, or someone who works with compilers, if you have access to anyone like that. Or get a compiler theory book. Then you can stop this ridiculous arguing.
I’m going to lay this out as a simple follow-the-numbers argument.
1. The .Net v2.0 CLR implemented by Mono is legally protected by estoppel, ECMA, and the standardisation process. If you agree, go to (2). If you do not agree, go to (3).
2. Any future version of MSIL can be translated to v2.0-CLR MSIL. If you agree, go to (4). If you don’t agree, go to (5).
3. Please review the ECMA process, and note that in addition to RAND terms, Microsoft and co-sponsors have guaranteed that any patents are provided royalty-free. When you agree that the v2.0 CLR is legally protected, go to (2).
4. Welcome to the end of the discussion! If any future MSIL can be translated to v2.0-CLR MSIL, then it is impossible for any party to remove compatibility with the current Mono implementation, and any future version of .Net is guaranteed to run using Mono.
5. Oh-oh! You’ve arrived at I-Don’t-Have-Any-Practical-Experience Land! To rectify this lack, please create a translator from C++ to C. Then examine the structure of MSIL, and discover (shock! horror!) that it necessarily retains metadata (you can use Mono.Cecil to help you with this). If not yet convinced, delve into the source code for IKVM.Runtime.dll. When you are done, you will agree with me. You can then go to (4).
I’m glad that I amuse you with my offer to take something off-topic off-list. Your comment comes across as “Naah! I win! You ran away! Say you’re WRONG! Loser!”. After someone invests time in genuinely discussing things with you, do you consider it proper to end the discussion like that? Where I come from, at the end of a discussion, the two sides shake hands and either agree to disagree (with more understanding or both sides) or come to a decision on the matter. You need a lesson in etiquette; let me put it in terms that you’ll understand:
You’re acting like a child, and if you act like a child then you shouldn’t expect to be treated as an adult. Grow up. When people discuss technical issues with you, make an attempt to understand their points or request clarification. Ask someone qualified that you trust, if you don’t have experience with it yourself. Understand that technical issues are not a “matter of opinion”, and they are not subjective. Something is either possible, or impossible, and those are your options (there’s also “computationally infeasible”, but that’s just a subset of “possible” that approaches “impossible”
). Also understand that no matter how many “debates” about a technical issue you may win or lose, it doesn’t change the fact of that issue one iota. The C specification doesn’t care if you don’t understand, love, or hate “undefined behavior” or not: it will affect your program just the same either way.
It’s quite plain to me that you haven’t the faintest clue about compiler theory, and have never implemented as much as a toy cross-compiler, whereas I have. Educate yourself. I’d rather have done this more gently over email, but you seem intent on being embarrassed in public — and who am I to deny the whims of a child?
#5 by Jason on July 27th, 2009
@Richard,
I’m not a compiler dude, and I think I follow your argument.
The point I would raise is that isn’t point 2 above basically saying any Turing-complete system can implement any other Turing-complete system?
That doesn’t mean that everyone wants to use Brainfuck though, right? I mean isn’t the real argument around languages nowadays largely due to syntactic sugar and how well those things incorporate into the overall language?
In another words, isn’t it possible (albeit unlikely, I’ll admit), that Microsoft could release future versions of the CLI and C# so radically different from the existing versions that it would be an enormous effort to do this re-implementation?
Part of the criticism of Mono that I do subscribe to, and think is a strong point, is that Mono is always going to be trailing “real” .NET. Now, I don’t think that makes it worthless, or invalidates it, but I do think it is a weakness – the seriousness of which is surely debatable.
#6 by Richard on July 27th, 2009
@Jason,
Yes — and if anything concerns me, that does.
Syntactic sugar is a different sort of issue, since it deals with the compiler (and not the CLR). I don’t think that this is a real area for concern, since language constructs can’t be copyrighted (as far as I know! I’m not aware of anyone successfully doing so, anyway; see the x86 instruction-set wars for a take on this). Mono’s compiler can always implement syntactic changes.
Precisely. Converting from x86 to PPC is possible, but a mind-numbingly bad idea, precisely because of the differing architectures. This is why, if Microsoft decides to change their entire .Net architecture — effectively making it into something completely different which just happens to have the name “.Net” — everyone is screwed, Windows developers included. Third-party tools will stop working correctly. Microsoft’s own tools will stop working correctly! I can’t honestly see this as happening; it’s not a live option, any more than dropping backwards compatibility for Windows 7 is a live option. By converting from a future CLR to an existing CLR, it is possible (and likely) that efficiency will be lost, and this could necessitate additional tweaks and heuristics to the existing CLR. The consequence of this is that programs written for the future CLR may run more slowly on Mono
.
Were Microsoft to take this sort of path, I think that I would abandon, with regret, the .Net architecture. I doubt that I’d be the only one. One of the reasons that I admire it is because it is very cross-platform, and if they remove that, … well, I suspect I won’t be the only one that they alienate. Leaves me with Java to use, though, which is not an appealing option (after a decade, no lambda functions? It’s like being crippled…).
That’s a common misconception
. Riiiiight at the start, before Mono got off the ground properly, I heard this cynical view a lot. It’s outdated now, though.
In fact, Mono is very ahead in some areas of .Net development. They have provided us with a C# shell, an excellent MSIL-manipulation library (Mono.Cecil), GTK# bindings, Gendarme (FxCop, eat your heart out!), the concept of a package consisting of multiple assemblies, and so forth. I use both Mono.Cairo and Mono.Cecil in my work, and know of many other developers who have turned down an existing Microsoft alternative (such as the System.Reflection namespace) in favour of these excellent tools. From where I’m sitting, it looks more like cross-pollination than follow-the-leader.
#7 by Lex on July 28th, 2009
@Richard
Strangely you continue to amuse me.
Let’s take a mono library that is not covered by ECMA and is not a subject to patent protection. Now, if this library has a legal problem, that means the source code of that library has a problem.
It does not matter what bytecode you compiled that library to. If the source violates the law, so does the compiled version.
So your claim that any future version of MSIL can be translated to v2.0-CLR MSIL makes no difference whatsoever. The patented libraries will retain their patent protection under any form of compilation. The big problem is that most .net libraries are not a part of ECMA. Mono has many components, some are covered by ECMA and some are not.
What are you going to do about the libraries that are not covered? Your answer consistently seems to be – recompile them to another bytecode. But that will not gain you patent protection. You seem to conveniently ignore that and continue focusing on bytecode.
It seems I’m going to have to repeat myself for the THIRD time. The problem is not the bytecode, the problem is translating library calls.
It looks like you are descending to the level of personal insults while forgetting to say anything about so much talked about 100% compatibility. I understand it must be hard for you to admit when you are wrong, so you’d rather forget those things and focus a discussion on non-relevant topics. It’s ok, most pro-Mono people seem to follow that pattern, it’s not something new and I don’t hold it personally against you.
#8 by Richard on July 28th, 2009
@Lex,
You make accusations; let’s see if you have the evidence to back those accusations up!
Name such a library. System.Data, System.Web we know of; these are trivial (in fact, System.Web is effectively being done away with in favour of MVC); any others?
… “most”? Big claims. What percentage are we talking about? Can you give me the assembly names?
No. That is my answer to a future incompatible CLR. That is not my answer to the problem of libraries; if you think that it is, quote any point at which I say that. My answer is “this is why such libraries would have to be reimplemented”, to quote myself in comment #45. My answer to the legal “issues” that might arise from this strategy are documented at the end of comment #34.
#9 by Lex on July 28th, 2009
@Richard
You were claiming that any mono project can be recompiled (i’m sorry, TRANSLATED) into java or older MSIL to avoid legal issues, and that it can be done with 100% reliability and 100% automation. COST FREE (yes, you were claiming that too)! Click – done.
So now you are saying that indeed, some libraries may have to be reimplemented. But this is not 100% automation and not cost free.
And you are still silent on “100% reliability”? Oh well…
For “evidence” you have requested I suggest you refer to patent section in mono faq: http://mono-project.com/License
For the answer what libraries in .net are patented and not covered by CP I suggest you lobby to Microsoft.
#10 by Richard on July 28th, 2009
Absolutely, and I still claim that. This completely solves the CLR compatibility issue.
Now? You act as though this is news to you. I have addressed this in comments #34 (“If the feature [...] avoidance of patent issues”), #41 (“this is called [...] are good at it”) and #45 (“this is why [...] worse at the game”). Library compatibility is a completely separate issue to CLR/runtime compatibility. To other readers of this post: is there something that I’m failing to explain to Lex? Perhaps one of you could do a better job? I’m all out of ways to make this simpler to understand.
Lex: you are bordering on being a troll.
No, I don’t think that I will. You made the claim, now back it up or retract it. The onus is not on me to provide evidence for your claims. Whenever I have made a claim, I have provided evidence for it, and referred you to neutral parties if you had doubt. It’s time that you did the same.
#11 by Lex on July 28th, 2009
@Richard
“Absolutely, and I still claim that. This completely solves the CLR compatibility issue.”
Why did you pick CLR compatibility. I was talking about .net compatibility, and as you have put it: mono “is a CLR + tools + libraries”.
I keep talking about the entire stack, but you insist on picking CLR. Are you reading a manual on straw man argument or something?
Explain me how is legal translation to older MSIL or java is 100% reliable and 100% automated when you have to reimplement some libraries to make that translation possible?
__________________________________________________________
On an unrelated topic: you make it sound as if the evidence you require does not exists or impossible to find, when in fact it’s a common subject of pro-anti-mono arguments.
But if you feel the need for diving into a side argument (you seem to do that a lot, my guess is to avoid the real issue)…
Here is a quote from wikipedia:
“The Framework Class Library (FCL) is a superset of the BCL classes and refers to the entire class library that ships with .NET Framework. It includes an expanded set of libraries, including WinForms, ADO.NET, ASP.NET, Language Integrated Query, Windows Presentation Foundation, Windows Communication Foundation among others. The FCL is much larger in scope than standard libraries for languages like C++, and comparable in scope to the standard libraries of Java.”
http://en.wikipedia.org/wiki/.NET_Framework
You can find further links on that page with a list of assemblies.
“Lex: you are bordering on being a troll.”
Richard: you are past the borderline of contradicting yourself, so you start flaming.
#12 by Richard on July 28th, 2009
Alright. We agree that the CLR will remain, and there are no legal issues with it, so there are no problems there. Mono’s tools have been independently created, and there are no problems there. The core libraries will remain (see: estoppel, ECMA process), so there are no problems there.
So, tell me: what’s still bugging you that hasn’t been covered?
See above. Reimplementation of existing libraries is not necessary.
(I’ll repeat that). Reimplementation of existing libraries is not necessary.
Such libraries are also 100% legal. If a new library comes out that is not covered by the CP, a clean-room implementation may be necessary. This is perfectly legal, and the library would have to be implemented in any case. Where’s the problem with this?
No such list exists on that page; and note that ECMA includes much more than just the BCL (e.g., the System.Environment namespace). There are dozens of links leaving the page. Can you be more explicit? Where is this list of non-covered assemblies to which you refer?
#13 by Lex on July 28th, 2009
@Richard
“Reimplementation of existing libraries is not necessary.”
By far, this is the least correct statement you have made yet. Please refer to patent section in mono faq:
“For people who need full compatibility with the Windows platform, Mono’s strategy for dealing with any potential issues that might arise with ASP.NET, ADO.NET or Windows.Forms is: (1) work around the patent by using a different implementation technique that retains the API, but changes the mechanism; if that is not possible, we would (2) remove the pieces of code that were covered by those patents, and also (3) find prior art that would render the patent useless.”
http://mono-project.com/License
Notice #2 choice of mono team is to drop the piece of code infringing a patent. That would leave the burden of reimplementing that piece of library with the user.
“If a new library comes out that is not covered by the CP, a clean-room implementation may be necessary. This is perfectly legal, and the library would have to be implemented in any case. Where’s the problem with this?”
Clean room implementation does not shield you from patent claims. Any new library not covered by the CP would be a subject to the same issues as current libraries not covered by CP.
_________________________________________________________
As for wiki link, it contains a link to an incomplete list of FCL namespaces. I’ll write a script to compare the list of libraries covered by ECMA 335 and a list of namespaces of .NET 3.5 SDK.
#14 by Richard on July 28th, 2009
I see your point. Still, as far as I understand it, Microsoft is leaning towards putting in some legal protections for some of the better items (e.g. System.Linq namespace). If they don’t provide any guarantees about ADO.Net, and WinForms, I probably won’t care (NHibernate and GTK#/WPF are superior alternatives in most cases). ASP.Net is a bit worrying, but since it’s not a desktop technology, the impact is limited …
To my mind, in the sphere of developer tools, they haven’t done much wrong as yet. Sure, that could change. I’m giving them the benefit of the doubt. Innocent until proven guilty, no?
I understand why you feel as you do about clean-room implementation, but that’s mostly a matter of ingenuity if it is possible to work around it (see here), and a matter of interoperability if it is not. Unless something comes up, I don’t think that I’ll worry too much about it, since none of the non-covered namespaces are essential.
On the other hand, if patent problems do arise, I think that I (and others) would become much warier about using the .Net platform. One doesn’t want to code for new features (e.g. LINQ-to-XML), and then have some stupid legal crud slow down a port! Depending on the seriousness of anything that arises, I may well decide to abandon the platform. That would be sad :/.
#15 by Lex on July 29th, 2009
Fair enough. It looks like we run out of things to argue about.
Just as I finished a list of .NET 3.5 FCL classes not covered by ECMA 335. Oh well, maybe it will be useful for some other purposes.
http://mono-nono.com/bbpress/topic/detailed-count-of-net-35-covered-by-ecma-335
#16 by makomk on July 29th, 2009
You’re assuming NHibernate and Gtk# are sufficiently different from the Microsoft equivalent to dodge the patent threat. That’s not necessarily the case – remember that being implemented in the same language forces a certain amount of similarity that wouldn’t be there with (say) Gtk+.
Pingback: Pedro M. Rosario Barbosa’s Blog