Mono isn’t just for Apes

written by Armin Ronacher, on Thursday, August 14, 2008 23:49.

On my trip through the Scotland I bought an edition of “Linux Format” to have something to read while waiting for the train. I was reading the letters to the editor when I came across one letter that was basically an insult to the magazine complaining about their Mono support. Apparently they reviewed Tomboy in an earlier edition and haven't criticised for using Microsoft technology.

I came in contact with C# and .NET about two years ago when it was .NET 2.0 and instantly fell in love with it. It was Java inspired but implemented tons of really cool features like properties, delegates and much more. However at the time, Mono hasn't yet implemented generics which was a 2.0 feature. Maybe it did, but at least my ubuntu installation wasn't shipping gmcs yet. Because of that I pretty much forgot about Mono for a while and just played with it once in a while.

A few weeks ago I noticed that gmcs has a command line switch called -langversion:linq which enables all 2.0 features plus a few from 3.0 and 3.5 which made me play a lot with it. My main development environments are an OS X notebook and an Ubuntu linux one. I still do have a windows box but I just use it for playing. As a matter of fact I'm only interested in Mono and not the Microsoft versions of the .NET technologies. What I've seen so far is that Mono implemented all the cool features I actually want to use. That is C# with generics, “yield return”, lambdas, extension methods and LINQ (that is .NET 3.0 + some 3.5 features as far as I know, afair LINQ is a 3.5 feature). They also have XSP2 and System.Web which makes it possible to use it for web applications. What I've seen so far qualifies as “awesome” so I want to share my feelings about Mono and why I think it's the best since the advent of ubuntu. My real experience with Mono is only a few weeks old therefore I may be missing quite a few things so please take this “review” with a grain of salt.

I think there are three major types of critics of Mono in the Open Source community. Those who think Microsoft pays Novell for developing Mono to take over the world, those who think Mono is a project that will face patent problems in the future because Microsoft will claim copyright infringement and those who have a problem with Novell because of the patent agreement with Microsoft. Of course there are more. There are people who actually had a look at it and compare it to established platforms like the JVM and come to the conclusion that the Sun compiler is better than Mono or something similar. I agree that it's perfectly okay to not like Mono because one is happy with the JVM or to hate Novell to sign that patent agreement with Microsoft. However none of that makes Mono as such a bad thing to have.

