The Case For Supporting and Using Mono
snydeq writes "Fatal Exception's Neil McAllister argues in favor of Mono, asking those among the open source community who have 'variously described Mono as a trap, a kludge, or simply a waste of effort' to look past Miguel de Icaza and Mono's associations with Microsoft and give the open source implementation of .Net a second chance, as he himself has, having predicted Mono's demise at the hands of open source Java in 2006. Far from being just a clone of .Net for Linux, McAllister argues, Mono has been 'expanding its presence into exciting and unexpected new niches.' And for those who argue that 'developing open-source software based on Microsoft technologies is like walking into a lion's den,' McAllister suggests taking a look at the direction Mono is heading. The more Mono evolves, the less likely Microsoft is to use patent claims or some other dirty trick to bring down the platform."
For bit rates less than 24 Kbps I prefer mono.
(What, RTFA ? Who has time for that ?)
A third party implementation of a standard defined by the first-party implementor is always going to lag behind the original. Even if .Net is technical nirvana, if your platform's only implementation comes from a third party, your platform is a second-class citizen.
The case against Mono has nothing to do with the technical niceties he presents, nor do the fears of Microsoft "pulling out the rug" matter... What matters is that when developers and end users pick a technology, they pick the leader, not the follower. Accepting Mono is giving up and giving in to Microsoft vendor lock-in.
Microsoft has a history of using patents to protect its desktop market share. They attempted to scare people out of using open source software because it supposedly violated 235 of their patents. Therefore, I believe it is prudent that the open source community remain sceptical of Microsoft as well as implimentations of any of its technology including the .net platform.
Sigs are too short to say anything truly profound so read the above post instead.
Mono is in a precarious, teetering position. Somewhere between tepid and antagonistic reaction amongst professional and casual developers, a designer community that is seen as a puppet or apprentice to the hegemony, and not even a clear path forward for compatibility. Be distinct, or be identical, but there's no way to be both.
[
With Qt 4.5 going LGPL in March, one would have to wonder why you would use Mono over Qt or Java.
There are legitimate reasons - the CLR for instance or the multi-language support. But Qt has a Java API if you're addicted to virtual machines, and the C++ toolkit compiles anywhere with a modern C++ compiler. It supports Javascript (QtScript) and Python bindings. But unlike Mono, which is Microsoft derived, there will be no patent worries. Nokia really does want Qt everywhere.
The picture is getting more and more complicated when it comes to software development, and I think that's wrong. I liked .Net as an idea. We could all code to one platform, but the business/IP aspects prevented that technical utopia. I am hoping that LGPL Qt will, while a little more limited be that multi-platform toolkit that everyone can use to solve new problems, instead of continually recoding the old ones.
Slashdot's rate-of-post filter: Preventing you from posting too many great ideas at once.
Ohhh, yeaaah. I remember this guy. This is the same nitwit who used logic from 1996 to try and convince us all to burn our webapps. I see he's back with even more faulty reasoning.
I guess there's only one thing to say. Slashdot, meet the new John C. Dvorak.
Javascript + Nintendo DSi = DSiCade
Now that Java is open source, wouldn't it make more sense to use the JVM as the standard runtime, instead of something that "might" not get sued for copying the .NET runtime?
Java has already been made to run on .NET. I wonder if it'd really be that hard to get standardized C# running on the JVM?
With Mono you can run C# code (even WinForms) not only on Linux, but also MacOS and it seems also on Solaris (http://codicesoftware.blogspot.com/2008/12/plastic-on-solaris-10.html, http://codicesoftware.blogspot.com/2008/12/opensolaris-and-mwf.html). The only thing they miss is a decent debugger on all platforms (currently only on Linux). It's unfortunately not easy to develop on Mono right now, but IMHO only due to the debugger. If they had one, more and more people would be jumping into it. Performance is very, very good, close to C/C++, but coding in C# is easier.
Until Mono gets WPF support there isn't going to be much cross-compatibility. Any Windows .NET developer with any sense is writing in WPF already. WinForms is dead.
But Mono seems quite content to ignore WPF for now. One can't help but think it was part of that Novell/Microsoft deal.
The subset of WPF in Moonlight is useless for non-web development. It's great way for MS to pretend their Flash-killer format is multi-platform though.
Sorry, I will never trust Microsoft enough to put them in a position to control a key technology. So that means there is no discussing the issue as far as I'm concerned. There is NO rational basis to argue. I don't trust em.
And I don't trust the judgement of anyone who isn't themselves suspicious of Microsoft and Miguel's motives.
Mono is a trap if it is allowed to be deployed beyond a browser plugin to support .net content in the browser. Come the day my current distro of choice loses any finctionality when removing the mono packges I'll be running something different as soon as bittorrent can supply me a new install image. Again, that position is 100% non-negotiable. I have used binary drivers in the past, bought closed source apps and committed many 'sins' against the Church of GNU but this is one case where compromise simply isn't possible. They want us dead, you can't compromise with that.
Democrat delenda est
Most people think of Qt as a GUI toolkit. They're not wrong, but that's like calling a Swiss Army Knife a "pocket knife." That's only one thing it does, and the characterization completely misses the point. Qt is an application framework. It fixes every gripe developers have with C++.
Qt promotes clean and well-developed code that is easily ported to Windows, X11 (Linux et al), Mac, and Embedded (Linux sans-X11). That's something even Java doesn't do well (have you ever tried porting between J2SE and J2ME? nothing works!), even disregarding the whole performance loss from the JVM emulation-like interpreting that goes on.
The LGPL relicensing of Qt coming this spring will change the entire programing language landscape. Nokia is moving in to crush Java. C#/.NET and it's mediocre OSS implementation in Mono aren't even on the radar.
I cite the LGPL announcement because that's the kiss of death, placing Qt firmly above GTK (GTK being an incidental casualty on the way to said crushing of Java). With Mono relying so heavily upon GTK#, that puts it behind the game already (the Qt# project is cited on the Mono page as completely dead).
Recall that Nokia is a phone company. They need not make money from the software. Freeing and promoting Qt (and getting it to supplant J2ME) merely feeds this primary function. And while they're at it, they're sweeping in a wonderful set of perks for software engineers in and out of the Free Software community, on both embedded platforms and desktops.
Use my userscript to add story images to Slashdot. There's no going back.
Learn x86, C, Java, JavaScript. EOL.
Anything more is bonus.
Anything less is lacking.
Unfortunately (or maybe not) the truth is 20 years later, to write multi-platform products, the best option is still C/C++...
Then you are a fool.
Axioms of software design:
1. Algorithmic improvements will always trump optimizing execution speed.
2. Unless there is a hard requirement, development time is more important than raw performance.
3. Hardware is cheaper than developers.
4. A rich and flexible library is more useful and stable than custom coding for performance.
Javascript + Nintendo DSi = DSiCade
I used to code Java in the JDK 1.1 - 1.4 days. It sucked ass. It was slow, had weird dependencies on X11, required a lot of boilerplate code (such that up to half of the LOC could be logging inside exception blocks), had various JRE incompatibilities all over the place (such that some applications just couldn't be run bug-free on ALL of AIX/Solaris/Windows/Linux/Mac), and the reference JDK/JRE was Sun's proprietary property. I left Java and went on to C, Perl, C++, and Lisp. Naturally I used Emacs and SLIME.
Then I found Clojure. And I got a $350 laptop from Walmart last week that had 3 gigs of RAM and a single-core 1.8GHz AMD processor. And I thought, "I wonder if Eclipse will run decent on this thing?" And it does, and it's not all that slow, and it is by far the best IDE I've ever used.
I'm now re-climbing the learning curve on modern Java, and it's looking pretty good now. AspectJ does a good job eliminating a lot of repetitive code, eclipse-metrics warns me when I'm not being decent at OOP design, and the available libraries are top-notch. Java the language isn't so bad anymore, and now with Clojure on top I have plenty of linguistic room to prototype and get to choose the best among many paradigms for each situation.
Give Java a fresh look, it's come a long way.
There was a famous story about Sun and IBM that got aired a lot during the MS antitrust trial. It goes like this:
One day, a bunch of IBM patent lawyers show up at Sun's headquarters, saying that Sun is infringing on patents A, B, C, etc. They demand a hefty license fee. Sun engineers (remember, it started as a company of engineers) sit down in a boardroom with the lawyers, look at the patents, and are surprised--they're for various obvious things like mathematically adding a variable stroke to a line, and such. The engineers walk the lawyers through their own patents, explaining how they're all obvious and wouldn't stand up in a court of law. The lawyers remain silent until they're done. Then the chief lawyer says "Perhaps you're right. But after one big court case dragging on for years, we'd just come back with another set of patents and repeat the whole process. Eventually we'd find something that you'd infringed on, and then you'd have to pay damages rather than a licensing fee."
Sun signs a cross-licensing agreement with IBM the next day.
That's the worry. It's not that Microsoft has patents that can allow it to launch SCO 2.0 with a better hope of success. It's the worry that, if they decide to snuff out Mono, they can launch a legal crusade to so encumber Mono in litigation and FUD that it dies an ignominious death. Then all that effort is wasted, OSS and Linux get a bad name in the process, and a lot of developers and customers are soured on Mono, Linux, and anything that doesn't come from a Fortune 500 company. This is why Novell signing a patent cross-licensing agreement caused such bad blood--it implies that MS does have patents that are or could be infringed. On the fateful day that MS decides to crush Mono, Novell's agreement strengthens MS's case, if only in PR terms.
Anyone who loves or hates any language, platform, or manufacturer, doesn't know what they're talking about.
Actually, I'm inclined to agree that WebApps generally suck when compared to a Windows App performing the same task. Obviously, WebApps have their advantages (easy distribution, usage monitoring, centralized access, no risk of rogue versions); but when the situation doesn't make it necessary to create a product as a WebApp, I think it's generally stupid to do so.
As for Mono, the product is a valiant effort, but I can't understand why you would run software on something other than its native platform. After the App is deployed, if it encounters any problems, you'll always have to wonder, is it the App, or is it Mono?
WinForms isn't dead. In some circles, I'd say WPF is stillborn, and if there's anything good that came out of it, it was in fact Silverlight.
In fact, I would say that while WPF has its plus sides, its got a few drawbacks as well. Its -really- slow compared to WinForms, the nested control architecture isn't as good, the layouts and sizing aren't as flexible, and worst of all, there's no datagrid.
I understand the inspiration. Microsoft tried to make a modern client gui toolkit that gives you some of what html does, but I frankly think they missed the mark. If anything, WPF will inspire the idea that developer's have choices in control and widget sets and that will lead developers to look at things like Qt and Java or even Webkit, as I have done.
This is my sig.
Consider the following sentence:
.NET, which the earlier poster did, even if it doesn't exactly make sense to speak of .NET being a language, which you decided the earlier poster must have meant to do.
"If I was going to buy a new car, it would probably be Ford or Chevy and not GMC."
"Ford and Chevy aren't cars," would be one possible response, but an unnecessary attempt at correcting something that could have been interpreted in a way that made sense to begin with.
It makes sense to speak of a language being
Nope. ECMA has not forced Microsoft to give up its patent claims. The only requirement with respect to patents is that they be available under "reasonable and nondiscriminitory" terms -- which basically means that Microsoft can charge whatever it wants for patent licences, as long as it's the same fee for everyone. So MS can still threaten to sue for patent violations. And any fee of significant size is of course fatal for free software. So you are wrong.
Couldn't agree more. I've tried to develop code using mono and notepad (or vi, whatever) instead of Visual Studio. It's practically impossible.
.NET developer who doesn't use Visual Studio and I'll show you a magician. Visual Studio (which I admin, I think is awesome) is such a great IDE and it generates a lot of useful code and config files (etc etc etc) and crap that makes it a complete nightmare to do without.
.net code using mono and some other IDE, it's technically possible, and you could do it, but it'd be like pulling a shopping cart along with a toddler attached instead of removing the child and then pushing it. Stupid and too much effort.
The microsoft documentation is only useful if you're using Visual Studio. Period. Find me a
Now it is technically possible to write
Just fork out the $$ for VS and you've instantly saved yourself weeks of development. But Mono.... just give up now. Unless things have changed over the past 2 or 3 years. But I doubt it. I don't even really understand why they bother.
I contracted a while at Microsoft, and every blue badge (full-time developer) I ever met ignored VS.NET and used vim or emacs all day (for C#, C++, XML, everything except the occasional dialog edit) with the MSDN docs open on the other monitor. No lead with a clue lets the opaque plumbing inside an IDE determine whether their project gets built corectly (we used build.exe, a make clone from the DDK), WinDbg is far more powerful than the builtin debugger (download and try it), and an editor with too much "assistance" to even keep up with your typing (on desktops fast enough to run internal debug builds of Vista!) was just unforgivably lame.
"If it gets too powerful, or too feature full, who's to say if MS doesn't retract their promise and claim that Mono is infringing on their patents, suing whatever company might have worked on said products?"
MS patents are going to be general (as all patents with "business goodness" are). In other words, MS isn't going to limit any patent description in such a way that only .NET implementations would be in violation. If mono violates a MS patent it's very likely that Java and many other projects will violate it too. The mere fact that Mono is an attempt to implement a sub-set of .NET doesn't mean it has any greater risk than other projects.
In any case, I seriously doubt that MS has any desire to start a patent war anyway. Between the DOJ and IBM, it wouldn't be a winning strategy.
I regret that he apparently wasn't more successful in convincing us to burn our web apps. I'd hazard a guess that 80% of my computer-related headaches is a result of web apps, which I have now almost completely swore off if there's any way I can avoid them.
Crap like Google Maps I find insulting. We had map software 15 years ago. The only thing we needed was periodic udpates, but web apps go to a completely opposite extreme, every single data request is serviced live, nobody finds it acceptable to risk that data might be hours or days old. If I'm actually using my connection to retrieve data (files, audio, video, etc.) all those web-apps slow to a crawl.
With web apps, even with the fastest modern computers we're working at speeds closer to what we had back in 1995. We don't need all data to be streamed from the source, I would much prefer most of the applications reside on a local computer and function at native speeds instead of everything being bottle-necked by my ISP. I don't even mind using a thin-client running applications through terminal services, but having all basic desktop applications running from a web server is just ridiculous.