Since a few folks have asked on irc and they are not using
my innovative comment-reading service, am reposting (with some
slight edits and clarifications) the answer to "Will Mono
implement C# 3.0?"

Yes, we will be implementing C# 3.0.

We have been waiting for two reasons: first, we wanted to
focus on bug fixing the existing compilers to ensure that we
have a solid foundation to build upon. I very much like the
Joel
Test that states `Do you fix bugs before writing new
code?'.

C# 3.0 is made up of about a dozen new small features.
The features are very easy to implement but they rely heavily
on the 2.0 foundation: iterators, anonymous methods, variable
lifting and generics.

Since we have been fixing and improving the 2.0 compiler
anyways, we get to implement the next draft of the
specification instead of the current draft. This means that
there is less code to rewrite when and if things change.

Fixing bugs first turned out to be a really important. In
C# 3.0 lambda functions are built on the foundation laid out
by anonymous methods. And it turned out that our anonymous
method implementation even a few months ago had some very bad
bugs on it. It took Martin Baulig a few months to completely
fix it. I wrote about Martin's work here.
The second piece is LINQ, some bits and pieces of the
libraries have been implemented, those live in our Olive subproject.
Alejandro Serrano and Marek Safar have contributed the core to
the Query space, and Atsushi did some of the work on the XML
Query libraries. We certainly could use help and
contributions in that area.

Anecdote: we started on the C# 2.0 compiler about
six months before C# 2.0 was actually announced at the 2003
PDC. Through ECMA we had early access to the virtual machine
changes to support generics, and the language changes to C#.
By the time of the PDC we had almost a functional generics
compiler.

The spec was not set in stone, and it would change in
subtle places for the next two years. So during the next two
years we worked on and off in completing the support and
implementing the changes to the language as it happened.

Most of the hard test cases came when C# 2.0 was released
to the public as part of .NET 2.0. About six weeks into the
release (mid-December and January) we started receiving a lot
of bug reports from people that were using the new features.

Second Mini-Anecdote: Pretty much every new release
of IronPython has exposed limitations in our runtime, our
class libraries or our compilers. IronPython has really
helped Mono become a better runtime.