We vastly underestimated the Slashdot effect. There were 85k hits in the first hour since we went live, and then the machine collapsed under the weight and has remained in that state despite repeated attempts to get some data out of it.

None of the betas really had this problem, we got some mild load, but today the load on the machine was insane.

I made a few posts today: New Windows.Forms plan, the new cvs rules in the post 1.0 world and finally a thank you note to developers.

Mike Kestner has posted an update on Gtk# in the release.

Afternoon at Usenix

I had a great afternoon at Usenix, met lots of good friends again.

Tomorrow: Rob Pike's keynote at 9am.

The OMG is one step ahead: they have a RFP for the Minimal CORBA. Beautiful.

Apple's new Spotlight and Beagle

Apple's new Spotlight is remarkably similar to Nat's Beagle and Nat's Dashboard.

Nat's tool was demostrated yestearday at GUADEC, here is a photo from the talk.

I have been asked recently whether we should fork the C# language and add extensions and improvements to the language and the class libraries to deviate from Microsoft (there are plenty of little small things that can be done with relatively no effort).

I do not believe that making the Mono C# compiler incompatible with the Microsoft and the ECMA standard is a good idea. A big benefit of having a compatible language is that source code can be interchanged between the two platforms with ease. If we were to modify the language to have features not found in the Microsoft compiler, we would make the life of our end users (software developers) harder for no good reason.

On the other hand, I would encourage folks to prototype their ideas on the compiler: if your idea is great, we could help drafting a proposal and bring that forward to ECMA and Microsoft, and who knows, it could even become part of the standard.

Nullable types

I personally did not like the C# language support for nullable types I felt they had no place in the language, and I think a lot of people feel the same way.

I changed my opinion on its usefulness when I explained them to a couple of friends: they immediately saw the benefits to them. It was clear that my programmer background was not the same programmer background that nullable types addressed.

A good friend was asking me about why I had abandoned CORBA (I did not). Here is my response:

On the CORBA question: I have not particularly abandoned the idea of CORBA. It was just that CORBA as a platform to solve the multi-lingual issue was too hard (too huge of an investment, steep learning curve). In fact, I would like to use more of IIOP as a replacement for remoting and web services in key places.

I think that *some* elements of CORBA are extremely useful and are better than many of the Microsoft proposed APIs/protocols, but the problem with CORBA is that you must move carefully: it is too easy to get trapped in that world of standards and try to implement and use everything.

Some bits of CORBA are extraordinary, but teaching it is hard given the large scope of it: what pieces of it must be ignored and what pieces are followed is a tricky part.

