There has been a lot of press recently about the Open Source "Mono" project, arguing about whether it is safe to use by the Free Software community, and even comparing it to the project I work on, Samba. Given all this controversy I thought I might as well write down my own thoughts on the matter, and even try and change a few minds into the bargain.

Mono is controversial as it is a re-implementation of Microsoft's .NET technology, in much the same way as Samba is a re-implementation of Microsoft's Server Message Block (SMB) file sharing protocol. The genesis of each project and how they have developed over the years is somewhat different however.

Samba was initially written by the original developers to "scratch our own itch" . It was code that was specifically useful to us, and originally had no wider purpose than that. We have gotten a little more ambitious over the years, but one of our primary purposes is still to write code that's useful to us - or to me at least :-). Witness our development of a UNIX variant of the SMB protocol, which has no use for Windows clients or servers, but is a great way of networking Linux boxes together.

Miguel de Icaza, the original creator of the Mono project, would argue the same for Mono. Miguel was one of the original creators of the Gnome Linux desktop code, and personally wrote some of the large Gnome desktop applications in C. I once asked Miguel why he decided to create Mono, which re-implements Microsoft's C# language and the runtime environment that goes with it, whilst we were stuck on a bus together traveling to an evening event in some godforsaken Linux World event in Boston. "It's simple," he replied, "I'm fed up of writing memory garbage collection code for C applications. There had to be an easier way to write Linux desktop applications than that."

He does have a point. Writing complex graphical user interface (GUI) applications in C or even C++ is hard, with many opportunities for memory corruption, memory leaks or security errors. The question is, why recreate a Microsoft technology for this, when Sun's Java already existed at the time the Mono project was started, and solved many of the same problems.

Miguel and many others argue that .NET and Mono is simply better technology. It's true that .NET is a later design than Java, as it was instigated after Microsoft was unable to wrest control of Java from Sun by creating a Windows-specific version of Java (a lawsuit promptly settled that). Also, at the time Mono was started in 2001 Sun had yet to release Java under a Free Software license, forcing Free Software developers to have to re-implement the Java technology if they wanted to use it openly.

But I'm not buying that excuse. Miguel and the other Mono developers are smart enough to have made Java do what they needed, even if it would have required creating Gnome-specific wrappers for the Gnome GUI. After all, this is exactly what they're doing for C# and Mono. No, I'm guessing it was simply the old Open Source/Free Software disease of being unable or unwilling to cooperate with existing developers who are doing something similar to what you have in mind. Much easier to start your own project to do something similar, after all that way you have complete control over it. And if you believe that by developing Mono you will get Microsoft Windows .NET developers to move their code over to Linux then you can even claim the moral high ground.

But the problem is that Mono is dangerous for Free Software. The heart of the matter is, as usual, software patents. Microsoft have patents on the technology inside .NET, and since the Tom Tom lawsuit, Microsoft have shown they are not averse to attacking Free Software using patent infringement claims. Microsoft have tried to allay some fears by putting the .NET specification under their "Microsoft Community Promise" which you can read here:

Miguel hailed this a the solution to all the patent problems with Mono. But this promise is simply not good enough to base a language environment implementation upon. After all, if the rug is pulled out from under that implementation by the threat of patent infringement you don't just lose the implementation itself, you lose all the programs that depend upon it. That's a really dangerous situation for Free Software programs to be in. The Free Software Foundation wrote a good analysis of the problems with this promise here:

But my basic issue with the Microsoft Community Promise is that Miguel doesn't have to depend on it like everyone else does. Miguel's employer, Novell, has a patent agreement with Microsoft that exempts Mono users from Microsoft patent aggression, so long as you get Mono from Novell. Miguel takes pains to point this out. This is not a level playing field, or software freedom for all. This is a preferred supplier trying to pretend there is no problem. Sure there isn't a problem, for them. If it isn't good enough for Miguel, why is it good enough for other developers?

I'd like to contrast this with the agreement that Andrew Tridgell negotiated with Microsoft for Samba over the very same issues of software patents covered in a specification. You can read an overview of the agreement here:

I can't say anything better than Andrew's own words so I won't try, I'll just call attention to them here: "For me, one of the key things about free software and patents is that we are all in the same boat. It is vitally important to the continued success of the community development model that one part of the community does not enter into an agreement which gives some people patent protection while leaving other people out in the cold. That is why I was so opposed to the patent agreements recently entered into by Novell, Xandros and other companies."