Mono is largely based on two ECMA standards (ECMA-334 aka C#) and (ECMA-335 aka CLI or Common Language Infrastructure). Other than that Mono also implements parts of ASP.NET, ADO.NET as well as Windows.Forms which are subject to lots of concern from the Open Source community. I don't know if parts of those are patented already or if that's just a hypothetical problem but it seems to be one of the main reasons why people hate Mono. Fortunately you don't have to use any of them to do proper development with Mono. Especially Windows.Forms is something you don't even want to use ;-)

Mono itself is a fantastic piece of software and one of the best programming environments Linux users got since ages. The big advantage of it is that the Mono environment can host multiple programming languages, not just C#. Even though there are multiple languages running on top of it they can exchange code which is somewhat hard to achieve with the more traditional approaches. For example it's nearly impossible to use a Python library with Ruby or the other way round. With Mono, IronRuby and IronPython this becomes somewhat possible. But I must agree that I haven't played with that in detail so far. C# alone was convincing enough.

There are just two languages I dare to compare with C#. One is obviously Java where C# got mosts of it's inspiration. The other one is D, ~~a rather new language~~(Edit: Apparently D is a lot older than I remembered. turns out it's there since 1999) that unlike C# or Java is not running on an runtime environment but produces nativ code only. There is another one which is called Vala and popped up a while ago which basically tries to be C# compiling down to glib-C. D is a rather new language and there are not many bindings to popular libraries available so far. Vala is even newer. Until Mono popped up there was no statically compiled language with bindings to major open source libraries such as GTK or DBus and was beginner friendly. Most people used C/C++ or Python to develop GNOME applications at least and on my rather new ubuntu box most GUI applications are still made with those languages.

The language that is most similar to C# is Java. Having learned a lot from Java, Microsoft improved C# over Java a lot. C# feels a lot more like Python than Java. My favourite feature of C# is without a doubt the ability to create properties. And from all the languages with comparable features I know (which are Python, Ruby, D and C#) C# really has one of the best solution for the problem. Unlike Java there is no need to write getters and setters from the ground up in fear of breaking code later when code execution on setting/getting of values is required and unlike Python you don't have two variables (foo and _foo) lurking around on the object. A non-property approach to represent a user could look like this:

class User {
  public string Username;
  public User(string username) {
    Username = username;
  }
}

If you later decide to execute code on setting the Username attribute you can easily do so by making the attribute private and adding a property:

class User {
  private string username;
  public User(string username) {
    Username = username;
  }
  public Username {
    get { return username; }
    set {
      Utils.MoveHomeFolder(username, value);
      username = value;
    }
  }
}

My favorite feature after properties is definitively that you have to make methods virtual explicitly. This enables faster code and hides a lot of errors. In general the compiler can save you from quite a lot of problems you only spot with excessive unit-testing in Python. For me that is a huge advantage because I'm a) quite lazy and b) bad at typing. I get typos in the easiest words and thanks to ^P in Vim those appear multiple times before I notice :)

One of the things I love about Python is the possibility to subclass internal objects such as dicts, lists and more to given them a behavior more practical to the kind of data I store in them than the normal version of the objects. For example Werkzeug comes with tons of custom dicts, lists and sets for case insensitive data, multiple keys in a dict and similar stuff. C# makes it ridiculously easy to do that thanks to generics and the classes from System.Collections.Generic. First of all they check the types of the objects you put into them and furthermore you don't even have to subclass them to get collections the standard library accepts as containers. In Python you pretty much have to subclass the builtins because many Python libraries perform instance checks against list, dict etc. In C# there are Interfaces for that and they are used all over the place which is clever.

A huge advantage over Java is also that you have delegates and lambdas which enable a lot of cool stuff not possible in Java. C# also knows “yield return” which is essentially a helper to generate Enumerator (iterator in Python) objects automatically which saves you tons of boilerplate code. Another neat thing about C# is that you have preprocessor directives which enable conditional compilation and allow you to affect the error reporting by providing different line numbers or filenames in “#line” comments. I often wished for something like that in Python for example when writing Jinja which has to do an ugly hack to rewrite the Tracebacks on the fly to get a proper debug output.

But C# goes far beyond that. Apparently the thread safety in C# is mostly achieved by per-object locking which you can control with lock(obj) { ... } which makes it a lot easier to write thread safe classes. The Python “with” statement is available as using (expr) { ... } which leads to much shorter code compared to Java. Take this Java example:

import java.io.*;

public class FileExample {
  public static void main (String[] args) {
    StringBuilder out = new StringBuilder();
    try {
      BufferedReader in = new BufferedReader(new FileReader("filename.txt"));
      try {
        String line, separator = System.getProperty("line.separator");
        while ((line = in.readLine() != null) {
          out.append(line);
          out.append(separator);
        }
      }
      finally {
        in.close();
      }
    }
    catch (IOException ex) {
      ex.printStackTrace();
    }
    doSomethingWith(out.toString());
  }
  public static void doSomethingWith(string s) {}
}

This is just ugly and I don't even know if I works because I hacked up from memory without actually testing it. Now compare that with the following C# version of the above code:

using System.IO;

class FileExample {
  public static void Main(string[] args) {
    string result;
    using (StreamReader r = new StreamReader("filename.txt"))
      result = r.ReadToEnd();
    DoSomethingWith(result);
  }
  public static void DoSomethingWith(string s) {}
}

Not a single try/finally. using automatically does the right thing because the StreamReader is an object implementing IDisposable which means that after the using block C# will automatically call r.Dispose().

All the libraries I played with so far (that are the System.* ones, GTK#, Dbus and many others) are using the language features like they should. Properties are used where wanted, all public namespaces, classes, methods and properties are named in a consistent way and attribute classes (a special feature somewhat comparable to decorators in Python) are used where useful (for example Dbus). That's a consistency in the core libraries you won't find in Python! It's really a pleasure to work with that because the code looks nice and there are few surprises when looking for names.

Of course there are problems too. The documentation for Mono is still lacking but you can help yourself by using the MSDN one. In general the Mono documentation is a lot better than some other open source projects.

The progress Mono makes is astonishing. They may not be as fast as Microsoft but the majority of the features work and even if we wouldn't get any new it would be a great development platform. It really doesn't matter if Mono can't keep up with Microsoft's .NET. The linux community isn't very keen on Silverlight anyways and besides Silverlight not many non-mono applications will hit the average Linux PC. The goal of the Mono project is not to run arbitrary Windows .NET applications on Linux but to have a free implementation of the .NET framework. It's saddening that so many people torpedo the development because of FUD or just because Microsoft came up with the idea.

So if you haven't had a look at Mono yet because you've heard so many negative things about it: Forget about that and give it a try yourself. You can't lose :)

Comments

I'm sorry but Mono is dangerous. «Mono also implements parts of ASP.NET, ADO.NET as well as Windows.Forms which are subject to lots of concern from the Open Source community.» You're acknowledging there is some concerns and then you are calling our doubts FUD ? I don't react when I see this kind of posts on Planet Gnome from Novell employees. But on Planet Ubuntu it's different, and I really hope you're just talking for yourself and that it is not an Ubuntu trend.

— Stemp on Friday, August 15, 2008 1:06 #
Prepare for an angry swarm of fanatics now (some will even skip everything what you wrote!)

— Vadim P. on Friday, August 15, 2008 2:43 #
But does it have SQLAlchemy? :)
(Yeah, I know about NHibernate. I'll take a pass on that one.)

— Kevin Dangoor on Friday, August 15, 2008 2:57 #
I should note my previous comment was mostly joking (though I do love SQLAlchemy and would hate to be without it).
Mono is a great project, and I follow their developments because I think there is a lot of good work being done there (and by Microsoft as well) and it's certainly worth watching.

— Kevin Dangoor on Friday, August 15, 2008 2:58 #
I basically agree with you. Mono is great. What I would like to see is a F# compiler for Mono with a better license than the MS Research one. Its not so much C# that has the potential to pull people over to Mono, but the other, more advanced languages like F#, IMO.

— Levi on Friday, August 15, 2008 6:37 #
No, it's not. It's for monkeys too ;-)

— Max on Friday, August 15, 2008 6:46 #
It often amuses me that when I'm trying to figure how to use some .NET class (MSDN suxxors), the mono source code comes up, and I can actually figure out what the damn thing's supposed to do!
Fantastic when trying to subclass and override methods of System.* classes.

— Simon Davy on Friday, August 15, 2008 7:53 #
Hi,
Good article. I've ben following mono for some time, after i switched to OS X as my primary workstation, but i've never really gotten anything done in it, since VIM or MonoDevelop seems really bad at project management compared to Visual Studio.
I use a plugin for visual studio that enables vim-behavior in that editor, so it's not the vim behavior that i'm afraid of.
I guess my request is: it would be cool if you would write up your workflow using VIM to develop with. Do you use the internal make command? any usage of xbuild etc..
Best
Oliver

— oliver on Friday, August 15, 2008 8:48 #
Agree with Vadim...there's far too much politics in software these days. Open source has unleashed a new Taliban, one bent on world domination of open source... but only the open source projects they judge to be worthy.

— Jack on Friday, August 15, 2008 8:55 #
Great post. I didn't know about D or Vala, I will check them.

— menek on Friday, August 15, 2008 9:00 #
You didn't actually address why the valid patent concerns are fud, you just said we can guess at which bits are patented and work around them. Personally i'm not bothering to touch it till they release a version with no patented microsoft stuff in it. It's pretty common knowledge that microsoft hate gpl and think that gpl coders are riding on "their" intellectual property without paying their due, so i fail to see why it's a good idea to start investing large amounts of time in it just because it's got a couple of nice features and microsoft pinky swears not to sue over patent infringment.

— 12dogs on Friday, August 15, 2008 9:18 #
You should really check groovy, it has properties closures and runs on the JVM. As for Java its lacking many features due to backward compatibility (which is a good thing for legacy code bases), hopefully some of those will be resolved on Java 7. I think that the main important thing to remember is that the language isn't as important as the platform, Java is an echo system which includes servers, libraries and other languages , the JVM culture is OOS friendly and that i think is the most compelling reason of all over .Net

— Ronen on Friday, August 15, 2008 9:41 #
"Prepare for an angry swarm of fanatics now (some will even skip everything what you wrote!)"
I would not call people with other opinions fanatics. There are also a few errors he posted.
One I will point out is this statement here:
'No need to write getters and setters from the ground up in fear of breaking code later when code execution on setting/getting of values is required.'
What exactly is difficult or "from the ground up" in ruby to write a "getter"
attr_reader :foobar
or a "setter" method?
attr_writer :foobar
or a combined accessor (setter/getter)
attr_accessor :foobar
?
To me it seems that people of the Java/C# etc.. camp still think that languages like Ruby or Python are hugely inferior to C#. I find this attitude extremely annoying. C# should be compared with Java or D or C++, but definitely not with a language like Ruby or Python.
I even had a long discussion with a Mono/C# fanboy who continued to claim that being able to alter base (or core, if you so will) classes.
"It will break your code!" "It will render big projects to a grinding halt!"
I did in fact wonder what big project he meant because most Mono/C# projects I know of are one-man shows anyway. But I found it interesting that he totally hated being extremely flexible in a language like Ruby.
And this is why I am extremely angry about the arrogance of the C# world. They tout the language as so incredibly strong and cool that I do not know if I should either laugh or flame them.
STOP BEING ARROGANT. That is my request.

— markus on Friday, August 15, 2008 10:06 #
Implementing the IDisposable interface will close all the streams but will not magically handle exceptions, which you are explicitly handling in the Java code. A more apples to apples comparison would be something like this:
<code>
import java.io.*;
public class FileExample { public static void main(String[] args) throws Throwable { FileInputStream fis = new FileInputStream("filename.txt"); ByteArrayOutputStream bout = new ByteArrayOutputStream();
int b;
while ((b = fis.read()) > 0) {
bout.write(b);
}
fis.close();
doSomethingWith(new String(bout.toByteArray()));
}
public static void doSomethingWith(String s) {}
}
</code>
It still is not as succinct as the C# version but it doesn't look as bad :-) ... anyway... this is example is more of an API issue that a language one. I program in Java and C# for a living, I will grant you that C# the language is more elegant than Java the language, but as a platform, Java leaves .NET in the dust... my opinion of course. As for Mono, I agree with you, it is cool, and getting better. I actually develop in Linux using MonoDevelop and deploy to Windows and I'm yet to experience any problems - I don't do GUI stuff though, so my experience may be atypical - my only problem so far is that performance of the Mono XML parser sucks, that is the main reason for not using it in production.

— Jorge Chandra on Friday, August 15, 2008 10:35 #
markus, flexibility comes at a price. Python does not allow to alter base classes either but you subclass it. I think it is for the better, because I'm scared of libraries which patch my classes without notifying me, just because it is possible. Subclassing usually is really a solution that is good enough. You see the same kind of discussion in the JavaScript camp too, with Prototype.js on one side and jQuery on the other.
With Common Lisp you get even more possibilities to do strange stuff. You can start overriding operators, creating new syntax constructs and modify object behaviour using the MOP. These are all useful things, but once you start creating a customized language you don't haveto wonder why nobody understands your code.
Armin, have you tried Nemerle? I'd be interested in your opinion about this. For me it currently sounds like one of the better languages that were designed specifically for .NET.

— Marek Kubica on Friday, August 15, 2008 10:39 #
<i>Mono is a project that will face patent problems in the future because Microsoft will claim copyright infringement</i>
Can I get an edit: you conflate two different forms of intellectual property. A copyright is not a patent and vice versa: the two things are different. Copyright infringement can't reasonably affect Mono because copyright is to a particular embodiment of a creative effort (and Miguel, etc., have not copied outright the MS .Net implementation). Patents may be a threat, because the inventive effort protected by a patent allows you to deny anyone else from making use of that idea. Can you please change your text to clarify this?
If there are patents in .Net which are infringed by Mono, there's the MS-Novell Patent Covenant to provide some shielding. However, it's not clear whether any edition of Mono not supplied by Novell is under the patent covenant (despite the GPLv2). Consequently, there are reasonable concerns about the patents involved in .Net. However, this must be tempered with the status of Mono as the primary implementation of .Net outside the Windows ecosystem which would cause Microsoft to shoot themselves in the foot with respect for cross-platform uptake of .Net were they to place injunctions against the use of .Net technologies in Mono (or editions of Mono not supplied by Novell).
K3n.

— k3ninho on Friday, August 15, 2008 11:11 #
@1: So why is Mono dangerous? I aknowledged that ASP.NET, ADO.NET and Windows.Forms could cause troubles in the future. But nobody is forcing you to use those components. Even without them Mono makes a great development environment.
@11: Because the core components are ECMA specified and as such not problematic. The three technologies I've listed are developed by Microsoft on top of the .NET framework and could probably be covered by patents.
@13: I love Python, don't get me wrong. But I can see the advantages of a compiled language. It happened for me multiple times that an typo ended up somewhere and got lost on the noise of pylint which complains about basically everything :) For bigger projects C# can be an advantage over Python.
@14: For fairness sake I wanted to not handle exceptions anywhere but that's not possible in Java because the readers have exceptions you have to catch.
@15: I had a quick look at it but haven't really got past C# so far. It's a darn interesting language that's for sure, but I'm sort of afraid about programmable syntax.

— Armin Ronacher on Friday, August 15, 2008 11:15 #
Have you looked at boo? Statically typed, optionally ducktyped, macro enabled CLR language with Python inspired syntax.

— Ants Aasma on Friday, August 15, 2008 11:48 #
@13: I love Python, don’t get me wrong. But I can see the advantages of a compiled language. It happened for me multiple times that an typo ended up somewhere and got lost on the noise of pylint which complains about basically everything :) For bigger projects C# can be an advantage over Python.
If PyLint complains about too many things then you have it badly configured. You should configure it to only report problems you are actually interested.
If you don't have tests to catch your typos then you have more problems than just using a dynamic language. The 'layer of safety' provided by a compiled language is very thin indeed.
Having said that I like C#. Python is more expressive and faster to develop with though. Shame we can't yet use .NET attributes from it.

— Michael Foord on Friday, August 15, 2008 13:28 #
I love how Mono-haters like to point at things like Windows.Forms in order to support their FUD about how Mono infringes on patents.
Yet these same people are perfectly ok with WINE? If Windows.Forms infringes on patents, then WINE does as well. In fact, in Windows, Windows.Forms is just a .NET binding around the Win32 API (which is what WINE implements).
They also /conveniently/ fail to mention that Windows.Forms, ASP.NET, and ADO.NET are not core components of Mono. They try to play it off as if it's impossible to write a Mono application without using these 3 components in an effort to play on people's fear and hatred of Microsoft.
Let's also note that Microsoft has not sued the WINE project nor any project using WINE/making money off of WINE, etc so it seems to me that it's not something worth worrying about. If Microsoft were going to sue over patents they have on the win32 API, they would have done it already.
Again, the Mono-FUDers focus on this to spread fear about Mono and do not care about being at all factual or reasonable.
Advice to the Mono-haters: Stop being a bunch of cry babies with nothing of value to say. If you have to stoop so low as to spread FUD about a Free Software project, then you are worthless to the Free Software community.

— Jonathan on Friday, August 15, 2008 14:09 #
Regarding properties, there is one problem with that approach. Properties and public attributes are not binary compatible so code "linked" against a dll which used attributes will not work with a new version of that dll which replaced it with a property. So at least where I work it's a convention to create properties for every public attribute.

— Jonas Wagner on Friday, August 15, 2008 15:18 #
"favorite feature after properties is definitively that you have to make methods virtual explicitly. This enables faster code and hides a lot of errors."
Auch, I would love .Net a lot more, if it wasn't this way. First off, a jit can figure out which methods it can optimize without them being non virtual. So the "enables faster code" is likely to be false, actually very false, because now any virtual method is bound to be slower in such a system, and you use virual a lot. (Optimizing virtual methods require you can rewrite stack frames, which the .Net jit does not do (afaik), and without this, it cannot optimize virtual methods the same as non virtual. Java can.)
Second, the "hides a lot of errors"; not sure which ones? The ones where you didn't anticipate me needing to override your library method? So now I need to either patch your library, or work around the fact you thought non virtual would be faster?
Final methods are made final, because any attempt to override them would fail, at least that is the premise in Java. Just marking lots of methods final for no good reason is bad practice, and disables reasonable use of the code, just because it wasn't forseen you could/wanted to do that...

— Onne on Friday, August 15, 2008 15:19 #
Oh, forgot to say. Totally agree with all other points; I think .Net (c#) is just much more pragmatic compared to Java. They certainly move a lot faster ;)

— Onne on Friday, August 15, 2008 15:27 #
Mono is a great product, and I've been consistently amazed at their ability to match new features in .NET -- not without tiny incompatibilities that occasionally cause me a lot of grief.
Python and Mono are my two primary programming environments, and I wouldn't have it any other way.

— Michael Greene on Friday, August 15, 2008 16:42 #
> If Microsoft were going to sue over patents they have on the win32 API, they would have done it already.
Why would they do it now when there aren't very many fundamental Mono applications? If I became unable to use Mono, all I would lose is F-spot. It would be a shame, but hardly irreplaceable. But if they waited five years or so before pulling their patent portfolio out, it's possible many more core parts of GNOME would be threatened. They would have a lot more to gain at that point assuming Mono gets a lot of uptake.

— Phil on Friday, August 15, 2008 19:36 #
Armin, you mean macros? Well, they do sound a little bit scary but powerful macros (not that what C uses) worked quite well for decades in Lisp. This enables some really nice metaprogramming. The Nemerle example in the Wikipedia reminds me a bit of syntax-rules in Scheme, that is pattern-based macro expansion which is relatively easy to grok.

— Marek Kubica on Friday, August 15, 2008 20:24 #
Sometimes I wonder if Microsoft allows Mono's existence just for the fun of watching the open source community gnaw at itself over this issue.

— Istarex on Friday, August 15, 2008 20:29 #
You mention IronRuby and IronPython. Don't forget there are many languages available for the JVM as well. Scala, Nice, Fan, Groovy, Jython, JRuby, Pnuts, Rhino Javascript, ... the list is long and most support the nicer features of C# that you mention. Neither the .NET or JVM languages are advanced enough to really be used together seamlessly. For example, you can't extend a Jython class with a JRuby class and call methods on an instance of that class from Scala expect things to work well.
Back to Mono. My biggest gripe is that Novell has to reimplement all of the system classes and will always be behind Microsoft. Not only that, they will never achieve 100% parity with the MS classes. Why do this? Wouldn't the effort be better spent working with Sun to get features into Java and the JVM (like delegates, properties, and LINQ) that would move the entire Java eco-system forward on Windows and Linux? Especially now that Sun has now released their code under an open source license. Grr.

— Kevin on Friday, August 15, 2008 20:31 #
It's also worth noting, in the patent field, that a patent on C# technology can very reasonably be infringed by Java or Python if it's so written. Saying that Mono might be infringing patents is no more or less true than saying Apache might be infringing patents. If you're going to worry about that, you'll need to do a patent search no matter what you're writing.

— Darren on Friday, August 15, 2008 20:56 #
Mono has native GTK+ integration via Gtk#, if you are developing on Linux you should NOT use Windows.Forms anyway.
ASP.NET is over engineered crap and I wish the OSS community would with a more modern web framework built on .NET - this will also avoid the patent issues.

— Joe on Saturday, August 16, 2008 2:35 #
Great post! I love C# for many of the same reasons as you. Something a lot of people forgetis that Novell is a founding member of the Open Innovation Network, an organization with a patent arsenal to use to defend free software, including Mono.
@Jorge: from the C# reference: "The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object."
@markus: There are those of us who can appreciate Ruby's flexibility and appreciate C#'s power and grace. Also, tomboy, f-spot, gnome-do, banshee, beagle, and a host of other Mono-powered apps are way more than one-man shows. I also think you'll find most contributors to those projects not at all arrogant. You might want to work on your ignorance, though - not knowing one Mono app that's more than a one-man show is hilarious.

— Gabriel on Saturday, August 16, 2008 5:16 #
Mono may not be explicitly working on getting random Windows .net applications working in Linux, but they aren't opposed to the idea either. They are, however, actively working on a replacement for the Windows .net libraries within Windows itself, including the ability to run those Linux-incompatible mixed mode applications that use both .net and win32.
What we can do is bind Wine and Mono together - we run the Windows version of Mono inside Wine, and then anything that works on Windows/Mono can then work in Linux/Wine. You can already test this a bit with winetricks and the 1.9 beta releases of Mono. Come time for Ubuntu Intrepid when Mono makes their release, things will be even better.

— Scott Ritchie on Saturday, August 16, 2008 8:10 #
I agree that Mono really needs an F# compiler. Mono also needs a lot more work: even the new GC needs a lot of work and Mono 2.0 is still 3x slower than .NET (from my SciMark2 benchmarks in F#).
I am also surprised to see so few people developing on Mono. The number of registered installs of mono-gmcs on Debian and Ubuntu is only slightly more than OCaml!
When Mono matures, we will gladly jump on the bandwagon and start building upon it because Mono is one of the few offerings in the Linux world that is even capable of supporting a commercial market.

— Jon Harrop on Saturday, August 16, 2008 15:55 #
There's no Eclipse-plugin for Mono. So Mono is completely unusable.

— Lord Uli on Saturday, August 16, 2008 19:56 #
Mono may be great, but it's missing a decent documentation tool... ;-)

— Georg on Saturday, August 16, 2008 22:50 #
Chandra,
You are wrong, the "using" statement will take care of exceptions thrown inside the using block.
Just look at the ildasm output from the sample.

— mandi on Monday, August 18, 2008 5:09 #
I am glad Mono exists, because it allows me to use F# which I would not look at twice if there would be no .NET environment on my Linux machine. What I would like to see is a F# compiler with an open source license. I am a litte worried that once F# becomes Visual F# or something its license will stink even more. But Mono is still nice. Thanks Mono team!

— Nichol Kent on Monday, August 18, 2008 13:01 #
It's funny to see mono fanboys accuse others spread FUD while they cannot participate in a factual discussion.

— NOmono on Monday, January 11, 2010 12:01 #
After reading all this I tried but didn't work for me, may be because I am too used to .Net

— Wajahat on Sunday, March 7, 2010 2:43 #

Armin Ronacher

Mono isn’t just for Apes

Comments

Leave a Reply