No coding exercise. I'm not interested.

Richard, one of my colleagues at Readify, wrote an interesting blog post about how he learnt the hard way that if you want to hire a software developer you need to check her/his skills by giving her/him a coding exercise to solve. If you don’t do this you are simply asking for trouble. Have a look at Richard’s blog post for more details.
When I was looking for a job in Australia and I got in touch with a few companies and some of them didn’t require me to write any code. Those companies were immediately off my list. Moving to the other hemisphere was risky enough that I didn’t want to deal with companies that didn’t pay attention to their recruitment process. What is more if a company doesn’t bother to interview you properly that might be a sign that they won’t treat you well.
Just my two cents.

Subtext 1.9.5 -> 2.1.2

I’ve just upgraded my blog from Subtext 1.9.5 to Subtext 2.1.2. The upgrade has been smooth and I haven’t had to make any manual changes. I’m really impressed. Keep up good work guys! I can’t wait for Subtext 3.0 which is meant to based on ASP.NET MVC. Now I need to find a better skin for my blog but taking into account my UI skills that might take some time ;).

5 days SOA and DDD training by Udi Dahan in Melbourne

If there are enough people then this actually might happen. If you are interested and I’m telling you, you should :) then express that as soon as possible by  contacting Simon. You can find an overview of the training here.

Quick look at STM.NET performance

STM as an idea looks interesting and definitely has a lot of advantages over regular locking. It helps prevent deadlocks, makes easier to compose components that implement some kind of synchronization, helps eliminate nested locks, supports retries and so on. You can find the full list of goodness here.
When I found out that STM.NET(based on .NET 4.0) is out my first question was related to its performance. I put together a simple test and I have to say that in most scenarios STM.NET is an overkill. Sure, it’s a research project and it hasn’t been productized which means it’s not optimized and it’s not ready for prime time. But still, on average it’s 20x slower than the regular lock statement. That’s a lot taking into account that in most cases developers use very simple locking strategies and try to avoid nested locks. If Microsoft can bring it down to 2x then it is a completely different story.
The results:

The code of the benchmark:

using System;
using System.Threading;
using System.Collections;
using System.TransactionalMemory;
using System.Collections.Generic;
using System.Diagnostics;
class Program
{
    public delegate void CustomAction();
    [AtomicNotSupported]
    static void Main(string[] args)
    {
        var iterations = 1000000;
        Console.WriteLine("Number of Threads  | STM.NET [ms] |" + 
                          "Regular locking [ms] | Times slower");
        for (var i =1 ; i < 15; i++)
        {
            Test(i, iterations);  
        }
        
        Console.ReadLine();
    }
    private static void Test(int numberOfThreads, int iterations)
    {
        var storage = new Storage();
        CustomAction action = () =>
        {
            Atomic.Do(() =>
            {
                storage.UpdateByOne();
            });
        };
        var stm = Execute(numberOfThreads, iterations, action, storage);
        storage = new Storage();
        CustomAction action1 = () =>
        {
            lock (storage)
            {
                storage.UpdateByOne();
            }
        };
        var locking = Execute(numberOfThreads, iterations, action1, storage);
        int slower = (int)(stm.ElapsedMilliseconds / locking.ElapsedMilliseconds);
        var message = String.Format("{0}\t\t\t{1}\t\t\t{2}\t\t\t{3}", numberOfThreads, 
                                    stm.ElapsedMilliseconds, 
                                    locking.ElapsedMilliseconds, slower);
        Console.WriteLine(message);
    }
    private static Stopwatch Execute(int numberOfThreads, int iterations, 
                                     CustomAction action, Storage storage)
    {
        var stopwatch = Stopwatch.StartNew();
        var threads = new List<Thread>();
        for (var i = 0; i < numberOfThreads; i++)
        {
            var thread = new Thread(() =>
            {
                for (var j = 0; j < iterations; j++)
                {
                    action();
                }
            });
            threads.Add(thread);
        }
        foreach (var thread in threads)
        {
            thread.Start();
        }
        foreach (var thread in threads)
        {
            thread.Join();
        }
        stopwatch.Stop();
        if (numberOfThreads * iterations != storage.Result)
        { 
            var message = String.Format("Incorrect value. Expected: {0} Actual: {1}", 
                                         numberOfThreads*iterations, storage.Result);
            throw new ApplicationException(message);
        }
        return stopwatch;
    }
}
public class Storage
{
    private long value;
    public void UpdateByOne()
    {
        value = value + 1;
    }
    public long Result
    {
        get { return value; }
    }
}