This agreement is available to all willing to affiliate with the Protocol Freedom Information Foundation (PFIF) and provides implementors with a limited number of Microsoft patents that may be asserted, and clear and timely warning if new patents are added by Microsoft.

This is at the heart of why Samba is different from the Mono project, at least in terms of how we view software freedom for all, and how we dealt with patent threats in the implementation. If Miguel and the Mono folks had been so careful when negotiating with Microsoft, and just a little less excited about the cool new technology, then I think they'd have done their users a better service.

Lest I get tarred with a reputation as a hopeless Luddite, afraid of new technology just because Microsoft developed it, I do want to say that I think Mono is pretty amazing work. If Microsoft could see their way to issuing a patent promise that was acceptable to Free Software developers I'd happily see it as a core part of any Linux (or GNU/Linux if you wish) distribution. I actually do use a Mono application to index all my personal photographs, the very capable F-Spot. I prefer it to the alternative of Google Picasa because at least F-Spot is Free Software (and yes I've reported bugs in F-Spot by looking at the code :-). But if I had to give up F-Spot due to patent threats I could, because all the picture meta-data it indexes is stored inside the photographs themselves. So even if I lost the use of F-spot I wouldn't lose any photograph data, just the time needed to re-tag and
re-sort the photos. Annoying, but not a fatal loss.

Just like installing programs to play the patented MP3 format, this is a risk some Linux users are willing to take. But this should be the users decision, not an accident of it being a default application in a distribution. Most distributions have a way to manage patent risk, by separating out the Free Software that may have patent problems into separate downloadable repositories that are not enabled by default. People in counties with software patents and willing to take the patent risk can then enable the repository and download the patent-covered software themselves. I think it is time for the Mono implementation and applications that use it to be moved into the "risky" category, until the patent situation around it is deemed to be truly safe to use by default in Free Software.

Microsoft isn't playing games any more by merely threatening to assert patents. Real lawsuits have now occurred and the gloves are off against Free Software. Moving Mono and its applications to the "restricted" repositories is now just plain common sense.

Jeremy Allison
Samba Team.
San Jose, California.
11th October 2009.



> Witness our development of a UNIX variant of the SMB
> protocol, which has no use for Windows clients or servers,
> but is a great way of networking Linux boxes together

Can you point to what you're talking about please? This sounds interesting but I am not aware of any 'non-Windows Samba' :)

Thanks for the article, I think that you hit the issue dead on: Mono is a threat to Free Software due to patent issues. I am not sure why this is so hard for some to recognize.

unix extensions

Check "unix extensions" in man smb.conf


Samba has a couple of extensions that only make sense for unix-systems talking to each other, like showing the unix-file-permissions(and owner and group).

An additional point to consider....

Great article! Thanks for posting. I would like to add that in addition to the 2 points you have above on possible intent there is also a 3rd motivation which might help explain the way things have been conducted. From some of the comments made by Miguel one can perceive an underlying frustration: "Now that I've learned how to program and do all this neat computer stuff and made a name for myself how do I make money with open source?" That we have to work to support ourselves is not an all together unrealistic thing to understand but how does one reconcile it with the purpose and drive and goals of the open source community? That seems to be where enlightenment is needed and where he has been getting it wrong.

I have been using Samba for

I have been using Samba for Unix to unix networking for a while in situations where I am going to have a server likely to be going up an down a lot. Samba just recovers from that sort of thing a lot saner than NFS.

Because not everyone cares

Because not everyone cares for software patents, as you take risks with every technology you use, and Microsoft is more harmless than a patent-troll. Maybe you've never read about the Kodak patent Sun was sued over (losing 1B USD).

And also, not every open-source supporter or contributor cares for Free Software.

If you care so much, make your own distribution that's free of all
"evil". But leave the rest of us alone, please, as we should be free to make our own choices and decisions. Public insults and harassment makes open-source software look a lot worse than some patent threats that have yet to be found or proven valid.

Thanks, documenting Mono

If anyone can help documenting the problems and listing the good articles about Mono and patents, help is very welcome on this public anti-swpat wiki:

CiarĂ¡n O'Riordan

Very informative

Great article. Thanks for sharing your perspective. This is an important issue.



It is nice to see a clear headed description of the angles surrounding this hot button issue.


Very Precise

This is one of the most compelling articles I've read on Mono vs No-Mono..
Thanks for posting this great resource!


Thank You! Very well said.

