
Mono: What we are Cooking - rayvega
http://tirania.org/blog/archive/2010/Dec-09-1.html
======
grav1tas
I poke in on Mono from time to time to see what's new there, and I probably
don't do it enough. It seems like every time I show up they've finished what
they were doing previously and a rolling into a host of other new things.
These guys are freakin' rock stars at this stuff. In light of the fact that
Java's future has a lot of people flummoxed, it might be interesting to see if
there's increased entry into Mono. Are there any good general numbers on the
type of use Mono is getting these days? I'd never expect to see some kind of
mass exodus from Java or the JVM, but all these new language features and
paradigms going into mono are just SO COOL. In the face of how long it took
Java 7 to get rolling, Mono seems incredibly nimble to me, but at the same
time it also doesn't have that rock solid feel that I get when I think about
developing on the JVM. Mad props to these guys, the just never seem to get
tired.

~~~
nodata
If Oracle can't be trusted with Java, can Microsoft be trusted with Mono?

~~~
tzs
Generally yes. Mono can be split into three parts. First, there are the parts
that implement the ISO/EMCA standards for C#, the runtime, and the libraries.

Second, there are additional libraries that are in .NET for doing various non-
portable things on Windows (like writing Windows GUIs), for which Mono has
made compatible libraries for non-Windows.

Third, there are additional non-Windows things Mono has added. Some of these
are new language features from versions of .NET that haven't yet went through
ISO/ECMA. Others are things that Mono has added that don't have anything
corresponding in .NET.

For items in the first part, Microsoft had to make any IP of theirs known to
be necessary to implement the standard available on reasonable terms. The
terms they used are the Microsoft Community Promise.

For items in the second part, there may be some risk. The simplest thing to do
is avoid those parts. For example if you want to write a program that needs to
be portable to Windows, Mac, and Linux then instead of using the Windows-
specific GUI stuff and Mono's compatible versions of those, use Mono's GTK#.
That works on Windows. If you aren't trying to write a portable program, then
there is even less reason to consider the Windows-specific stuff and its Mono
equivalents.

For items in the third part the risk seems low. Mono isn't using Microsoft
code for the most part (and any Microsoft code they are using was released by
Microsoft under the Apache 2 license which includes a strong IP grant), so
copyright isn't going to be a problem. The potential problem would be patents.
However most of the things in the third part are things that are also done in
many other languages/runtimes and so any patents on the .NET versions are
likely covering specific implementation details. There's no particular reason
to believe that Mono's independent implementation would have used the same
methods. In other words, for these things the risk that Microsoft would go
after Mono is about the same as the risk that Microsoft would go after Java,
or Perl, or Ruby, or Python for how those languages and runtimes do similar
things.

Actually, that's not quite right--the risk is probably lower, because
Microsoft has provided encouragement for Mono. That's going to raise some
estoppel arguments. They'd have less of a problem going after some other
language where they might not have as many estoppel issues to deal with.

Really, though, the big difference between Microsoft and Oracle here is
attitude. Microsoft had encouraged independent and open source work on .NET.
They've released quite a bit of their code under the Apache 2 license,
including the .NET Micro Framework. The Apache 2 license has a strong patent
grant.

Sun/Oracle on the other hand have been reluctant to allow truly independent
implementations of Java. They will not place the spec under control of a
standards body. You can't get a patent license for an independent
implementation unless you pass the TCK, and you can't get a license to the TCK
under acceptable open source terms.

Sun did release OpenJDK, but it is GPLv2. No explicit patent grant. There is
probably an implicit patent grant but no one knows what the boundaries are, so
the practical effect is that OpenJDK is likely to just track closely Oracle
Java. I doubt you'll see any major effort to fork OpenJDK and add Java ME
support for instance.

A good illustration of the attitude difference can be seen with F#. The F#
compiler did not initially work under Mono. Microsoft could have ignored that,
opting to keep F# as a reason to encourage people to go with Windows and
Microsoft's developer tools, and leave it to the Mono people to enhance Mono
to be able to handle F#. Instead, Microsoft quickly updated F# to make the
compiler work on Mono.

If some Oracle thing didn't work on a non-Oracle JVM, I would be surprised if
Oracle would leap in to make it work unless some big customer with a lot of
money wanted it.

~~~
bad_user
About F# ... they also open-sourced it under the Apache 2.0 license which
contains an explicit patents grant.

------
jasonkester
I just looked back into Mono to see what they've been up to in the last year,
and it's nice to see that they're finally back on track:

<http://www.mono-project.com/Compatibility>

They've always had this annoying tendency to stray from the things we need
them to be working on (getting a 100% feature complete version of the latest
.NET CLR) and into things that are cool but not really core, such as the long
list described in this post.

I gave them a hard time about this a year ago, when they came up with a
similar list of fun side projects yet still had major pieces of .NET 2.0
unfinished, such as this one that was stopping me from using them:

<https://bugzilla.novell.com/show_bug.cgi?id=346561>

Sounds like they have enough people on the core now that they're mostly up to
date on 3.5 and starting on 4.0. That's great news (more-so than this blog
entry, but it provides a nice excuse to give them some props).

------
srean
This is great. Does this imply that Mono finally has constant stack space tail
recursions ? Now I can look forward to (Iron)python without arbitrary
restrictions on the depth of (tail)recursive calls. And no GIL too !

------
equark
How does using .net affect acquisitions? Are the big firms like google, IBM,
oracle, JVM only?

------
sagarun
This blog post sounds like telling the world that 'mono is not dead "yet" '

~~~
YooLi
Did we read the same blog post?

