WhoRunsGov.com provides a unique look at the world of
Washington through its key players and personalities. The site
features concise profiles of influential political officials
who shape government policy, including members of the new
presidential administration, Pentagon officials, lawmakers,
senior congressional aides and committee staff. The first
several hundred profiles are being crafted by a newly created
editorial team at the Washington Post Company, as well as a
group of experienced outside contributors.
Each profile provides in-depth information on an official’s
policy experience, involvement in government decision-making,
major policy positions, key associates, political
affiliations, voting records, campaign and personal finance
information, plus relevant news articles from around the Web.

Their Deki project has gone from the cutest Wiki system to
a full collaboration platform.

And as my readers have come to expect, yes, this is also
built on top of Mono. Deki is not built with ASP.NET
--Microsoft's web platform-- instead the engine is built on
top of
Mindtouch's Dream
framework and the presentation layer is built on top of
PHP.

The amazing Joachim Ante
from Unity3D wrote me to tell
me that Cartoon Network's new browser-based MMO for
kids FusionFall has
finally launched to the public.

Fusion Fall takes advantage of many new features in Unity3D
for creating large worlds.
I live
blogged some of the details as Joachim presented them at
the Unite Conference.

Unity uses the Mono runtime on both Windows and MacOS and
it might become one of the largest deployment vehicles for the
Mono VM.

There is an air of coolness in the fact that Mono is being
used on Windows instead of .NET. And part of it has to do
with the fact that Mono's open source engine allowed Unity to
modify it to suit their very specific needs.

As I mentioned at my PDC talk, the .NET engine is
fantastic, but up until Mono only Microsoft was in a position
to reshape .NET into different forms (Silverlight and Mesh
both use a special trimmed-down .NET called CoreCLR). I would
love to see a world where people take Mono (or chunks of Mono)
tune it and shape it to suit their needs.

Congratulations to the team at Unity for a job well done,
and to the team that produced FusionFall. You can see the
introduction video:

One thing that stands out in FusionFall is that it shows
what a big creative budget can do with Unity.

Microsoft worked late last night to get us access to the
code that will be used during the inauguration so we could
test it with Moonlight.

Thanks to: Joseph, Larry, Geoff, Rusty and specially Aaron
who all worked tirelessly to implement and get everything
tested tonight and ready to go on the Novell side. To Brian,
Eric, Ben at Microsoft and Mio at IStreamPlanet to make sure
that Linux users will be able to watch Obama's inauguration.

Three years ago, in November of 2005 we started a project
to upgrade Mono's code generation engine as the engine started
to age and it became increasingly difficult to improve code
generation and extend the JIT engine in meaningful ways.

The new
code generation engine is based on a linear intermediate
representation as opposed to the tree-based intermediate
representation that we had used up to Mono 2.0.

Switching the code generation engine is a pretty
significant effort and we did not want to switch it shortly
before we had to ship Mono 2.0, so we decided to ship 2.0 with
the engine that had been in wide use.

Shortly after we branched Mono's tree for
the 2.0
release Zoltan merged his work from the linear branch into
the main tree.

We have now shipped all of this as part
of Mono
2.2, you can get
it here.

Some Benchmarks

Mono's new engine generates much better code than the
version found in Mono 2.0.

Speed: The engine will mostly benefit computationally intensive
code, usually between 10% and 30% performance increase, with
some cases going up as high as being 50% faster.

Debugging the Transition

Although we had our test suite, and we regularly tested the
code against most apps, we were still afraid that something
might go wrong. The new code could miss-compile something,
and it would be hard in a large project to pin point exactly
what went wrong.

For example, the problem might not appear while compiling a
small test program like `hello world', but could appear when
running a web site under heavy load or when running
MonoDevelop.

Zoltan came up with a very interesting solution: for a
period of time Mono had two JIT engines built into it, the new
and the old one. Here is where the clever trick comes in:
an environment variable contained the number of methods that
should be compiled with the new JIT engine. After the Nth
method had been compiled, the engine would switch code
generators.

This was used to bisect regressions and failures.

A couple of months after we had done the switch and both
our unit tests and our system tests passed the old JIT engine
was eliminated from Mono.

SIMD

Using SIMD for accelerating certain floating point
operations had been in the back of our minds for a while.
We looked into implementing that in our old engine, but that
turned out to be very difficult.

With the new engine, Rodrigo was able to put together a
prototype in a weekend (the legend goes that Rodrigo's wife
was busy that weekend).

This prototype was later turned
into Mono.SIMD
an API for accelerating vector operations.

Mono 2.2 is the first release to officially support and
distribute it. To learn more about Mono.SIMD support, you
can
see this
blog entry.

Full Generics Sharing

With this release, the generics code sharing engine has
been completely debugged and is now enabled not only for code
that lives in mscorlib, but for all generics code written by
the user.

The Technical Details

We have
provided A
complete description of Mono's new engine design and the
the various code generation stages.

Raptor Copter has become our first Unity-made iPhone game to
hit the App Store! We’re making it available for a
limited-time price of $0.99. The game is a loose follow-up to
Off-Road Velociraptor Safari. Instead of a jeep, you have a
Chinook helicopter, but the basic game loop is the same:
Capture raptors, drop them into factories, and teleport their
sweet meats to the future.

Christian Lassmann from Weltenbauer Software
Entwicklung GmbH, who I had the pleasure of meeting at the
Unite Conference in Denmark in October, just wrote to tell me
that "My Animal
Center", a game built
with Unity3D's
Wii Edition and Mono hit the shelves on December 20th in
Germany.

The game uses C# extensively. It was a joy to hear
Christian explain how the various effects were created, I wish
he blogged about it.

UI Automation provides programmatic access to most user
interface (UI) elements on the desktop, enabling assistive
technology products such as screen readers to provide
information about the UI to end users and to manipulate the
UI by means other than standard input. UI Automation also
allows automated test scripts to interact with the UI.

Mono's Accessibility Framework is an implementation
of UI
Automation. The same API that is available for WPF and
the framework is used by Silverlight and Windows.Forms.

Client Code: The initial launch of Mono
Accessibility adds accessibility support to applications built
with Windows.Forms to be accessible.

Backend Code: The code has a bridge that talks to
the
existing ATK
framework on Linux.

In the future the Mono Accessibility framework will be used
in our own Moonlight 2.0.