Thank You! Very well said. No one wants to restrict the Mono people from scratching their itch. Scratch away! But as you said, until Microsoft ceases their battle plans against Linux and Open Source and states clearly their intentions to not pursue lawsuits that might involve Mono I don't see any other way to approach this. Put Mono apps and libraries in restricted as you suggested. That is both fair, to the Mono people, and smart for the rest of us.

Very clear and well written

Indeed the expressed approach is by far the most well thought and written article upon a rather controversial subject: The .Net implementation of Mono is definitely in desperate need of a totally free, in terms of patent claims, environment on behalf of Micro$oft.


Nice Piece

One of the better arguments in this debate. I do wish Java were used more. As a language, C# has some definite advantages, but the Java platform and surrounding open-source community are more mature and useful.

Mono and all that

The way I see Mono It's like having de Icaza design a beautiful 50 feet wall around Berlin and issue a statement:

Don't worry - We got a fantastic designer - de Icaza - to ensure that the wall is completely safe to pass through and he got his very good friends - the Novells - to build 10 gates you can pass through safely.

Psst! The Novells got copies of almost all the keys and they'll make sure you'll get in and out whenever you want.

The Novells live next door to the big bullies and they are even friends - just relax! They are REALLY friendly with the bullies you see - the bullies even provide concrete. For free!!

Ain't that nice?


mono and all that

Beautifully said, a (texted) image explain better than words!. Keep on trucking!. Reine and Poutou the dog.

Write More Often

As usual, great article and to the point. It is nice to have some fresh air on the net. Please, don't be a "stingy" and try to write more often.


I looked and looked, and have not found any single thing about Mono that seems like "really amazing work". Certainly, cloning C# was a lot of work, and there must be some cleverness in how they went about it, but the end result seems not only entirely uninteresting, but a big step backward. The VM approach was invented to solve a problem we, in Free Software, and for many interlocking reasons, have gone to some pains not to have. The result is that programs executed by Mono are noticeably slower and more resource-hungry than the same program written in a less compromised environment.

Meanwhile, the language itself is hardly any better than Java, which was itself hastily and badly designed, along any axis you choose to examine. The problem that Miguel says led him to Mono, memory management, doesn't even exist in C++; programmers may go for years without coding a "delete" statement in C++. Not only does Free Software not need Mono or Java, it would be measurably better off without them.

Another de Icaza initiative, Bonobo, also copied from Microsoft, is actively being written out of Gnome, at substantial expense. We can only hope that there will not be too much Mono code left around to be re-implemented in a more long-lived and better-designed language, once Microsoft moves on from C# and everyone recognizes what a mistake it was. Mono is not neutral, like most ill-conceived projects, that simply languish in repositories absorbing the attention of people you wouldn't want on your own project. It's an active drain on Free Software, a kind of sabotage.

Nathan Myers

Don't forget Vala

While still at an early stage, Vala is an excellent solution de Icaza's problem and it has required (and will require) far, far less heavy lifting.


these arguments are tiring to read. OF course MS is out to make a buck. I love the fact there is mono on linux, a nice cheap platform for me to deploy my C# apps if I don't want to use Windows for something. Putting it in a default desktop is really dumb unless your intentions are to help MS in the long run. Not sure what is so difficult about all this but people keep beating the dead horse's skeleton laying in the brush that became a jungle.

I came to Linux a few years

I came to Linux a few years ago simply because I did not like the direction m$ had with their software and OS -- and I grew tired of spending so much money upgrading just to remain compatible with other businesses. Linux was like a breath of fresh air.

I don't like Mono because I think it is dangerous. If I wanted to use m$ technologies I would have stayed with them. First thing I do when I install a new distro is purge everything related to mono then install GTK alternatives.

If m$ truly cared about the linux community they would have ported .NET to linux. They didn't.

Java is not the best example

While I entirely agree with your argument it should be pointed out that java is not the best choice to use as an example. Sun took a very long time to Open Source all of java; in my recollection Java became entirely free long after mono was implemented. This does not invalidate your argument. There are many other fully Open Source modern languages that support garbage collection to choose from.

Karl O. Pinc

There's still a difference

Rather than reimplementing Microsoft's proprietary language and runtime they could have reimplemented Sun's proprietary language and runtime. So what's the difference and why would Java have been a better choice?

Simple answer: Sun does not have a history of persecuting open source, nor a history of anti competitive behavior.

Jave *is* a good exemple

Even though the open-sourcing of the jvm took a long time, one should not forget :

