What is the point of a blog that you have to log in to leave a comment?

This has annoyed me twice today. I wanted to leave a comment on two peoples blogs – they are using Blogger. For some reason they think its a good idea to require authentication on their blogs – which entails me creating a Blogger account – I don’t want a blogger account!!!

There is some great content getting posted up on Blogger accounts – I’d love to respond to it but its just too much effort. Thats why the blog stuff integrated with the blog services included with MSDN Connection membership – it required Passport to sign in to view the posts if I recall correctly (that and there was no RSS feed?!?!).

Lesson number one about blogs people – you can’t put up walls between you and the people you want to have a distributed discussion with – it just won’t work. Paul’s idea is interesting though.

Skype Customer Service? Dunno – never needed to try them.

The question has been asked – is Skype customer service up to snuff? Personally, I haven’t really had any problems with the service – but because of that I haven’t had to use customer support. The SkypeOut stuff works fine.

What version of .NET 2.0 will the Indigo CTP be stabilised against?

Does anyone know what version of .NET 2.0 the Indigo CTP will be stabilised against? I’ll be running BETA 2 pretty much as soon as it comes out which is close to when the Indigo CTP will hit the streets. It would be nice if I could use them together.

Bad Meeting Requests.

Mea Culpa.

The next step in server virtualization?

Amazing as products like Virtual Server and VMware are, I’ve always felt that they are most applicable to people like application developers who need to run incompatible versions of development tools to support their work and that the vision of true virtualisation wasn’t being realised.

Because I am interested in this stuff I subscribed to the RSS feed at virtualization.info and a few days ago it turned up a treat. Apparently a company called Virtual Iron has come up with a way to emulate a single system which is actually running across multiple machines.

I hope Microsoft is looking at this and seeing how they could apply this idea to their server platform because it could just be the critical element in the Dynamic Systems Initiative. With the arrival of tools like Visual Studio Team System which actively encourage development teams to model their deployment environment it would be excellent for them to be able cast that model out onto an ocean of computers and have that model automatically acquire the underlying computing resources it needs to execute.

It also adds fuel to my argument in this post that developers need to become more aware of concurrency in their application architectures – especially server applications. Last week in my INDUSTRIAL STRENGTH .NET class in Melbourne I predicted that within ten years (or something like that) we could easily see cheap systems sporting 30+ processor cores finding their way to the mid-range market (maybe even the desktop).

If you take that in hand with this offering from Virtual Iron we will have enormous amounts of processing power that can be easily deployed – but only leveraged if you know how to write concurrent software. Before long we will probably start to see attributes we can mark out application assemblies up with that declaritively state what the concurrency characteristics of our code are, although this may only be a temporary measure until runtime optimisers can work across virtual systems that span multiple physical devices.

Interesting times ahead.

Covariance and Contravariance for Delegates

I got an e-mail today from someone asking a question about being able to wireup all the events of a control to a single method, for example – a ListBox. In the current version of the framework this isn’t possible because the delegate types that constrain the event vary meaning that one single method signature wouldn’t be acceptable to all. For example – the following code wouldn’t work:

this.m_ListBox.MeasureItem += new EventHandler(this.MyEventHandler);
private void MyEventHandler(object sender, EventArgs e) {};

In an OO platform like this its kind of counter-intuitive that you would have this restriction – after all EventArgs is the base class for MeasureItemEventArgs – why can’t the runtime gracefully cast MeasureItemEventArgs to EventArgs for us – isn’t that what the events pattern is all about?

Well – it turns out that the CLR team agrees with us and so Program Manager and fellow Tim Tam eater Joel Pobar became responsible for that feature (along with many others) inside the next version of the CLR that is going to be shipping with Whidbey. The feature is called Covariance and Contravariance.

I found this post by Wesner Moise which sums up the feature really nicely (sorry Joel, I’m sure you posted about this but I couldn’t find it – IINIGIDE).