XNA is a new set of tools for assisting in game design, development and mangement (see the XNA Wikipedia page).

One of the components is the "XNA Framework" a set of .NET APIs for actually building the applications. It does not expose DirectX which makes it simpler to be ported to other platforms.

Rob Loach has started a project to do an open source implementation using the TaoFramework (Tao provides bindings for all things OpenGL and a few other media libraries).

Rob's implementation is being developed here. Currently most of the development is happening on Windows, but the project on SVN has support for building this on Linux with Mono as well.

Jordi Mas has organized for me to talk in Barcelona on November 8th at 19:30 in the Aula Magna at the Universitat de Barcelona at Gran Via de les Corts Catalanes, 585.

Will talk about Mono, developing with Mono, will likely introduce the work from Jordi (Workflow) and Lluis (MonoDevelop and Stetic) and talk about our plans for Mono 2.0 and beyond.

At the Microsoft TechEd

Frank Rego and myself will be at TechEd Developers in Barcelona from the 7th to the 10th. If you are attending TechEd, we will be in the Novell booth.

F-Spot finally has a feature that I have been waiting for. It is now possible to scale pictures before sending them:

Preparing Images for Email

Alan McGovern the developer of the BitSharp libraries (Bittorrent APIs for the CLI) started blogging.

Alan has continued his work from the Summer of Code, here are a few updates from him:

• On some challenges he is facing.
• Performance improvements: downloads went from 30k/s to 4.5MB/s and memory consumption is under 10 MB.
• GUI for BitSharp.

From his blog:

So it looks like i well achieved my aim of creating a cross platform client that uses less than 1/3 the ram that Azureus uses.

Here are a few screenshots of the updated GUI (Piotr did the GUI originally, and it has now been updated to the latest BitSharp API changes):

GUI running on Windows (This is Gtk# on Windows).

Alan keeps a To-Do list here, which should make it simple for people to help in the effort.

a few more screenshots are available here and here.

The Mono Meeting is over, it was a couple of very intensive days, and I managed to get very little sleep.

The slides for the presentations are here:

• Mono Roadmap, opening presentation.
• The db4o embedded database.
• DekiWiki and the Dream Framework
• The Cecil CIL Manipulation Library.
• Grasshopper: running .NET applications on J2EE servers.
• Indigo and Infocard in Mono.
• Security, CAS, Monoxide and Crimson.
• Mono's Compacting GC work.
• Visual Studio and Mono integration
• Gtk# Roadmap.
• Mono Code Generation and Performance.
• Mono Debugger.
• NUnit and Mono.

Olive: Infocard and Indigo

On Monday Atsushi checked into the olive module the initial implementation of Indigo and Infocard.

The status of the module is kept here and contains a human readable report of where we are standing. It is only the beginning, but some simple applications are able to run now.

Hopefully in the next few days I will have time to write down a few more lines about everything we talked about in the public Mono meeting and in our internal discussions.

For those of you coming to the Mono Meeting early today (the "early-arrivers"), we will be having brunch at noon in Casa Romero.

Sergey Tikhonov has been working for a few months on an Alpha port of the Mono JIT. The port can currently bootstrap itself (a sanity test that is used by all Mono ports), and the port is able to build the usual Mono GUI libraries (Gtk# and the Gtk# apps).

Currently the port still lacks varargs support, debugger support, global register usage and some peephole optimizations.

All of this code is now on SVN, and will appear shortly on the Mono 1.1.18 release.

Mark Mason has been working on a MIPS port, and he said this morning that the port is now "limping along". Not quite sure what that means until we see the patch.

Now all we need is a m68k to conquer the Atari ST world and a VAX port for all of you that still run an 11/780 in your basement.

Today Jon pointed me to C#'s "??" operator, this is really the kind of thing that I should know. The operator is part of the nullable-type family of operators, but I did not know that you could use this with regular expressions.

Its lovely, the expression: a ?? b evaluates to a if a is not null, or to b if a is null.

Very handy, replaces the idiom: a == null ? b : a.

This is only available in the gmcs compiler.

Mono's C# compiler was forked a few years ago (mid 2003) when we started developing the generic extensions to the language. We did this because the generic specification at the time was still in flux, and this new compiler was sort of a research compiler for us. We did not want to destabilize our production compiler (mcs) with generics at the time, so we kept the new compiler on its own tree (gmcs).

The downside is that ever since, we have had to merge all the improvements and bug fixes done to the generics which required a considerable effort.

Things have luckly changed. The C# generics specification is complete and gmcs is now stable.

This past week Martin and Harinath completed the merging of mcs with gmcs. Now we have a unified source code base, the only place where we have kept the code base divided is the tokenizer and the parser. This is ok, as we are considering writing a hand-written parser instead of the yacc generated parser that we use today.

This effort started because Martin did some major architectural changes in the anonymous method and iterator support.

One of the most common problems that people face when porting applications from Windows to Linux using Mono are paths.

The Problem

Windows developers are used to a case-insensitive file system, which means that they might create a file called "mydata" in one place, and try to access it somewhere else as "MyData" or as "MYDATA". This of course breaks on most Unix setups because Windows is case insensitive[1].

Another problem is that developers on Windows are known to hardcode the directory separator character in their source code ("\") instead of using Path.DirectorySeparator and using Path.Combine for combining this paths. This is a problem because "\" is a valid file name components on Unix. This means that if an application hardcodes for example "Logs\access_log", in Unix this will not store the contents in the "Logs" directory as the file "access_log". Instead, it will store the results in a file called "Logs\access_log".

Only a few applications cope with drive letters, but they might still pose a problem as the colon is a valid filename in Unix, which means that "A:\file" is a valid filename in the current directory.

Although .NET provides the tools to write code that is portable, in practice, they do not use these features (the exception is Path.Combine, which some people use, as it is genuinely useful on its own).

The Usual Solution

When moving applications from Windows to Linux, it is always necessary to run the application, run its test suite, and validate that the application works as intended. With the path problems described above, the process above included a number of iterations to fix the assumptions made by programmers about the file system.

This process could be time consuming, because identifying where the mistakes were made could take some time, the program might fail with FileNotFound exceptions (when referencing files that were not there), data would show up empty (listing contents of a directory that had nothing, as all the data went elsewhere) but it was doable.

This process works as long as you have the source code to all the components that you are porting, but if you were using a third-party library that you had no source code for, you would not be able to fix the problems.

The New Solution

This week, Dick Porter introduced a portability layer into Mono that will address those problems without requiring changes to your code. This will remove a large component of the porting cycle as a whole class of obnoxious problems are gone.

The new portability framework is enabled by setting the environment variable MONO_IOMAP (which we will likely rename to something shorter) to one of the following values:

• case: makes all file system access case insensitive.
• drive: strips drive name from pathnames.
• all: enables both case and drive.

In addition, if any of those options are enabled, the directory separator mapping is also turned on. So this basically means that you have to type this, or include this in your script that launches your application:

	$ export MONO_IOMAP=all
	$ mono myapp.exe
	

For ASP.NET applications hosted with mod_mono, you can add the following directive to your Apache configuration file:

	MonoSetEnv MONO_IOMAP=all
	

This new feature will appear in Mono 1.1.18.

The downside is that Mono will have to do some extra work when coping with your file system, to search for case insensitive file names. So if your application is still a portable application, you will be much better off without this switch.

[1] Some Linux file systems are case insensitive, and some folks have used a combination of hacks, including doing loopback CIFS mounts to get case sensitivity issues out of the way; OS X does not have this particular problem, but it still has the others.