- a large pool of java floss software existed way before .Net was created (let alone Mono). When Miguel decided to create Mono he also decided to parter with a community with little or no FLOSS contributions instead of a community that was already churning out lots of FLOSS code (in fact one of the major problems in the FLOSS Java world is the way FLOSS application-level code writers drifted from system-level code writers in the long years there were no FLOSS JVM to bridge the gap)

- people tend to agree SUN's hand was forced by the progress of GNU Classpath (ie at one point it was open-sourcing the JVM, and keep some control of the FLOSS java community, or look it migrate in droves to a floss JVM that got good enough for production). So what took a long time is not SUN's open sourcing the JVM, but GNU Classpath reaching a level that let no other palatable option to SUN than open sourcing its software. It is pretty obvious that had Ximian worked with the GNU Classpath project instead of embarking on its MS partnership, the open-sourcing of the JVM would have happened years before.

I agree, but one issue...

Because of the potential for patent unfriendliness, I agree that Mono and Mono based applications should be treated like flash, Widows's codecs, MP3, dvdcss, etc.

However I do take issue with your love fest for Java. You see, AFAIK, when Mono was started, Java was still encumbered in Sun's naughty land. So Java wouldn't have been a good choice at that time either.

My Linux desktop runs flash, uses proprietary Nvidia drivers, plays and RIPS MP3s, plays and RIPS DVDs and plays most all WMV's, etc. And I can pretty much say that if it couldn't do all of that, I wouldn't have a very nice desktop.

Just an observation...

Miguel helped divide the Linux community with the extortion deal

Great article.
I have read Allison, Bruce Perens and Glyn Moody write excellent articles explaining why Mono and Samba are not in the same boat but the Monoists use it all the time.

"Miguel's employer, Novell, has a patent agreement with Microsoft that exempts Mono users from Microsoft patent aggression, so long as you get Mono from Novell. Miguel takes pains to point this out. This is not a level playing field, or software freedom for all. "

Miguel is VP at Novell, not a simple passerby. He has been privy and part of the MS extortion scheme and as a Red Hat user, I am reminded by the person who signs the checks that I owe MS money because the distro I use is using stolen IP and that Novell's is the legal and safe Linux to use:

Microsoft is the ones going around and telling us that it would be a shame if something were to happen to our little bakery and that paying them would keep us safe but Novell (and the VP along with it) is sitting in the car outside.

I may not agree with many people in free software but what is good for Fedora is good for Mandriva or Kubuntu because were in the same boat. We all benefit from enhancements and improvements.
MS/Novell have tried to change the playing field and NEVER have I heard Miguel say one thing about the rest of us who arent protected by their covenant.
FOR THAT reason alone, I say Miguel is a traitor to all of us.
He did what was good for Novell and didnt care if the rest of us got screwed in the process.

Im not going to waste anyone's time rehashing the case against Mono, its inclusion into Gnome (im not talking apps but infrastructure) or even Miguel's Redmond and NET obsession (wasnt it his dream to see Gnome based entirely on NET?) because I think this line by Jeremy sums up best what Novell did to free software:

"This is not a level playing field, or software freedom for all. This is a preferred supplier trying to pretend there is no problem. Sure there isn't a problem, for them."

But why the hardon for F-Spot when DigiKam is absolutely brilliant?
Even with a heavy bias towards one you cant tell me that it would be too difficult to use another program? I've used both and while I think that Digikam is in a class apart, its not the end of the world when im using the other on someone else's computer.


That's the joy of the environment we use. I prefer F-Spot. You can opt for Digikam. As an aside, F-Spot stores the meta-data in an sqlite3 DB file, so migration is possible (including tags). In fact, I have done this myself, going from Digikam to F-Spot. Being open-source, you can peek inside, understand the code and your data is your own.

James Plamondon said it best....

The Combs vs Microsoft trial released documents that revealed Microsoft's game plan:

"Evangelism Is War

... Every line of code that is written to our standards is a small victory; every line of code that is written to any other standard, is a small defeat. Total victory ... is the universal adoption of our standards by developers, as this is an important step towards total victory for Microsoft itself...."

MONO can NEVER be on par with the latest release of .NET so it will always be behind in capabilities. All Microsoft has to do to isolate and destroy MONO dependent applications, desktops and distros is to release a proprietary EXTENSION that is not under the ECMA 334 or 335, and then make all .NET applications dependent on that extension. That EXTINGUISHES all apps, desktops or distros dependent on MONO. The strange part of that trilogy is that certain Linux users will have performed the EMBRACE themselves, which is certainly a form of suicide.