I think the Next Generation Web Services (WS-*) world has reached the same level of complexity that CORBA achieved in an effort to satisfy the users requests. It seems that WS-* is a victim of its own success: once SOAP web services could be produced and consumed easily with `netcat', but today, realistically to integrate with any of the advanced features you need a stack as complete and as complex as the various CORBA implementations.

Web Services were pushed in the same direction that CORBA was used, and it started to get used in places where CORBA was used, and they ended up with pretty much the same thing CORBA had, and sadly without some of the benefits of it. Not a particularly fascinating subject.

Speaking of fascinating technologies, a few ex-CORBA people went to create a new RPC stack with a very precise set of features at ZeroC. It is called Ice

I first heard about Ice from Vladimir, who wrote his own implementation of the protocol in C#. It is available from the Mono CVS repository, and is a subset the features offered by ZeroC's product. ZeroC's product is dual licensed: GPL and Commercial and today they support Java and PHP with a C# version in the works.

Having being subject to three years of propaganda, this movie feels like an Oasis.

Too short, seems like a lot of interesting material was left out.

Various reports have arrived that Microsoft was demoing Mono at the LinuxDays. I do not have more data other than a Windows machine was used to build a web application, copied to Linux and ran there and that they also showed Monodoc.

Nice!

Mandatory Movie

Got tickets for the worst possible time for Farenheit's 9/11 showing tonight. I underestimated the demand, all the other showings were sold out.

Mono Freeze

The Mono Freeze has continuted in preparation for the 1.0 release, everything is looking good.

My friend Jon Perr was running a political commentary site, called Perrspectives and using Google adwords to advertise it.

Here is the tale of the adwords censoring his site.

One of the best Daily Shows today. Jon Stewart was amazing.

Atom support in LameBlog

Lame Blog now supports Atom using Atom.NET. It supports Mono out of the box (yup, nice Makefile and all), and comes with awesome docs for it. Am still an Atom newbie, so I do not know if I got everything right, drop me a note if my Atom stinks.

It took 10 minutes, so do not expect Enterprise-enabled, transactional based atom feed just yet.

Cory from the EFF went to Microsoft to talk about DRM, here is a transcript which should be mandatory reading.

Joel keeps pumping out the gems.

Most importantly, he follows up with a concrete list of features that the web needs. Now is the time for all good hackers to join the Mozilla development.

A key to the proposal from Joel is that some high-level features must be incorporated into HTML in some form, and not be limited to server-side controls implemented with a particular technology (ASP.NET or Struts or PHP): it should be something that can be placed on a static HTML page.

My favorite conference is coming to town in a couple of weeks. Hope to see a lot of folks

Martin has been doing quite a lot of work on the Mono Debugger, getting nicer every day. And it has docs ;-)

A parser and scanner for VB.NET has been released by Microsoft. It is written in VB.

Manufacturing the Facts.

Kuwait Times: "U.S truck carrying radioactive material caught in Kuwait".

Tehran Times: "The MNA reported for the first time the coalition forces suspicious transfer of WMD parts from Kuwait to Southern Iraq by trucks."

Update: Someone researched this in depth here, and apparently the trucks were coming *out*, not in.

The Cocoa# developers got their first window showing on the MacOS X, and they also got inheritance working. This is a young binding, but here is a screenshot of what it looks like:

Cocoa# sample application.

Ross improved on a script from Matt to do web page thumbnails.

Here is the same written C#, Gtk# and Gecko#.

using System;
using Gtk;
using Gecko;

class X {
	static WebControl wc;
	static string output = "shot.png";
	static string url;
	static int width = -1;
	static int height = -1;
	
	static void Main (string [] args)
	{
		for (int i = 0; i < args.Length; i++){
			switch (args [i]){
			case "-width":
				try {
					i++;
					width = Int32.Parse (args [i]);
				} catch {
					Console.WriteLine ("-width requires an numeric argument");
				}
				break;
			case "-height":
				try {
					i++;
					height = Int32.Parse (args [i]);
				} catch {
					Console.WriteLine ("-height requires an numeric argument");
				}
				break;
			case "-help":
			case "-h":
				Help ();
				break;
				
			default:
				if (url == null)
					url = args [i];
				else if (output == null)
					output = args [i];
				else
					Help ();
				break;
			}
		}

		Application.Init();
		Window w = new Window ("test");
		wc = new WebControl ();
		wc.LoadUrl (args [0]);
		wc.NetStop += MakeShot;
		wc.Show ();
		wc.SetSizeRequest (1024, 768);
		w.Add (wc);
		w.ShowAll ();
		Application.Run();
	}

	static void Help ()
	{
		Console.WriteLine ("Usage is: shot [-width N] [-height N] url [shot]");
		Environment.Exit (0);
	}
	
	static void MakeShot (object sender, EventArgs a)
	{
		Gdk.Window win = wc.GdkWindow;
		int iwidth = wc.Allocation.Width;
		int iheight = wc.Allocation.Height;
		Gdk.Pixbuf p = new Gdk.Pixbuf (Gdk.Colorspace.Rgb, false, 8, iwidth, iheight);
		Gdk.Pixbuf scaled;
		
		p.GetFromDrawable (win, win.Colormap, 0, 0, 0, 0, iwidth, iheight);
		if (width == -1){
			if (height == -1)
				scaled = p;
			else
				scaled = p.ScaleSimple (height * iwidth / iheight, height, Gdk.InterpType.Hyper);
		} else {
			if (height == -1)
				scaled = p.ScaleSimple (width, width * iheight / iwidth, Gdk.InterpType.Hyper);
			else
				scaled = p.ScaleSimple (width, height, Gdk.InterpType.Hyper);
		}
		
		scaled.Savev (output, "png", null, null); 
		Application.Quit (); 
	}
}

Jeff posted on portability of Java vs .NET code in an article.

First lets state the obvious: you can write portable code with C# and .NET (duh). Our C# compiler uses plenty of .NET APIs and works just fine across Linux, Solaris, MacOS and Windows. Scott also pointed to nGallery 1.6.1 Mono-compliance post which has some nice portability rules.

Porting an application from the real .NET to Mono is a relatively simple exercise in most cases (path separators and filename casing). A situation that I would like to fix on upcoming versions of Mono to simplify the porting (with some kind of configuration flag).

It is also a matter of how much your application needs to integrate with the OS. Some applications needs this functionality, and some others do not.

If my choice is between a system that does not let me integrate with the OS easily or a system that does, I personally rather use the later and be responsible for any portability issues myself.

That being said, I personally love to write software that takes advantage of the native platform am on, specially on the desktop. I want to take advantage of what my desktop has to offer: Gtk# (when using Linux), Cairo, OpenGL, Cocoa# (when using the Mac), GConf, Gnome Printing, and access to Posix.

If my software uses all of the above libraries, will it be easily portable? Most likely not.

Consider what the iFolder team is doing: they are writing the core libraries as a cross platform reusable component. This component is called "Simias" and provides the basic synchronization and replication services. Simias works unchanged on Linux, MacOS, Windows and Solaris. Like every other cross platform software, it must be tested on each platform, and bugs on each platform must be debugged.

This is not different than doing any other kind of cross platform development.

Then they integrate with each operating system natively at the user interface level. Windows.Forms and COM on Windows; Gtk# on Linux and in the future Cocoa# on the Mac.

Although Gtk# looks and feels like Windows.Forms on Windows, the problem that they were facing is that Gtk# was an extra download for people using iFolder, and they chose to keep things simple for the end user.

Mono as a new Wine?

Although Jeff's post is fairly naive and not that interesting I do have a problem with his follow up: Mono is not just a `Wine-like' technology to emulate an API.

Mono is a complete development stack, with a standard core from ECMA and ISO. Jeff has obviously not written any code with Mono, or he would know that it is quite an enjoyable standalone development platform as oppposed to just a runtime.

Mono is also not limited to run the .NET code, thanks to IKVM: a Java VM written entirely in C# and .NET, we can run Java code just as well as .NET on the same virtual machine, and have them happily talking to each other.

Nat Interview

Another interview with Nat on the Novell Linux Strategy.

Nat and Dan in Bangalore.

Laura in Kona

Bangalore.

Arturo's Laptop

Arturo is a modern day Indiana Jones, a resourceful humanist. On this picture with his laptop and portable 17" monitor, making up for a hard learned lesson: do not fight gravity with your notebook LCD screen.

Arturo and his C64-like TiBook.

Summer movies: The Corporation and Farenheit 9/11

Trailers are now available on Rotten Tomatoes, and a list of dates in the US

Can not wait to see Michael Moore's new movie, opens on June 25th!

Venus Transit

Venus Transit on Tuesday.