Annotations of George speech is over at billmon.

Hugo's speech at the UN raises a few good points:

And we must recall in this room that in just a few days there will be another anniversary. Thirty years will have passed from this other horrendous terrorist attack on the Cuban plane, where 73 innocents died, a Cubana de Aviacion airliner.

And where is the biggest terrorist of this continent who took the responsibility for blowing up the plane? He spent a few years in jail in Venezuela. Thanks to CIA and then government officials, he was allowed to escape, and he lives here in this country, protected by the government.

And he was convicted. He has confessed to his crime. But the U.S. government has double standards. It protects terrorism when it wants to.

And this is to say that Venezuela is fully committed to combating terrorism and violence. And we are one of the people who are fighting for peace.

Luis Posada Carriles is the name of that terrorist who is protected here. And other tremendously corrupt people who escaped from Venezuela are also living here under protection: a group that bombed various embassies, that assassinated people during the coup. They kidnapped me and they were going to kill me, but I think God reached down and our people came out into the streets and the army was too, and so I'm here today.

But these people who led that coup are here today in this country protected by the American government. And I accuse the American government of protecting terrorists and of having a completely cynical discourse.

Then he raises the issue of the veto:

Point three, the immediate suppression -- and that is something everyone's calling for -- of the anti-democratic mechanism known as the veto, the veto on decisions of the Security Council. Let me give you a recent example. The immoral veto of the United States allowed the Israelis, with impunity, to destroy Lebanon. Right in front of all of us as we stood there watching, a resolution in the council was prevented.

Worth reading the whole thing.

My Firenze Talk will be held in a new location: Universitá degli Studi di Firenze - Facoltá di Ingegneria, in l'aula è la 008 di viale Morgagni at 3pm.

A flier is available here.

Michael Lehman has uploaded the videos from the various presentations that we had at the Lang.NET Symposium.

My favorites:

• John Gough on running Ruby on the CLR.
• Mike Barnett on Spec# (Programming with contracts).
• Anders Hejlsberg on the new LINQ extensions. A great introduction to the new data and XML processing facilities in C# 3.0 and how these are built on top of a few small changes to the language.
• Dom Syme talks on F# and delivers a great live demo.
• Jim Hugunin shows IronPython, this was done very close to 1.0
• Jim and Cory on SecondLife. I absolutely loved Jim's presentation.
• John Lam on bridging the Ruby interpreter and the CLR (different from John's presentation. He also pulls an incredible demo with Ruby and Avalon.

There are more talks there, but I missed a few of those talks (one of the talks uses Mono's C# compiler as the base for their research.

And my own presentation here, the usual Mono stuff that I talk about.

Cory does a fantastic presentation on what SecondLife is on this video from the Lang.NET Symposium.

Jim then talks about the work that they have been doing to use Mono as the virtual machine to run their scripts. Jim is an excellent presenter.

This is a must-watch presentation for programmers.

We have changed the hotel venue, to a nearby location, please check the Venue Update post on the Web site.

Officials of the United Nations' International Atomic Energy Agency said in a letter that the report contained some "erroneous, misleading and unsubstantiated statements."

Yesterday's letter, a copy of which was provided to The Washington Post, was the first time the IAEA has publicly disputed U.S. allegations about its Iran investigation. The agency noted five major errors in the committee's 29-page report, which said Iran's nuclear capabilities are more advanced than either the IAEA or U.S. intelligence has shown.

Among the committee's assertions is that Iran is producing weapons-grade uranium at its facility in the town of Natanz. The IAEA called that "incorrect," noting that weapons-grade uranium is enriched to a level of 90 percent or more. Iran has enriched uranium to 3.5 percent under IAEA monitoring.

Washington Post
U.N. Inspectors Dispute Iran Report By House Panel
September 14, 2006

Last Sunday, Mohammad_Khatami, Iran's former president, had a talk at the Harvard Kennedy School of Government here in Boston, the talk is available on C-SPAN.

Not an expert on the topic, but his talk is worth watching.

The Q&A section of the talk was probably the most interesting, Harvard agreed to host him provided that Mohammad Khatami took unscripted questions from the audience. The questions and answers are the best part of the talk.

When asked about the uranium enrichment program he said something along the lines that Iran continued to abide by the IAEA regulations. That they had withdrawn from some voluntarily stricter regulation that they had suggested in the past. This is roughly from memory.

I completely had forgotten to blog about SplendidCRM, an open source, .NET-based CRM system

The folks at SplendidCRM are very much Windows developers, they are completely new to Linux, they do not know our ways, nor speak the language that most of us Linux users do.

They were interested in supporting their CRM system on Linux, but they were overwhelmed by the instructions on how to get their software up and running on a system that they barely knew.

They were the first users to try our Mono VMware image. They had been requesting this from us for months, they got their software ported in a couple of days:

Within an hour of getting the VMware image, I was able to compile my project without any errors. You guys should have done this years ago.

We had to fix a couple of issues with our VMware image (DHCP configuration, installing the VMware tools) and after these changes, only after 48 hours since the release, his product was running on Linux.

SplendidCRM running with Mono, SUSE/Linux and MySql.

You can try their product running against MySQL or against SQL Server on top of Mono from their site.

In this interview president Bush is visible upset by the questions about torture.

Otee and a few other companies are building games with Mono as the VM for running scripts.

In Otee's case, I believe they are using some modified version of Boo. We are also assisting Second Life in adding a few features that they need in Mono for their own game.

Today, while reading reddit, I ran into this article Why C++, an article where the author talks about the advantages of C++ over C for game engines. At the end there was an interesting paragraph:

So I hate to admit it, but I come down on the side of conventional wisdom. Write your game engine in C++. Write your gameplay in Lua. Those might not be the right answers for the next generation. I can imagine a language with better support for concurrency stealing the application domain from C++ sometime in the next decade. And C#/Mono is nipping at Lua's heels as a game scripting language already. But for now, I think the C++/Lua combination is as good as it gets.

Emphasis added.

We know about a handful of games, but we do not have an entire list; I would love to know more about people using Mono to develop their game logic and would like to work with you guys (and yes, we can keep a secret).

Although Mono is embeddable, I always got the feeling that we could improve that API, and would like to get feedback from those embedding the VM about what kind of things they would like to have in Mono to simplify the embedding and improving future embedders experience.

Updated, some cute screenshots from Unity and games built with Unity are here

If you install their web plugin (Windows and OSX only for now), you can try out some of the samples, and sample games in here.

It is a shame that it does not run on Linux, but both the Windows and OSX versions use Mono as their high-level engine.

I will be talking about Mono, Mono-based applications and a little about our work on the desktop at Novell.

Location: Universitá degli Studi di Firenze - Facoltá di Ingegneria, in l'aula è la 008 di viale Morgagni at 3pm.

When: 29th of September, 2006.

Thanks to Massi for helping me set this up!

Updated

Calderón, the most recently purchased president and a corrupt politician has been now appointed Mexico's president by the court.

From The Guardian:

Felipe Calderón has been named president of Mexico, by a court, much as George Bush was named President of the United States, by a court.

But did he win the election? We do not know. The court's decision does not establish this, any more than the Bush v Gore case established that Bush won his first election - which, as we now know, he did not.

In both cases, the truth could have been known in time. But it was not. And that is because one side - in the legal struggle, the winning side - refused and resisted a full recount of the votes.

We finally have a location for the upcoming Mono Summit in Boston: The event will be held at Marriot Hotel at Kendall Square in Cambridge, MA on October 23 and 24th.

Just in front of the Kendall T-Stop in Cambridge, 20 minute walking distance from Berklee College in Boston and across the street from MIT.

If you are coming, please register in advance and if you wish to connect with other Mono summit attendees, you can list yourself in our our public Wiki.

My boss today suggested that we should have some kind of reception, am thinking we could have a "Welcome Meeting" on Sunday evening for those arriving to the city, and maybe some small soire on Monday and maybe some parting drinks for Tuesday. Anyways, if you got some awesome idea about what to do with 80-100 C# developers, drop me a line.

Lluis has finally put the finishing touches on the latest incarnation of MonoDevelop.

This release is feature packed: Stetic now has toolbar, menu and action editors for Gtk# applications:

The Menu Designer, showing stock-icons. Clicking on "Click to create an action" will enter a new row.

The toolbar designer, here it show how to select a stock-icon for the toolbar.

This GUI designer is based around the Gtk Action model, so all menu entries and toolbar commands are linked to the same action. So you actually hook up events to the actions, not to the individual items, which is useful to keep consistency in your application.

The stock icons are not limited to the ones that ship with Gtk+, you can define your own that you can later reference, this is how:

When designing your dialog boxes, a context-sensitive toolbar is activated depending on the widget selected, so the most common operations are available right in the design surface without having to hunt them down on a property list:

Here you can see the options available for a label: alignment of the text,
and the vertical and horizontal filling and expanding properties.

Michael's Summer of Code ASP.NET GUI designer is now part of MonoDevelop, here it is in all of its glory:

The palette on the right shows the properties for the selected control, the "OK" button.

The ASP.NET designer is built on top of Mozilla, so a lot of the work is in the interaction between the embedded Mozilla engine and the MonoDevelop host.

Code completion has been vastly improved, it now supports Generics and will also display a tooltip with the help associated with a method when you select it.

Finally, when you hover over the source code, you can get documentation for a particular method:

MonoDevelop will now also generate the auto-tools infrastructure for your project (thanks to Scott!), to ease the deployment of your applications. And is able to produce tarballs directly from the IDE:

It will generate the standard auto-* stuff, but it will also install a .pc pkg-config file for your libraries, so third party projects can "reference" your library easily.

Solutions and Widget Libraries

My favorite feature is that your solution can include not only your main project, but also other libraries, like a widget library.

In this screenshot I have created a library that contains a custom control "MyControl" which is part of the "MyWidgets" project. The "MyWidgets" project then gets added (Go to References, Edit) to the main project, and this new widget becomes available for consumption in the main program.

You can also incorporate any other libraries and widgets, and they will show up in the palette just like MyControl show up on the right here:

My Wish-list

Internationalization: I personally would like to see something like Rafael's internationalization plugin to be integrated in MonoDevelop so you could also manage internationalization in the IDE.

And there is plenty that can be done in this area, for translations we could poke web services that expose all known translation strings for a project and incorporate translations into a program. We could also have a service that translates with Google Translate and help people translate their project and keep track of progress.

Web Services: There is a web service consumer add-in that was developed by Gideon (his current code lives in http://code.google.com/p/md-addins/ that provides a similar experience to Visual Studio for creating and consuming web services.

Deployment: it would be great if someone wrote a deployment target that submits the tarball to the OpenSUSE build service.

The OpenSUSE build service will take a piece of source code and produce packages for Fedora Core, Ubuntu, SUSE and others, so we could have MonoDevelop directly generate packages for all distributions from within the IDE.

An XML Editor: it would be nice if someone wrote an XML editor that could use some RelaxNG or XmlSchema rules to provide intellisense for various file formats and provide a good XML editing experience.

IronPython Integration: IronPython has a number of features to support IDEs, and it would be lovely if we could get these things supported into MonoDevelop, in the same spirit that the Boo support does today.

More

There is much more in the Release Notes where I liberally took screenshots from.

The IDE today has support for various languages: Boo, Nemerle, Visual Basic, C#, Java and ILasm.

Lluis and his team have done a fantastic job on MonoDevelop. The demo that Lluis did in Guadec this year was truly mind blowing, I hope we have some form of screencast soon for people to witness the great integration on this IDE.

Jim Hugunin has announced IronPython 1.0. Congratulations to the IronPython team at Microsoft for this release!

From the release announcement:

IronPython is about bringing together two worlds. The key value in IronPython is that it is both a true implementation of Python and is seamlessly integrated with the .NET platform. Most features were easy and natural choices where the language and the platform fit together with almost no work. However, there were challenges from the obvious cases like exception type hierarchies to the somewhat esoteric challenges concerning different methods on strings. We spent long days and sometimes weeks looking for the best answers to these challenging problems and in the end I think that we have stayed true to both Python and .NET.

To drive our Python compatibility, we run a large portion of the standard Python regression test suite in addition to a large custom test suite we added that runs IronPython and CPython side-by-side to test for identical behavior whenever possible. Despite all of this work, there will still be differences between IronPython 1.0 and CPython. The most obvious difference is that IronPython is missing a number of standard C-based extension modules so things like "import bsddb" will fail. We maintain a detailed list of differences between the two implementations and aim to reduce the size of this list in every release.

IronPython has also striven for deep integration with the CLR. For the implementation this is a great thing as it lets us take advantage of highly-tuned components developed for other languages such as the just-in-time compiler, garbage collector, debugging support, reflection, dynamic loading and more. This integration is also valuable to IronPython developers as it lets them easily use any and all libraries built for .NET from their Python code.

I have been exchanging some emails with Pablo from CodiceSoftware a Spanish startup that is building software configuration management tools using .NET and Windows.Forms called Plastic.

Pablo's email on the subject:

We started Códice Software (www.codicesoftware.com) in August 2005, and since then we have developed a new SCM system, full written in C#. It runs on Mono from the beginning, in fact, our automated NUnit based system always tests on Linux/Mono (pnunit.codicesoftware.com).

Our intention building this new SCM was having something as powerful as Clearcase (ok, without some features like build enhacements and so on) but easy to use and fast (in some operations we are even faster than Perforce...), and also affordable to any-sized team. [Emphasis added]

This is what the software looks like on Windows:

In addition, they have developed a three way merge tool using OpenGL to render the view:

This is what it looks like in Linux running with Mono's Windows.Forms:

There are a couple of rendering glitches here and there, but other than that, its looking pretty sweet.

Rolf's excellent Visual Basic compiler was able to bootstrap itself a few weeks ago on Windows, but it did not work with Mono yet.

The compiler needed the VB runtime to be upgraded, it required a few fixes in the way we handle interface implementation for generics in the Mono VM, the final bug today was reference file names with their proper casing.

Also Rolf's compiler contained a few MS-specific hacks in the compiler, but those are no longer necessary so this afternoon the VB compiler was able to build Hello World on Linux:

$ mono vbnc.exe a.vb
	
                                                  DEBUG RUN

Visual Basic.Net Compiler version 0.0.0.4706 (last write time: 05/09/2006 21:06:28)
Copyright (C) 2004-2006 Rolf Bjarne Kvinge. All rights reserved.


Starting Scan
Scanning file /home/cvs/vbnc/vbnc/bin/a.vb
File '/home/cvs/vbnc/vbnc/bin/a.vb' scanned in 0.118 seconds
7 lines and 115 characters in total.
After SCAN: True
Starting Conditional Compilation
After ConditionaL True
Starting Parse
Parsing file /home/cvs/vbnc/vbnc/bin/a.vb (1 of 1 files)
3 assemblies were loaded.
73 namespaces were loaded.
2129 types were loaded.
Starting Resolve
Starting Resolve
CreateImplicitTypes compiler (1 of 1 types)
ResolveType compiler (1 of 1 types)
ResolveTypeReferences compiler (1 of 1 types)
CreateImplicitMembers compiler (1 of 1 types)
ResolveMembers compiler (1 of 1 types)
ResolveCode compiler (1 of 1 types)
Finished Resolve
DefineTypes compiler (1 of 1 types)
DefineTypeParameters compiler (1 of 1 types)
DefineTypeHierarchy compiler (1 of 1 types)
DefineMembers compiler (1 of 1 types)
Starting Emit
Emit compiler (1 of 1 types)
CreateType compiler (1 of 1 types)
Creating: compiler
Created:  compiler
Assembly 'a, Version=0.0.0.0, Culture=neutral' saved successfully to '/home/cvs/vbnc/vbnc/bin/a.exe'.
Compilation successful

	

The "DEBUG" run is a tiny bit verbose as you can see, the results are mind blowing:

mono$ cat a.vb
public class compiler
shared function Main as integer
Console.WriteLine ("Dingus")
return 0
End function
end class
mono$ mono a.exe
Dingus

	

Am actually scared of trying to bootstrap on Mono, I do not know if there are enough pixels in my machine to build the 68,000 lines of VB that the compiler has.

I think we have decided on what we will be doing in Italy.

We arrive to Pisa on September 16th, and we will head to the Elba island in the afternoon with the other speakers to the Elba island for the LASER Lectures.

After Elba, we will go to Rome on the 22nd or 23rd for the most part of that week.

Our plan is to go from Rome to Firenze and then to Pisa to take our airplane back home.

With this in mind: could we arrange some talks in Rome and Firenze (if there are Mono/Linuxers/.NETers there?)

A few days ago, Mono contributor Jordi Mas posted on his blog about the work that he has done to create an open source implementation of the Workflow APIs to Mono.

He announced his work here and provided the details about it here.

Scott Guthrie posts a couple of pointers to interesting tutorials on Workflow:

There are no screenshots at this time to spice up this blog entry, but here is the output of running the NUnit tests:

MONO_PATH=`pkg-config mono --variable prefix`/lib/mono/2.0:"../../class/
lib/net_3_0::$MONO_PATH" mono --debug ../../class/lib/net_3_0/nunit-console.exe
/output:TestResult-net_3_0.log /exclude:NotWorking,ValueAdd,CAS,InetAccess
 /xml:TestResult-net_3_0.xml  System.Workflow.Activities_test_net_3_0.dll 
|| ok=false; \
sed '1,/^Tests run: /d' TestResult-net_3_0.log; \
$ok
NUnit version 2.2.0
Copyright (C) 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov,
 Charlie Poole.
Copyright (C) 2000-2003 Philip Craig.
All Rights Reserved.

OS Version: Unix 2.6.16.21    Mono Version: 2.0.50727.42

Excluded categories: NotWorking,ValueAdd,CAS,InetAccess
..........

Tests run: 10, Failures: 0, Not run: 0, Time: 0.245039 seconds

	

Exciting.

Today I finally upgraded my home server which was running ancient software so I could run Tangerine for sharing my mp3s on the home network over DAAP.

Worked like a charm.

Gonzalo Paniagua developed a couple of new libraries: google-sharp to access a few Google services, and in particular Picasa and gnome-keyring-sharp, to access the Gnome Keyring from .NET applications.

gnome-keyring-sharp is a completely managed implementation, it basically speaks the keyring protocol instead of using a P/Invoke binding to call into native libraries, which is convenient as it is one dependency less on running applications.

Stephane Delcroix then developed a GUI for F-Spot to register your accounts, manage your albums and upload your pictures from F-Spot, the SVN version now has this fancy dialog box:

My first uploaded gallery from F-Spot is here.

Which reminds me, while traveling in Europe in July, I ran into the 12 Euro computer in a museum. I kid you not.

12 Euros, that is quite a good price. It is going to be hard for the OLPC guys to compete with that 100 dollar price tag, it has a surprisingly similar design, they also fold and they are also have quite an innovative design.

Judge for yourself here.

Martin has been working for the past couple of weeks on fixing a bug in the Mono C# compiler: how to properly compile an anonymous method inside a generic method.

The problem started with an innocent looking program:

	
        delegate void Foo ();

        class X
        {
                static void Hello<U> (U u)
                { }

                static void Test<T> (T t)
                {
                        Foo foo = delegate {
                                Hello (t);
                        };
                }
        }
	
	

The issue is that when we generated the anonymous method for "foo", we had to turn the "T" generic method parameter into a generic *class* parameter:

	
  .class nested private auto ansi sealed beforefieldinit 'AnonHelp<0>'
    extends [mscorlib]System.Object
  {
     .field  assembly  !0 'p:t'
  }
	

The code to cope with this in the compiler was fairly ugly, and Martin embarked on fixing the design internals at the end of July. We originally thought that there were two solutions: an elegant solution that required some refactoring and an ugly hack that basically accessed System.Reflection.Emit directly and poked at these internals from the anonymous method code path.

I have never quite liked what I did with the implementation of anonymous methods; I have tried to bounce the ideas off a few people to try to get their feeling on how to redo this code. I explained the design to Federico and Gonzalo hoping to get some feedback on the bugs and to clarify my own thoughts.

So to make a long story short, I did not like what was going on in the internals of the compiler; and in addition there are some annoying side effects and various constructs that crash the compiler when nested anonymous methods are used or when iterators and anonymous are mixed.

On Friday, Martin sent his weekly status report where he officially has removed my design mistakes. He has eliminated CaptureContext's from the compiler, and has eliminated the special-cases that coped with captured variables in the compiler --another part piece of code that worked, but was far from elegant--.

The new code that Martin has written replaced chunks of code that has bugged me for more than a year, so these are great news.

The patch is available here

In addition, cleaning up this code is essential as C# 3.0 will make extensive use of this infrastructure as part of the new lambda function support (This is because in C# 3.0 it is very natural for developers to create nested lambdas and anonymous methods, something that was more of a curiosity with the C# 2.0 syntax).

Btw, Martin just had a birthday, and he likes chocolates ;-)

Alan has updated the list of TODO activities for BitSharp.

This year, during the summer of code three students worked on Bittorrent support for Mono/.NET. Each one was in charge of an independent piece: a bittorrent downloading (Alan), a tracker (Gregor) and the GUI (Piotr).

The code has now moved from our incubator repository to the public and it is available on SVN or you can get a tarball of it.

The code is licensed under the terms of the MIT X11 license, which means, anyone can embed it anywhere.

If you make fixes or improve the code, it would be nice for you to contribute those back. Let the sharp bitorrenting begin!

Screenshots will come later.

On Linux it is possible to write user-level file system by using FUSE, a toolkit to write user-space tools that can be mounted as file systems.

There is a whole scene of Fuse developers, to satisfy the most unique tastes in file system needs. Cryptographic file systems, gmail-as-a-backing-store, and of course a Wikipedia file system.

Jon Pryor has released Mono and FUSE bridge: Mono.Fuse. With Mono.Fuse it is possible to author file system extensions with Mono using any of the libraries or languages supported by Mono.

To create a file system with Mono.Fuse, you must create a class that derives from Mono.Fuse.FileSystem, like this:

  using Mono.Fuse
  class TypeNavigator : FileSystem {

      static void Main (string [] args)
      {
          using (TypeNavigator t = new TypeNavigator ()){
	      t.MountPoint = args [0];
	      t.Start ();
	  }
      }
  }

	

Then you need to implement a couple of methods, you override the directory reading and attribute fetching methods like this:

  protected override Errno OnReadDirectory (string path, [Out] out string[] paths, OpenedFileInfo fi)
  {
          ...
  }

  protected override Errno OnGetFileAttributes (string path, ref Stat stbuf)
  {
          ...
  }	
	

I wrote a small file system to browse assemblies, you can get the source here.

To run my toy file system, do this:

	
	$ mono fuse.exe /tmp/u
	

That will get the file system going (currently you need the Mono.Fuse.dll library in the same directory where fuse.exe lives, and the libMonoFuseHelper.so in your library path).

With this, you can browse the types in your favorite assemblies from the shell (or for the less manly hackers in my readership: a file manager) like this:

	$ ls /tmp/u/mscorlib
	...
	Mono.Security.Cryptography.RSAManaged+KeyGeneratedEventHandler/
	Mono.Security.Cryptography.SymmetricTransform/
	Mono.Security.PKCS7/
	Mono.Security.PKCS7+ContentInfo/
	Mono.Security.PKCS7+EncryptedData/
	Mono.Security.PKCS7+EnvelopedData/
	...
	$ ls /tmp/u/mscorlib/Mono.Security.Cryptography.SymmetricTransform
	CanReuseTransform               GetHashCode          OutputBlockSize
	CanTransformMultipleBlocks      get_InputBlockSize   ToString
	Equals                          get_OutputBlockSize  TransformBlock
	get_CanReuseTransform           GetType              TransformFinalBlock
	get_CanTransformMultipleBlocks  InputBlockSize

	

Once you are done with the exciting world of browsing your assemblies with ls and cd you can umount your file system like this:

	$ fusermount -u /tmp/u
	

Very nice work Jon!