The Ubuntu Technical Board rules on June 29th that future remixes of the Ubuntu desktop will be dependent on MONO. Since MONO is dependent on .NET and Microsoft controls .NET, that means that Microsoft controls future Ubuntu desktops if one cannot remove mono-runtime or without breaking Ubuntu/GNOME. Every Linux user KNOWS what "dependency" means, or worse, what broken dependencies mean.

Much is made of C#, memory management, and bindings to GTK2+ gui frameworks (because it was belatedly revealed that MONO frameworks were not under the ECMA 334 & 335) but that is like saying "With MONO and $1.50 I can get a cup of coffee". Besides, there is a widget set released under the GPL which allows memory management, garbage collection and automatic pointer deletions and it has a FANTASTIC, well integrated user GUI component... Qt4. And, it can be installed from most distro repositories with a single click, along with its fantastic gui rad tool, QtCreator. It has no hidden IP traps or law suite threats. And, Neither Trolltech nor Nokia have tried to secretly sell IP to patent trolls along with instructions on how to sue Linux vendors and users.

work around

I disagree. when it came to SCO, even Linus said, the patent come to light, we make changes to the kernel, in weeks, and ... no problem. I believe the same is true for Mono. Also some of the things that may be patent issues are coming up to 11+ years in use, so if MS wants to act, they better do it soon. Mono is probably more in the clear from patents then Linux is, that doesn't justify the Mono position, but, even Java isn't free of patent issues... not sure the state of the kodak claim,but if Sun wasn't able to settle?
bottom line is 99.999999% of mono stuff isn't touchable by patents, and if a patent war breaks out, mono will take the Linus approach, and just adapt.
no problems here mate.

-mono user


Why does one suppose they would pay turfers to come post here if there were in fact no problem?

Patenting API

>> bottom line is 99.999999% of mono stuff isn't touchable by patents

How do you bypass a patent for an invention (ie, for an application) "that uses runtime support of which the mono specification would be a subset and where the invention indexes the user's files?"

In other words, the patent is a patent about indexing files in some ordinary way (remember how obvious "one-click" was) but where the invention (ie, the app) also has certain properties which parallel key mono properties.

How might we bypass such a patent?

We can't do the indexing and use mono since that would violate.

Alternatively, we could do indexing but change the mono-ish part. The problem here is that we won't learn of the patent until various such apps exist. At that point, changing the mono-ish part sufficiently may mean redesigning much of the application if these mono-ish parts are implemented automatically through standard and pervasive dotnet API.

Alternatively, we can simply not do the indexing, but this might be a huge barrier to building an efficient app.

Conclusion: As long as we do mono, we leave behind a series of apps, all of which might have to be redesigned to avoid mono-ish parts (that might be in the patent), AND we yield this upper hand and control to -- of all companies -- Microsoft, a company whose business model is severely threatened by FOSS because they rely on monopolies and closed source lock-in.

Fortunately, the FSF and others argued that the US Supreme Court has basically already shun software patents, even if the lower courts have not, and can formalize this with a new clearer ruling.

I am optimistic.

>> , and if a patent war breaks out, mono will take the Linus approach, and just adapt.

Linux is not based upon Microsoft invented API.

Microsoft invented API mean Microsoft has the upper hand (insider access) in developing patents built upon those API and upon common extensions of those API (eg, "indexing a hard drive" AND being mono-ish).

-- Jose_X

Quite. For example, if you

Quite. For example, if you want to see something really evil, take a look at Microsoft patent 6,951,022. This covers using delegates for event handling in a specific way - more precisely, according to Microsoft's C# programming guidelines. Since you don't have to use delegates and events in this way in your own code, doing so isn't covered by Microsoft's patent promises - but lots of code will do it this way, because it's what the guidelines suggest. In particular, Gtk# thoroughly infringes on this particular patent.


I think that the Gnome-Java bridge was long builted before Mono came about. Miguel was never interested in the JVM like the .NET VM.


And you suggest using Java, why? Java who don't have any support for native widgets (if you can call GTK that), and the worst UI model of any framework of the last decade?

C# is a superior language, and .NET a superior framework, and yet you people babble with your politics and evangelism, rather than being pragmatic, and making tools who solves problems.

The amount of shitty C userland apps for Linux is amazing, and puts the general experience in the system a decade back.

Userland software development for Linux is a pain, it's so horrible much more annoying than developing for Windows based systems. Try get out of your kernel API hacking and write software with non-powerusers that have to use them. You might learn something.

