I’m writing this short series in an attempt to dispel some of the misunderstandings (and FUD) spread around liberally, and hopefully explain to people why I (and many others) see the Mono project as a good thing for Free Software, not the evil destroyer of worlds that some of the more tinfoil blogs would have you believe.

Today I will be discussing standards.

Programming languages, historically, are implemented by lots of people in different ways. To give FORTRAN as an example, I can think of five major compilers on the market today off the top of my head (GFortran, Intel, Pathscale, Portland, and Absoft). The same situation applies with, say, C. FORTRAN and C both have so many implementations, because there is a “core” for all those implementations to work towards – the idea being that if you write any program “in FORTRAN”, you can compile it with any FORTRAN compiler that supports the same revision of the core specification that you used. The most popular in use today are FORTRAN 77 (an ANSI-ratified standard) and Fortran 90 (both ANSI and ISO). Write an app for Fortran 90, and compile it anywhere.

You still have a degree of freedom to “extend” those standards (hence apps which will only compile with a subset or single compiler), but those standards exist, unchanging, as potential targets for your code.

A similar situation exists with C: people commonly talk about “ANSI C”, meaning the ANSI C89 standard (ratified a year later as ISO/IEC 9899:1990, better known as C90). This was an attempt to standardise the C language, following on from the mess of mostly-compatible languages built around a textbook by a couple of guys at Bell Labs.

Again, using the C standards allow for code which is compatible between different compilers (GCC, Intel, Pathscale, Portland, Borland, Microsoft, and so on). And again, whilst there are a lot of possible extensions, those standards are still there (and, again, are immutable targets for you to aim at if you so wish).

So what is this getting towards? Well, these days, there is an ugly trend away from reliable published standards for languages, which is a cause for great confusion – and worse – single-vendor implementations. Imagine a popular language, let’s call it “Boa Constrictor”, which essentially only has one implementation, which is prone to change and breakage at any given time (forcing application authors to constantly worry about whether their apps will still work over time). Where the only “standard” is today’s vision of one supplier, making fully compatible competitors (which might be much faster or better in other ways) is largely impossible.

Bad, right?

Now, imagine if someone came forward and said “actually, this sucks, we believe in standards”. Imagine that! A real, immutable standard for multiple people to work on, and make compilers and libraries to be compatible with. That’d be good, right? And then, when a new version is developed, that standard appears too, as an immutable alternative – much like F77 and F90. Nothing but good news!

Except, apparently, it’s not. The old situation, the single-source language with no coherent version to lean on is the best option. Why? Because, shock horror, the evil Microsoft are the ones who published the standards. See, when Microsoft get involved, things like “immutable” suddenly mean “evil trap” – “ISO/IEC 23270:2003″ means “ever-changing moving target”.

But that’s a lie, from serial liars with an agenda. It has no basis in reality.

The reality is, if you write an application which targets the published CLI standards (ISO/IEC 23271:2003 or ISO/IEC 23271:2006 at your choice), using a published C# language standard (ISO/IEC 23270:2003 or ISO/IEC 23270:2006 at your choice), then it will run on any complete, functional implementation of those standards – be it Mono or Microsoft.NET or DotGNU portable.NET or Microsoft Rotor or something else. If you use extensions beyond the core specifciation, then you need to worry about whether those extensions can be used elsewhere, but at that point you simply need to select cross-platform extensions which, again, have immutable versions you can target (so design your GUI with GTK# and not System.Windows.Forms, for example).

So there’s some reasoning on why standards are an important thing in programming languages – and why the oft-cited “Mono is chasing a moving target” line is lies. Mono is chasing two targets. Firstly, the published, immutable, ratified international standards which were published by Microsoft. Secondly, the stars – Mono is aiming to implement everything sensible beyond those core standards, and even bring some of its own compelling technologies to the table.

If anyone tells you Mono is “chasing a moving target”, call them a liar, and print out a copy of the published ISO/ECMA standards for them to read.

This entry was posted on Monday, October 20th, 2008 at 10:47 am. You can leave a response, or trackback from your own site.