In reality, Mono is good. Without it Linux wouldn't be a platform worthy of considering software deployment.

We're wasting enough time and money developing for 1-2% of the actual users. Forcing us to waste even more time by going in a religious war against Mono isn't just stupid, it's retardation on a high level.

If Microsoft is evil, I'd rather be in Hell with Microsoft and Novell, than with in heavens with Stallman and friends.

Software developers care little for politics. How hard is this to understand?


Sorry, but if you're gonna troll, try to be more subtle.

You're leaving Mr. Ballmer without anything left to say!

Please be more considerate... sheesh, people these days...

Mono useful to Microsoft/Novell. Not terribly useful to others.

>> Userland software development for Linux is a pain, it's so horrible much more annoying than developing for Windows based systems.

You are a fool if you think this is true AND mono solves this problem.

If you like mono feature X, just build that into a tool. There is no need to copy the precise exact way in every detail possible of how Microsoft implemented something.

Developing apps with FOSS is not a RAD exercise if the intent is to develop the best app possible. Costs are distributed. It's not too smart to sacrifice efficiency to save a few days of time. I am almost certain that Microsoft and most software houses do use C and C++ and assembly language quite a bit (note Microsoft's affinity for x86 arch). I think Microsoft's own testimony in the past has been that they want most users tied in to their API and heavy frameworks.

But again, there are many tools that exist and can be built to improve the correctness and overall quality of apps without having to resort to any specific method (eg, "mono").

>> Without it Linux wouldn't be a platform worthy of considering software deployment.

Don't make your allegiance to Microsoft that obvious. It destroys your credibility.

Are you aware of how much code has be written for and deployed on Linux and which does not use mono?

Why is Linux uptake continuing to rise and gain convert devs if it's not worthy of software deployment? Most people deploying Linux and coming to it are not using dotnet/mono.

Ask the London Stock Exchange why they dumped dotnet for Linux? [And they did not chose mono. Not to mention that the best dotnet environment is MSdotnet.]

There are a number of reasons why desktop apps have lagged server apps in Linux. The solution has nothing or very little to do with mono.

>> If Microsoft is evil, I'd rather be in Hell with Microsoft and Novell, than with in heavens with Stallman and friends.

Why do I get this feeling that you are?

Microsoft and Novell benefit from the spread of mono, that's for sure.

>> Software developers care little for politics. How hard is this to understand?

Not sure what you mean by "politics".

Many care for freedom from patent problems.

Many dislike abusive monopolies. Why promote the technology of abusive companies? If there is anything of value, use that, but don't spread frameworks on which they have so much invested and have such clear advantages.

Many dislike companies trying to bypass the intent of the terms of the licenses they have chosen.

>> In reality, Mono is good.

There is a huge list of users that think this.


I'd suggest not using the API/standard created by the company most hostile to FOSS. Certainly, this would be a stupid move if you care about FOSS and as long as software patents are a problem. [See my earlier comment about extension patents.]

Of course, if one were getting his/her money by way of Microsoft or had dotnet patents, then perhaps I can see how one would like mono to spread.

Politics is required for pragmatism

The terrain of Free Software development is political. At the theoretical level it is political because Free Software is a political concept. At the practical level it is political because Microsoft and other proprietary software producing corporations are engaged in a power struggle to control markets which operates at overtly political levels, from lobbying legislators to change laws to packing standards bodies--and they see Free Software as a player in that power struggle, a threat to their control.

Free Software is in politics up to its neck. Pretending otherwise isn't pragmatism, it is being an ostrich.
I notice that every time someone claims that thinking about politics isn't "pragmatic", the reason they give always seems to boil down to "I don't like politics so I don't want to think they're important". Well, I don't like looking both ways before I cross the street--I'd rather keep on reading. Doesn't make walking across with my nose in a book "pragmatic".

Re: *sigh*

> And you suggest using Java, why? Java who don't have any support for native widgets (if you can call GTK that), and the worst UI model of any framework of the last decade?

Binding to any native widgets library can be built in Java. You don't have native widgets support (GTK+) with java, somebody can create it using JNI. And last time I checked, there is a java binding for GTK+.


>>Miguel and the other Mono developers
>>are smart enough to have
>>made Java do what they needed

Seriously, what java apps are you using? True, if they worked hard enough they "could" make java work. Hell, with sufficient effort Tk/perl would work. Based on my experience with both runtimes I'd have to say java is a lot more trouble than its worth. If not mono, I'd prefer to just use C++.

Worth noting, the IKVM support in mono provides a convenient environment for C# java interop.

Limited patent protection is no protection

I couldn't add anything to this article other than the words:

Give me complete patent protection or,

sudo apt-get remove --purge mono-common libmono0

Assume for the sake of

Assume for the sake of arguments you are correct that Miguel could have made Java serve his purposes, although I believe you are not correct there. I'll explain why at the end.

Then the question we must is ask is how come when Miguel went the Mono route, those who find Mono unacceptable didn't go ahead and turn Java into a first class environment for developing Linux apps? By first class, I mean apps that fully fit in with the Linux environment, allowing access to all features of the OS. Mostly all I see of Java on Linux are apps that are meant to be cross platform. Mono, no the other hand, is an excellent vehicle for Linux apps.

As for why I think you are wrong on Java being a viable choice for Miguel, first C# had several significan language advantages over Java. In response to those, Java eventually added most of them, but I think that happened after Mono got off the ground. Second, for a long time, all the free (speech, not beer, yadda yadda) versions of Java sucked, if I'm remembering my timeline correctly. The only Java that worked well on Linux was the Sun verson, which was not free, so there was no chance that the cool features Java lacked that C# had could be added by the community.

Assume for the sake of

Those who found mono inacceptable had were less interested than Ximian about the desktop. They'd probably have helped a non-controversial desktop effort (based on java, or python, or any non-MS stack), but the .Net choice made that impossible.

(Also conversely Mono is still nowhere outside the desktop, even compared to the mass of non-desktop floss code that existed when Mono was launched, and ignoring all the new code written since. And this is not something to spurn when every DE is racing today to integrate the web in its apps and either repurposing or rewriting server code. Had Ximian chosen a tech compatible with server-side coders GNOME could just have just used server libs years ago instead of discovering it needs some equivalent today)

The great successes of GNOME were built one contribution at a time by many entities, none of which would have spearheaded a desktop effort alone, but could contribute to a code pool they felt were safe and not under anyone's sole control (that's probably also true of the kernel, xorg, and most FLOSS successes).

The huge mistake about Mono was thinking some language feature were worth giving up on the common safe pool concept. And in fact after years of relentless Mono promotion Miguel has been unable to construct this common safe pool. While the language features have been added to Java.

Community building is harder than code.

I really can't believe this

I really can't believe this blog! Go to the mono website and you will see "Mono 2.4 is our gift to the world." Mono is bringing software developers with .net skills to develop or port applications to Linux. Mono has enabled me to move some of my apps and develop new ones for Linux. I have developed applications where the same binary works on Windows and Linux, and most likely OSX! People in Linux have to stop bitching and complaining about everything if they want Linux to succeed!

If we didn't care about freedom....

If we didn't care about Freedom we'd all be using Solaris.

Is it any wonder that an attempt by the Microsoft/Novel cabal to do an end-run around the Free desktop irks some members of the community? If we wanted to be under Microsoft's thumb we'd be using Windows.

Name them

Which glorious apps would that be?

The only decent crossplatform apps I know are:
* Firefox
* Transmission
* Azureus (used to be pretty good, haven't used it since started using Transmission)
* Eclipse
* Netbeans
* Google Chrome
* Opera
* Pidgin
* Skype
* QtCreate/QtDesigner/...
* Adobe Acrobat Reader

Notice the lack of any .Net based app in the above list. Only C, C++ and Java apps.

And now, please name _any_ decent .Net apps which runs on Windows, Linux and MacOS/X.

Good title

Thanks. That's a well written post, and coming from one so well regarded in our community I'm hopeful it will not end up in the usual flamewar and ad hominem we have had in the past.

PS - I'd used "monomania" too:

mono will be good

mono serves and promotes a CONVICTED monopolist's interests and Judas Novell is helping them.

There's is too much talk regarding how "good" is and we should accepted as default installations. WRONG. It belongs to the garbage of history on how Microsoft is trying to divide and destroy the Community. Novell is a proprietary software company who has said NOTHING regarding software patents lately.

mono will be good, the day is realeased under the GPL v3. That day indeed pigs will fly.

We need to update what fair-use means.

The present situation is deplorable. A patent holder can sit on his backside while you invest $millions, then attack you after you are so far into the project that you can not back out. Then the patent holder extorts huge sums from you without having done anything himself except to wait like a nasty spider for a fly to come along. I say that there should be some conditions that must be satisfied before a patent can be enforced:

1. The patent technology must be in active technological use or development by the patent holder. This means that the holder must actually use it and not simply hold on forever. (The "Use it or loose it" clause)
2. The patent holder can not collect if it knew of the alleged infringement for at least 1 year prior to filing a claim, unless the holder has sent a notice to the "offender" in that time. (The anti-submarine clause.)
3. If patent holder claims infringement their patents then the "infringer" has the right to demand that the holder disclose the basis for this belief. If the holder does not respond in a reasonable time then the holder is barred from taking legal action. Further, the holder must cease public statements of the infringement or be liable to slander libel suit by the "infringer". (The put-up or shut-up clause).

You forgot clause 1: software cannot be patented, period.

So the one-click patent is fine?


Software should not be patented because of the unfairness of the reward/restriction structure. Very few if any software patents are worthy of even a five year monopoly. This is particularly true when you consider how easily it is for those with money and a desire to write patents instead of code to be able to block off competitors doing better work. The bias against those producing prior art but not writing up the time/money/ethics costly patent application is disgusting and obscene.

There are many ways to help those that make great contributions without hurting them and most others a lot as we give 20 year monopolies to people completely undeserving of such things.

You can't copy/paste part of an existing physical skyscraper in order to build your physical "flying skyscraper" (certainly not within seconds and at near $0). Software on a computer is nothing like real inventions.

[Don't read the above as a supposed justification that "real inventions" deserve blanket 20 year monopolies.]

Why is the promise not good enough?

Microsoft have tried to allay some fears by putting the .NET specification under their "Microsoft Community Promise" which you can read here:

Miguel hailed this a the solution to all the patent problems with Mono. But this promise is simply not good enough to base a language environment implementation upon.


re:Why is the promise not good enough?

Microsoft's promise, from the Microsoft website covers ONLY those portions of an implementation that are specifically covered in about three C# ECMA standards. Mono includes a lot more than that. If you strip Mono down to just the standards that are covered, it would not be very useful. Certainly not compatible with programs written for C# - .net under Windows.

Half dead is not the same thing as healthy. Half pregnant is not the same as not pregnant. Miguel is trying, and keeps assuring us that everything is rosy, but I'd still wait a year or two to jump in that pool. YMMV.

It's Linux, so we have the freedom to choose, thanks to Mr. Stallman and friends. ( Thank you Jeremy too!)

For myself, I am firmly in the 'wait and see' camp.

There are three parts of

There are three parts of Mono.

1. The parts covered by the standard. Safe because of the Community Promise.

2. The parts the are clones of Windows-specific stuff like WinForms. Not covered by the CP. This is of some concern if you are trying to run Windows apps on Linux, but the primary use of Mono on Linux is to develop Linux apps, not run Windows apps. When developing a Linux app you use GTK#, not WinForms.

3. The parts that are not in the standard, and are not implementations of Windows stuff, but rather are implementations of neat non-MS libraries and language constructs. Not covered by the Community Promise. However, these same kind of things are in other languages and libraries on Linux. If Microsoft has any patents on these, they not only cover the Mono implementation, but almost certainly similar things in Ruby, Perl, Python, etc.

Conclusion: I don't write Windows programs, so I have no reason to fear patents if I use Mono to write Linux programs.

Gtk# infringes at least one

Gtk# infringes at least one Microsoft patent (#6951022) thanks to being .Net-based, and probably more. The fact that Microsoft designed .Net gave them wide latitude to lay patent traps for people writing code for it. This is especially true when the code is a replacement for a Microsoft-provided technology, even when like Gtk# it's not in any way a clone of the Microsoft equivalent.


Once in a while its to good to read a well thought out piece. Clear and concise. I agree. If there is a sniff of patent threat, then it should be down to the user to use, not the distro to implement by default. At least until the patent wars have been settled (and with that I mean whether patents are useful to software development etc etc).
As to whether java could/should of been used... who knows? May be a better runtime could of been developed instead, now that would of been totally new!
James B.

Mono is dangerous for business entities

If you are a home user, Mono might be relatively safe for you. If you are a business, however, Mono is dangerous for you.

Moreover, any distro that includes Mono in its default install becomes dangerous for you, even if you remove Mono before it succeeds to install. If Microsoft decides to sue you, and you use such a distro, the onus is on you to prove that you never installed Mono. You might be able to prove it eventually, but this will prolong the litigation process, and during it time is a LOT of money...

I had gripes with Debian about it: at .


if Miguel needed a garbage collection why then not use ObjC which is free of patents, already ported to linux, without virtual machines and really stable?

just my 2 cents

Back to top