Functional Fun

A Fiddler plug-in for inspecting WCF Binary encoded messages

2009-11-02T17:59:00.001Z

If ever you're needing to debug the interaction between a Web Service and its clients, Microsoft’s Fiddler is the tool to use - this includes WCF Services so long as they're using a HTTP transport. The only thing Fiddler won't do is decode messages that are sent using WCF's proprietary Binary encoding - until today, that is: at lunch time, I took advantage of Fiddler's neat extensibility mechanism and created a rough-and-ready Inspector that will translate binary messages from gobbledegook to plain xml for your debugging pleasure.

You can download the plug-in and source from MSDN Code Gallery. To use it, just drop the plug-in in the Inspectors folder of your Fiddler installation. Once you've reloaded Fiddler, switch to the Inspectors tab and look for WCF Binary.

Implementation Notes

There’s a very helpful page on the Fiddler site which tells you how to build Inspectors in .Net.
Fiddler gives each Inspector the raw bytes of each message, and it can do with it what it likes. Here’s how I decode a WCF Binary encoded message:

using System;
using System.Runtime.Serialization;
using System.ServiceModel.Channels;

...

private static readonly BufferManager _bufferManager = BufferManager.CreateBufferManager(int.MaxValue, int.MaxValue);

...

private string GetWcfBinaryMessageAsText(byte[] encodedMessage)
{
    var bindingElement = new BinaryMessageEncodingBindingElement();
    var factory = bindingElement.CreateMessageEncoderFactory();
    var message = factory.Encoder.ReadMessage(new ArraySegment<byte>(encodedMessage), _bufferManager);
    return message.ToString();
}

Getting the MethodInfo of a generic method using Lambda expressions

2009-10-22T07:00:00.000+01:00

Getting hold of the MethodInfo of a generic method via Reflection (so you can invoke it dynamically, for example) can be a bit of a pain. So this afternoon I formulated a pain-killer, SymbolExtensions.GetMethodInfo. It’s not fussy: it works for non-generic methods too. You use it like this:

internal class SymbolExtensionsTests
{
    [Test]
    public void GetMethodInfo_should_return_method_info()
    {
        var methodInfo = SymbolExtensions.GetMethodInfo<TestClass>(c => c.AMethod());
        methodInfo.Name.ShouldEqual("AMethod");
    }

    [Test]
    public void GetMethodInfo_should_return_method_info_for_generic_method()
    {
        var methodInfo = SymbolExtensions.GetMethodInfo<TestClass>(c => c.AGenericMethod(default(int)));

        methodInfo.Name.ShouldEqual("AGenericMethod");
        methodInfo.GetParameters().First().ParameterType.ShouldEqual(typeof(int));
    }

    [Test]
    public void GetMethodInfo_should_return_method_info_for_static_method_on_static_class()
    {
        var methodInfo = SymbolExtensions.GetMethodInfo(() => StaticTestClass.StaticTestMethod());

        methodInfo.Name.ShouldEqual("StaticTestMethod");
        methodInfo.IsStatic.ShouldBeTrue();
    }
}

The active ingredient, as you can see, is Lambda expressions:

using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System;

public static class SymbolExtensions
{
    /// <summary>
    /// Given a lambda expression that calls a method, returns the method info.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="expression">The expression.</param>
    /// <returns></returns>
    public static MethodInfo GetMethodInfo(Expression<Action> expression)
    {
        return GetMethodInfo((LambdaExpression)expression);
    }

    /// <summary>
    /// Given a lambda expression that calls a method, returns the method info.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="expression">The expression.</param>
    /// <returns></returns>
    public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
    {
        return GetMethodInfo((LambdaExpression)expression);
    }

    /// <summary>
    /// Given a lambda expression that calls a method, returns the method info.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="expression">The expression.</param>
    /// <returns></returns>
    public static MethodInfo GetMethodInfo<T, TResult>(Expression<Func<T, TResult>> expression)
    {
        return GetMethodInfo((LambdaExpression)expression);
    }

    /// <summary>
    /// Given a lambda expression that calls a method, returns the method info.
    /// </summary>
    /// <param name="expression">The expression.</param>
    /// <returns></returns>
    public static MethodInfo GetMethodInfo(LambdaExpression expression)
    {
        MethodCallExpression outermostExpression = expression.Body as MethodCallExpression;

        if (outermostExpression == null)
        {
            throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only.");
        }

        return outermostExpression.Method;
    }
}

Flattery (almost) works

2009-10-15T07:00:00.000+01:00

I checked my email using my smart-phone the other night, and found this:

Anonymous has left a new comment on your post "I'll be speaking at PDC 2008...":

Masters thesisI have been through the whole content of this blog which is very informative and knowledgeable stuff, So i would like to visit again.

How nice. I'm always chuffed when somebody takes the time to leave an appreciative comment on my blog. And this one stoked my ego. At a glance it seemed that Mr (or Ms) Anonymous was likening the quality and content of my work to a Masters thesis; though the wording of the message was a little strange ... perhaps English was not their native language?

Ever polite, the next time I went to my PC I fired up the browser and found the appropriate page on my blog with the intention of thanking Mr (or Ms) Anonymous for their kind words and inviting them to visit as often as they liked.

But the browser revealed what my phone's mail client had concealed. The words "Masters Thesis" were underlined in blue - a hyperlink to a site whose page rank I will not promote by repeating the link. Cue sound of hissing steam as ego is rapidly quenched.

Out of curiosity at the wares being peddled by these flattersome spammers, I followed the link, and found offers of written-to-order essays or Masters Thesis - guaranteed native English, and plagiarism free. The kind-hearted scholars at the site will also undertake to complete assignments and exams for online courses and can guarantee to ace them all - for a small consideration of $2000 plus $300 per exam.

Needless to say, I put my blog's trash-can button to good use.

Practical LINQ #4: Finding a descendant in a tree

2009-10-10T18:20:00.001+01:00

Trees are everywhere. I don’t mean the green, woody variety. I mean the peculiar ones invented by programmers that have their root somewhere in the clouds and branch downwards. As inevitably as apples fall from trees on the heads of meditating physicists, so coders find themselves writing code to traverse tree structures.

In an earlier post we explored the tree created by the UI Automation API representing all the widgets on the Windows desktop. One very common tree-traversal operation is finding a particular child several nodes down from a root starting point. I gave the example of locating the Paint.Net drawing canvas within the main window of the application:

// find the Paint.Net drawing Canvas
 var canvas = mainWindow.FindDescendentByIdPath(new[] {
     "appWorkspace",
       "workspacePanel",
         "DocumentView",
           "panel",
             "surfaceBox" });

What we have here is an extension method, FindDescendentByIdPath, that starts from a parent element and works its way down through the tree, at each level picking out the child with the given Automation Id. In my last post, I skipped over my implementation of this method, but it deserves a closer look because of the way it uses Functional techniques and LINQ to traverse the hierarchy.

So here it is:

public static AutomationElement FindDescendentByIdPath(this AutomationElement element, IEnumerable<string> idPath)
{
    var conditionPath = CreateConditionPathForPropertyValues(AutomationElement.AutomationIdProperty, idPath.Cast<object>());

    return FindDescendentByConditionPath(element, conditionPath);
}

public static IEnumerable<Condition> CreateConditionPathForPropertyValues(AutomationProperty property, IEnumerable<object> values)
{
    var conditions = values.Select(value => new PropertyCondition(property, value));

    return conditions.Cast<Condition>();
}

public static AutomationElement FindDescendentByConditionPath(this AutomationElement element, IEnumerable<Condition> conditionPath)
{
    if (!conditionPath.Any())
    {
        return element;
    }

    var result = conditionPath.Aggregate(
        element,
        (parentElement, nextCondition) => parentElement == null
                                              ? null
                                              : parentElement.FindChildByCondition(nextCondition));

    return result;
}

The first thing we do is convert the sequence of Automation Id strings into a sequence of Conditions (actually PropertyConditions) that the UI Automation API can use to pick out children of parent elements. This is handled for us by the CreateConditionPathForPropertyValues method in line 8.

The actual method of interest is FindDescendentByConditionPath, starting in line 15. Here we put the Enumerable.Aggregate method to a slightly unconventional use. Considered in the abstract, the Aggregate method takes elements from a sequence one by one and performs an function (of your choice) to combine the element with the previous result; the very first element is combined with a seed value.

In this case the seed value is the parent element at the top of tree, the sequence of elements is the list of conditions that we use to pick out the child at each level of the tree. And we provide a lambda function that, each time it is called, takes the element it found in the previous iteration, together with the next condition from the list and uses an extension method that I demonstrated in the earlier blog post, FindChildByCondition, to find the appropriate child.

I’ve found this method a great help when monkeying around in UI Automation trees. If you think you might, look for it in the the source code from last time.

Work around for WPF Bug: Drag and Drop does not work when executing a WPF application in a non-default AppDomain

2009-10-02T18:08:00.001+01:00

Today's task was implementing Drag/Drop to move items into folders. My estimate of yesterday was 6 hours to get the job done. That should have been plenty: then I discovered the bug.

We're creating an Excel Addin using Addin-Express (which is very like VSTO). All the UI for our add-in is built with WPF (naturally). When Addin Express hosts Add-ins for Excel, it isolates them each in their own App-Domain. Which is why today I came to add myself to the list of people who have reproduced this issue on the Connect website: "Drag and Drop does not work when executing a WPF application in a non-default AppDomain"

Googling around the problem, I found that Tao Wen had also encountered the problem, and had managed to find something of a work-around.

Having Reflectored around the WPF source-code a little, I can see that when WPF is hosted in a non-default App Domain, the check that the HwndSource class (which manages the Win32 Window object on behalf of the WPF Window class) does to ensure the code has the UnmanagedCode permission fails, so Windows do not register themselves as OLE Drop Targets (see the last few lines of the HwndSource.Initialize method)

Tao Wen's solution is to use reflection to directly call the internal DragDrop.RegisterDropTarget method. What his solution doesn't take into account is that, when the Window is closed it must unregister itself as a drop target.

Fortunately, by incrementing the _registeredDropTargetCount field in the HwndSource class we can ensure that HwndSource will itself call DropDrop.RevokeDropTarget when it's disposed (see about half-way down the HwndSource.Dispose method).

For anybody else who is blocked by the same issue, I've created a little class that will implement the hack on a Window class. Be warned: it uses evil reflection code to access private members of WPF classes, and it might break at any time. Use it at your own risk.

/// <summary>
/// Contains a helper method to enable a window as a drop target.
/// </summary>
public static class DropTargetEnabler
{
    /// <summary>
    /// Enables the window as drop target. Should only be used to work around the bug that
    /// occurs when WPF is hosted in a non-default App Domain
    /// </summary>
    /// <param name="window">The window to enable.</param>
    /// <remarks>
    /// This is a hack, so should be used with caution. It might stop working in future versions of .Net.
    /// The original wpf bug report is here: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=422485
    /// </remarks>
    // This code was inspired by a post made by Tao Wen on the Add-in Express forum:
    // http://www.add-in-express.com/forum/read.php?FID=5&TID=2436
    public static void EnableWindowAsDropTarget(Window window)
    {
        window.Loaded += HandleWindowLoaded;
    }

    private static void HandleWindowLoaded(object sender, RoutedEventArgs e)
    {
        // See the HwndSource.Initialize method to see how it sets up a window as a Drop Target
        // also see the HwndSource.Dispose for how the window is removed as a drop target
        var window = sender as Window;

        IntPtr windowHandle = new WindowInteropHelper(window).Handle;

        // invoking RegisterDropTarget calls Ole32 RegisterDragDrop
        InvokeRegisterDropTarget(windowHandle);

        // to make sure RevokeDragDrop gets called we have to increment the private field
        // _registeredDropTargetCount on the HwndSource instance that the Window is attached to
        EnsureRevokeDropTargetGetsCalled(windowHandle);
    }

    private static void InvokeRegisterDropTarget(IntPtr windowHandle)
    {
        var registerDropTargetMethod = typeof(System.Windows.DragDrop)
            .GetMethod("RegisterDropTarget", BindingFlags.Static | BindingFlags.NonPublic);
        if (registerDropTargetMethod == null)
        {
            throw new InvalidOperationException("The EnableWindowAsDropTarget Hack no longer works!");
        }

        registerDropTargetMethod
            .Invoke(null, new object[] { windowHandle });
    }

    private static void EnsureRevokeDropTargetGetsCalled(IntPtr windowHandle)
    {
        var hwndSource = HwndSource.FromHwnd(windowHandle);
        var fieldInfo = typeof(HwndSource).GetField("_registeredDropTargetCount", BindingFlags.NonPublic | BindingFlags.Instance);
        if (fieldInfo == null)
        {
            throw new InvalidOperationException("The EnableWindowAsDropTarget hack no longer works!");
        }

        var currentValue = (int) fieldInfo.GetValue(hwndSource);
        fieldInfo.SetValue(hwndSource, currentValue + 1);
    }
}

Use it like this:

public partial class MyWindow
 {
        public MyWindow()
        {
            InitializeComponent();
            DropTargetEnabler.EnableWindowAsDropTarget(this);
        }
}

Googling a tribute to my Grandfather

2009-09-30T07:00:00.000+01:00

My Grandpa, Dr R.A.F. Jack, passed away a few months ago, aged 89. It was a comfort at his funeral to see how highly regarded he was in the community and beyond: as well as being the village doctor for close to half-a-century, he was a respected and well-loved elder in our church, and he was known in the medical field for his work with homeopathy.

Though he pre-dated the internet by many years, when I googled his name, I turned up several references. Admittedly, these results were somewhat drowned out by pages referring to a certain aviationary body born two years before him. But once I’d filtered those out, I found a few gems.

I discovered that Amazon stock his book, Homeopathy in General Practice, currently number 1,252,945 on their Best Seller list. I found a bibliography of his other published works. Then there was a magazine article about his work written by an appreciative patient. She records his unorthodox method of checking that she wasn’t suffering from a trapped nerve – putting a sandbag under her knee, and bouncing another on top!

And finally, in the Letters page of the British Medical Journal from June 1955 I found this:

Redundant Circulars
Dr. R. A. F. JACK (Bromsgrove) writes: My young family have
helped me to-deal with the surfeit of advertisements that daily
swell my morning post. The elder two, who by now have lost
all interest in opening them, content themselves with collecting
the stamps and bemoan the fact that so many envelopes these
days are franked. -They then pass them on to the younger two,
who, armed with a pair of scissors each, cut out patterns or any
interesting figures or illustrations that take their fancy. They
preserve all blotters for me; and all large white envelopes that
can be ungummed are put aside for subsequent painting practice
or for conversion into paper darts. The result is that my wife and
I get an extra quarter of an hour's peace each morning, so that in
one way or another we all benefit from the unremitting onslaught
of the various drug houses.

The eldest of the two stamp collectors mentioned is my Dad, now himself a GP, and semi-retired!

If your WCF service is unexpectedly receiving a null parameter value, try this…

2009-09-25T17:56:00.002+01:00

An interesting problem ate up an hour and a half of my life yesterday morning. It was all to do with a WCF service.

The parameter that I was carefully formulating on one end of the wire and passing to my service proxy was not being received by my service at the other end - instead it was getting a null value. It worked the day before - why had it stopped working overnight?

Intercepting the http traffic with the help of the wonderful Fiddler (and a useful article about Fiddlering .Net by Rick Strahl) confirmed that a serialized version of the parameter was indeed being sent down the pipe and was arriving at the server - so why wasn't my service getting it?

After much head-scratching, I thought of checking the history of our Server project in the Source code repository. That gave me the clue I needed. In the file containing the interface which defines the service's contract, I noticed that the name of the parameter on the method in question had been changed.

Now at this point I should explain that, partially inspired by this article, we have chosen to eschew the usual route of having Visual Studio create our Service proxies for us. We prefer to share the assembly containing the Service contract interfaces and Data Contract objects between the client and the server projects. This approach works very nicely most of the time. It saves us having to "Update Service Reference" every time we change the shape of the sever side, and it reduces our dependence on the magic that Visual Studio usually works on our behalf.

Where this approach does get a little bit messy is when you want to have asynchronous versions of the operations on the client side (Begin[Operation] and End[Operation] methods). Clearly we don't need these on the contract implemented by the Server, so what we end up doing is creating a copy of the Contract named something like IContractClient which contains both the synchronous and also asynchronous versions of the operations.

Now can you see where this is going?

The problem turned out to be that the name of the parameter on the client version of the contract was different to that on the server version of the contract. The message on the wire contained the client’s (incorrect) name for the parameter. So presumably, when WCF received the message, it failed to match the parameters with those expected by the method on the server, shrugged its shoulders, and passed in a null value to the method.

But the story doesn't end there. I found the client version of the contract interface, made what I thought was the necessary correction, and whilst Visual Studio was rebuilding I announced to my colleague that I'd fixed the problem. Only to find, when I tested it, that it was still broken.

More head-scratching, and Fiddlering: the old parameter name was still being passed through. Huh? Clean and Rebuild to make definitely sure the change had stuck. Still no go.

And then the final ray of light. On the client side we were using the asynchronous version of the operation, so it was the Begin[Operation] method that I'd corrected. And I'd left the synchronous version untouched.

Once that was corrected everything started working, and I could finally begin the day's work.

In conclusion, for all you googlers:

If your WCF service is receiving null values instead of the parameters you are expecting, check that the parameter names on your methods on the client version of the contract match those on the server version of the contract. And on the client side, be sure to check both the synchronous and asynchronous definitions of your methods.

Introducing HymnSheet – free, simple song presentation software for Churches and Schools

2009-08-25T07:00:00.000+01:00

Our church jumped into the computer age a few years back. We ditched the Overhead Projector that had served us faithfully for many years, and acquired one of its digital brethren, along with a laptop. Ah, OHPs – those were the days – amazing what they could do with just a few lights, lenses, mirrors, and on a good day, no smoke. Anyway, I volunteered to sort out some software to do what the old OHP did for us – display songs on the screen for the Sunday School scholars to sing.

Powerpoint was an obvious first candidate, but rejected after a few moments consideration: our Sunday School leader likes to be able to add choruses to the mix at a moments notice: imagine try to insert slides into a Powerpoint presentation on the fly!

Then I scoured the ‘net for more specialised alternatives – and found plenty.But I noticed two things about all of them: firstly, they cost money; and secondly, all of them did too much – we prefer not to have our attention distracted from worship by snazzy graphics and alpha-blended video, or by nursery notices popping up to inform Mrs Jones that little Johnny needs his nappy changing.

What self-respecting programmer would not see this state of affairs as a challenge? Surely it would only take a few evenings to bash out something that would work exactly the way we wanted it to?

So (a few)^10 evenings later I had a little application ready to use. And we’ve been using it successfully for the last four years. Dragging and dropping song titles into a playlist sure beats sorting through a deck of transparencies.

Ever since I started this blog, I’ve been intending to put the application and source code online in the hope that others will find it useful. Finally I’ve got round to it. It is my birthday gift to you all (28 today – I reckon I’ll start feeling grown up in about two years time!).

What you should know about HymnSheet

So here it is, imaginatively named HymnSheet: simple song presentation software, especially suitable for children’s services, and, I imagine, School assemblies and music lessons. It features:

Support for dual monitors (or a laptop and a projector). One monitor displays the control screen, the other the song display
Drag-and-drop interface for putting songs into your play-list and for reordering them on the fly
Ability for you to highlight the current line of the song, to assist children learning to read
Easy to use song editor for adding your own songs to the song library
Whole song displayed at once on screen, with key shortcuts for scrolling between verses and the chorus of the song.

Get started by downloading the installer (note that you’ll need the .Net Framework installed on your computer) and reading the user guide. I’ve also made available some sample hymns and choruses (mostly of the more traditional kind) to get you started.

If you find this useful, you might like to help me persuade my wife that it was worth my while - if you’re sufficiently persuasive, she may allow me the time to add some new features:

Points of interest in the Source Code

For the more technically minded, I’ve made the source code to HymnSheet available – feel free to adapt it and add to it if you want – I’d love to hear from you if you do. Some points of interest in the source code :

The code is written in VB.Net. I know, I’m sorry. Reason is, I started working on this in the days before I had broadband. At the time I only had a CD of Visual Basic 2005 Express Beta which I’d picked up at a conference. By the time I had a a proper language installed on my machine, I didn’t fancy the job of rewriting ;-). Maybe one day…
Songs are stored in xml format. I use an XSL transform to turn this into HTML (with CSS to style it) and then display it in a Webbrowser control (maximised to fill the whole of the display screen). This gives you complete control over the way songs are presented. In particular, you might want to change the fonts or colours – the settings for these are in the songs.css file.
If you’ve never taken a look at the Webbrowser control, you should – it’s cool. As well as letting you load HTML from memory, it provides a managed DOM view of the HTML document, complete with events; you can also invoke any scripts embedded in the page.
I use some Javascript to animate the movement between verses. From IE 7 onwards, the default security settings prevent javascript from running in a HTML document that is loaded from memory (as is the case in HymnSheet). If you host the Webbrowser control in an application and want to enable javascript, you need to set a key in the registry: [HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER]\SOFTWARE\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BLOCK_LMZ_SCRIPT\[You executable name.exe], with value of 0. I do this in the installer, but I’ve also created a class with a method that will enable scripting for the current application: look for it in the source code – it’s called EnableWebBrowserScripting.
I’ve included the source code for the installer (see HymnSheet.wxs). If you want to build this, you’ll need to install WiX, the Windows Installer XML toolkit; you might also want to try out the excellent WixEdit for editing Wix scripts.

An introduction to UI Automation – with spooky spirographs

2009-08-04T21:49:00.001+01:00

A few weeks ago, I unearthed a hidden gem in the .Net framework: the UIAutomation API. UI Automation made its entrance as part of .Net 3.0, but was overshadowed by the trio of W*Fs – if they’d named it Windows Automation Foundation it might have received more love! UIAutomation provides a robust way of poking, prodding and perusing any widget shown on the Windows desktop; it even works with Silverlight. It can be used for many things, like building Screen Readers, writing automated UI tests – or for creating a digital spirit to spook your colleagues by possessing Paint.Net and sketching spirographs.

The UI Automation framework reduces the entire contents of the Windows Desktop to a tree of AutomationElement objects. Every widget of any significance, from Windows, to Menu Items, to Text Boxes is represented in the tree. The root of this tree is the Desktop window. You get hold of it, logically enough, using the static AutomationElement.RootElement property. From there you can traverse your way down the tree to just about any element on screen using two suggestively named methods on AutomationElement, FindAll and FindFirst.

Each of these two methods takes a Condition instance as a parameter, and it uses this to pick out the elements you’re looking for. The most useful kind of condition is a PropertyCondition. AutomationElements each have a number of properties like Name, Class, AutomationId, ProcessId, etc, exposing their intimate details to the world; these are what you use in the PropertyCondition to distinguish an element from its siblings when you’re hunting for it using one of the Find methods.

Finding Elements to automate

Let me show you an example. We want to automate Paint.Net, so first we fire up an instance of the Paint.Net process:

private string PaintDotNetPath = @"C:\Program Files\Paint.NET\PaintDotNet.exe";

...

var processStartInfo = new ProcessStartInfo(paintDotNetPath);
var process = Process.Start(processStartInfo);

Having started it up, we wait for it to initialize (the Delay method simply calls Thread.Sleep with the appropriate timespan):

process.WaitForInputIdle();
Delay(4000);

At this point, Paint.Net is up on screen, waiting for us to start doodling. This is where the UIAutomation bit begins. We need to get hold of Paint.Net’s main Window. Since we know the Process Id of Paint.Net, we’ll use a PropertyCondition bound to the ProcessId property:

var mainWindow = AutomationElement.RootElement.FindChildByProcessId(process.Id);

You won’t find the FindChildByProcessId method on the AutomationElement class: it’s an extension method I’ve created to wrap the call to FindFirst:

public static class AutomationExtensions
{
   public static AutomationElement FindChildByProcessId(this AutomationElement element, int processId)
   {
       var result = element.FindChildByCondition(
           new PropertyCondition(AutomationElement.ProcessIdProperty, processId));

       return result;
   }

   public static AutomationElement FindChildByCondition(this AutomationElement element, Condition condition)
   {
       var result = element.FindFirst(
           TreeScope.Children,
           condition);

       return result;
   }
}

Having found the main screen, we need to dig into it to find the actual drawing canvas element. This is were we need UISpy (which comes as part of the Windows SDK). UISpy lays bare the automation tree of the desktop and the applications on it. You can use it to snoop at the properties of any AutomationElement on screen, and to make snooping a snap, it has a particularly helpful mode where you can Ctrl-Click an element on screen to locate the corresponding AutomationElement in the automation tree (click the mouse icon on the UISpy toolbar to activate this mode). Using these special powers it doesn’t take long to discover that the drawing canvas is an element with AutomationId property set to “surfaceBox”, and is a child of another element, with AutomationId set to “panel”, which in turn is a child of another element with [snip - I’ll spare you the details], which is a child of the Paint.Net main window.

To assist in navigating this kind of hierarchy (a task you have to do all the time when automating any non-trivial application), I’ve cooked up the FindDescendentByIdPath extension method (the implementation of which is a whole other blog post). With that, finding the drawing canvas element is as simple as:

// find the Paint.Net drawing Canvas
var canvas = mainWindow.FindDescendentByIdPath(new[] {
    "appWorkspace",
      "workspacePanel",
        "DocumentView",
          "panel",
            "surfaceBox" });

Animating the Mouse

Now for the fun part. Do you remember Spirographs? They are mathematical toys for drawing pretty geometrical pictures. But have you ever tried drawing one freehand? Well here’s your chance to convince your friends that you have artistic talents surpassing Michelangelo’s.

Jürgen Köller has very kindly written up the mathematical equations that produce these pretty pictures, and I’ve translated them into a C# iterator that produces a sequence of points along the spirograph curve (don’t worry too much about littleR, bigR, etc. – they’re the parameters that govern the shape of the spirograph):

private IEnumerable<Point> GetPointsForSpirograph(int centerX, int centerY, double littleR, double bigR, double a, int tStart, int tEnd)
{
   // Equations from http://www.mathematische-basteleien.de/spirographs.htm
   for (double t = tStart; t < tEnd; t+= 0.1)
   {
       var rDifference = bigR - littleR;
       var rRatio = littleR / bigR;
       var x = (rDifference * Math.Cos(rRatio * t) + a * Math.Cos((1 - rRatio) * t)) * 25;
       var y = (rDifference * Math.Sin(rRatio * t) - a * Math.Sin((1 - rRatio) * t)) * 25;

       yield return new Point(centerX + (int)x, centerY + (int)y);
   }
}

So where are we? We have the Paint.Net canvas open on screen, and we have a set of points that we want to render. Conveniently for us, the default tool in Paint.Net is the brush tool. So to sketch out the spirograph, we just need to automate the mouse to move over the canvas, press the left button, move from point to point, and release the left button. As far as I know there’s no functionality built into the UIAutomation API to automate the mouse, but the WPF TestAPI (free to download from CodePlex) compensates for that. In its static Mouse class it provides Up, Down, and MoveTo methods that do all we need.

private void DrawSpirographWaveOnCanvas(AutomationElement canvasElement)
{
   var bounds = canvasElement.Current.BoundingRectangle;

   var centerX = (int)(bounds.X + bounds.Width /2);
   int centerY = (int)(bounds.Y + bounds.Height / 2);

   var points = GetPointsForSpirograph(centerX, centerY, 1.02, 5, 2, 0, 300);

   Mouse.MoveTo(points.First());
   Mouse.Down(MouseButton.Left);

   AnimateMouseThroughPoints(points);

   Mouse.Up(MouseButton.Left);
}

private void AnimateMouseThroughPoints(IEnumerable<Point> points)
{
   foreach (var point in points)
   {
       Mouse.MoveTo(point);
       Delay(5);
   }
}

Clicking Buttons

Once sufficient time has elapsed for your colleagues to admire the drawing, the last thing our automation script needs to do is tidy away – close down Paint.Net, in other words. This allows me to demonstrate another aspect of UIAutomation – how to manipulate elements on screen other than by simulating mouse moves and clicks.

Shutting down Paint.Net when there is an unsaved document requires two steps: clicking the Close button, and then clicking “Don’t Save” in the confirmation dialog box. As before, we use UISpy to discover the Automation Id of the Close button and its parents so that we can get a reference to the appropriate AutomationElement:

var closeButton = mainWindow.FindDescendentByIdPath(new[] {"TitleBar", "Close"});

Now that we have the button, we can get hold of its Invoke pattern. Depending on what kind of widget it represents, every AutomationElement makes available certain Patterns. These Patterns cover the kinds of interaction that are possible with that widget. So,for example, buttons (and button-like things such as hyperlinks) support the Invoke pattern with a method for Invoking the action, list items support the SelectionItem pattern with methods for selecting the item, or adding it to the selection, and Text Boxes support the Text pattern with methods for selecting a range of text and querying its attributes. On MSDN, you’ll find a full list of the available patterns.

To invoke the methods of a pattern on a particular AutomationElement, you need to get hold of a reference to the pattern implementation on the element. First you find the appropriate pattern meta-data. For the Invoke pattern, for example, this would be InvokePattern.Pattern; other patterns follow the same convention. Then you pass that meta-data to the GetCurrentPattern method on the AutomationElement class. When you’ve got a reference to the pattern implementation, you can go ahead an invoke the relevant methods.

Once again, I’ve made all this a bit easier by creating some extension methods (only the InvokePattern is shown here; extension methods for other patterns are available in the sample code):

public static class PatternExtensions
{
   public static InvokePattern GetInvokePattern(this AutomationElement element)
   {
       return element.GetPattern<InvokePattern>(InvokePattern.Pattern);
   }

   public static T GetPattern<T>(this AutomationElement element, AutomationPattern pattern) where T : class
   {
       var patternObject = element.GetCurrentPattern(pattern);

       return patternObject as T;
   }
}

With that I can now click the close button:

closeButton.GetInvokePattern().Invoke();

Then, after a short delay to allow the confirmation dialog to show up, I can click the Don’t Save button:

// give chance for the close dialog to show
Delay();

var dontSaveButton = mainWindow.FindDescendentByNamePath(new[] {"Unsaved Changes", "Don't Save"});

Mouse.MoveTo(dontSaveButton.GetClickablePoint().ToDrawingPoint());
Mouse.Click(MouseButton.Left);

For variation, I click this button by actually moving the mouse to its centre (line 6) then performing the click.

All the code is available on MSDN Code Gallery.

Bowing out

When I first read about UI Automation, I got the impression that it was rather complicated, with lots of code needed to make it do anything useful. I tried using Project White (a Thoughtworks sponsored wrapper around UIAutomation), thinking that would save me from the devilish details. It turned out the Project White introduced complexities of its own, and actually, UI Automation is pretty straightforward to use, especially when oiled with my extension methods. I’ve had a lot of fun using it to create automated tests of our product over the last couple of months.

How wide?

2009-07-16T13:50:00.001+01:00

A flier came through our door this morning from a new dental practice in the town. Next to a mug shot of two grinning models with impossibly white teeth, it itemises the services provided by the dentists:

Zoom tooth whitening
Air Flow Stain Removal
Gum Disease Treatment

then

Wheelchair Access

That would make me think twice when the dentist says “Open wide”.

Shipped!

2009-06-29T21:25:00.001+01:00

I’m pleased to announce that acceptance testing has been completed, and Baby Jack 2.0, now officially named Alaric Nahum Jack, was successfully delivered late last week.

The last few hours of the shipping process were rather gruelling for certain members of the team – my wife was allowed to bliss out on Gas and Air (known to the trade as Entonox), but I was not permitted ear plugs!

Unfortunately, no documentation was provided, but I do have two weeks off work to try to figure out how he works!

Magnetic Personalities

2009-06-17T12:33:00.001+01:00

A friend of ours happened to be listening in as a primary school teacher was giving a lesson on Electricity and Magnetism.

“What M picks things up?” the teacher asked the children. Then, choosing a child from the bunch waving their hands in the air, “Yes?”

“Mum!” replied the astute scholar of human nature.

Managed Memory leaks and their solutions

2009-06-10T21:45:00.001+01:00

It’s a myth that managed code does not suffer from memory leaks. Managed code is as capable of springing leaks as unmanaged, though fortunately, the leaks themselves are not nearly so pernicious. In managed code, leaks are not the result of forgetting to deallocate memory – the Garbage Collector is pretty much infallible in that respect. Rather, the leaks are almost always the result of an object subscribing to an event on another object with a longer lifetime. This results in the longer-lived Grandpa object grasping so tightly to the reference to the shorter-lived object (so that it can notify it of events) that the Garbage Collector dare not clean up the whippersnapper.

Such situations can easily be detected using one of the many memory profilers around (I’ve used, and can heartily recommend JetBrains dotTrace; I’ve also heard good things about the new version of RedGate’s Ants Profiler). These help you identify the objects that you expected to be cleaned up, and then let you trace back to find the villains that are keeping them alive.

But once you’ve identified the source of the problem, what do you do? Sometimes it’s as easy as remembering to make the short-lived objects unsubscribe from the longer-lived – you can do this if the class implements IDisposable, for instance. Other times, there’s no suitable or natural point at which to do the clean-up. What then?

That’s the subject of the excellent Code-Project article Weak Events in C# which explains the problem in more detail and covers the whole range of possible solutions to the problem. Don’t let the title put you off: the solutions don’t compromise on the power of your events – you can still declare

public event EventHandler<EventArgs> CountdownToArmagedonStarted

if you want to. Rather, the title refers to the common ingredient in all the solutions, the magical WeakReference class.

Go read the article. It will be the best spent fifteen minutes of your day.

Are Biology Students devolving?

2009-06-08T07:00:00.000+01:00

As if she wasn't busy enough bringing up our daughter, and growing the new addition to the family, my wife is a part-time private tutor to several A-Level Biology students (A-Level, for those not from the UK, being the final hurdle students have to clear before University). These students must all have passed their GCSEs before being accepted on to A-Level courses, with exams including core subjects like English and Maths. But you'd never know it from the answers they give as my wife goes over practice exam questions with them.

Take percentages. One question involved converting a percentage to a frequency: if 5% of the population have the recessive form of gene X, how many is that out of 100? Blank stare.

Then there was a question about interpreting Echocardiogram (ECG) traces. You’ll have seen one these in the movies if ever there was a hospital death scene. As the patient breathes his last, the camera invariably pans to an ECG monitor at his bedside. The sound-track turns somber, the sun is blotted out by a cloud, and on the monitor the peaks and troughs of heart activity subside to the infamous flat line.

On an ECG, the trace shows activity up the vertical axis and time along the horizontal, so to calculate the heart rate (as the question required) you begin by measuring the distance between peaks on the chart to get the duration of each beat. The student could do that - counting blocks was within her skill set. But the next step was to convert that to a rate in beats per minute.

"It's not fair that they ask Maths questions in a Biology paper!", complained the student. My wife was taken aback for a moment – the girl apparently wasn’t joking.

"So what do you do now?", my wife prompted once she’d recovered.

"I don't know", began the student; then with sudden inspiration: "It's got something to do with 60 hasn't it?".

"Well, yes, it has,", my wife said encouragingly. "You know how long each beat lasts. Now you need to work out how many of those beats will fit in a minute. So what do you do?"

"Ah, I've got it now". The student's face lights up. My wife smiles hopefully. "You divide the time by 60!"

ASP.Net Quick Tip: Get Web Deployment projects working with Web Application Projects

2009-06-04T13:10:00.001+01:00

Hopefully this will save someone else (or my future self) the couple of hours my colleague and I spent wrestling with ASP.Net to get this to work.

We have an ASP.Net 3.5 Web Application project and were trying to pair it up with a Web Deployment Project. This first problem we faced was with ILMerge complaining during the build process for the web deployment project. It said "An error occurred when merging assemblies: ILMerge.Merge: The target assembly 'cwSharp2' lists itself as an external reference.”. We fixed this thanks to a comment by JohnC on a post by Rick Strahl. You have to make sure that the output assembly for the Web Deployment project is different to the Web Application project – we called ours [Project].Pages.

The next problem didn’t reveal itself until we actually tried running the website as compiled by the Web Deployment project. When we tried browsing one of the pages we got errors like “Compiler Error Message: CS0433: The type '**' exists in both '***.dll’ and ‘***.dll'”. I searched, and – bing – out popped the answer: you have to right-click your web application project and click “Convert to Web Application”; doesn’t quite make sense, I know, but it works!

Silverlight Utility to decode Roman Numerals and spell out numbers

2009-05-27T17:43:00.001+01:00

I’ve had another chance to play around with Silverlight 2 over the last two days. The result: a new version of my utility to convert numbers to words. I’ve now added the ability to convert to and from Roman Numerals, making it substantially more useful – if you’re a Roman citizen caught in a time warp. Go try it.

I love the way Silverlight lets you run standard C# in the browser – generics, LINQ and all. The code for the conversion algorithms comes straight from two of my Project Euler posts, Converting Numbers to Words and Converting to and from Roman Numerals. From my limited experiment, the Model-View-View Model pattern also appears to work pretty much as it does in WPF, though data binding in Silverlight is not so sophisticated. For example, there is no UpdateSourceTrigger mode in Silverlight, so when you want a TextBox to update its data source every time the text changes you have to resort to a hack (switching focus away from the TextBox, then back again).

Unit Testing Silverlight

I’ve become quite a fan of unit testing over the last 9 months or so of my latest project, and I wanted to make sure we’ll be able to carry on the practice in Silverlight. Turns out it can be done, but choices are more limited than on the full CLR – mostly due to Silverlight only running in the browser (unless you are devious). There’s SilverUnit, but that’s built on top of Typemock Isolator which commercial users have to pay for. Or there’s Silverlight Unit Testing framework from Microsoft, which you can get free as part of the Silverlight Toolkit on Codeplex. I went with the free option.

Creating tests with Silverlight Unit Testing Framework is straightforward - you just decorate your classes and test methods with attributes, just as with other Unit Testing frameworks. At the moment though, options for running the tests are limited: you pretty much have to use the provided method, that runs through all the tests in a browser window. My colleague is currently trying out a technique using a powershell script to automate Internet Explorer so that we can include the Unit Tests on our Continuous Integration Server; also check out Odin, a promising looking project on CodePlex that aims to get the tests running from Resharper.

Oh, and one last thing. Did you know that Microsoft provide free hosting for Silverlight applications – 10 whole Gigabytes? And with Office Live you can get a website hosted for you, but using your own domain name – again for free. That’s how I’m hosting the utility.

Get the Code

I’ve put all the code for this little utility on MSDN Code Gallery for your hacking pleasure.

Practical LINQ #3: Compacting ranges of numbers

2009-05-01T07:00:00.000+01:00

Here’s a problem that has popped up several times in one guise or another during the six years of my career:

Given a list of numbers, present it to the user in its most compact form.

So if you have 1, 3, 4, 5, 9, 11, 12, 13 it should be presented as 1, 3 – 5, 9, 11 – 13. It’s what your brain does automatically when you fill out the “Selected Pages” box in the Print dialog of Microsoft Word.

I’m sure you can imagine for yourself the kind of for-loop I crafted the last time I solved this problem. This time I wanted to make life more interesting.

The first thing is to make sure the numbers are marshalled in ascending order, with no duplicates in the ranks:

var preparedList = numbers.Distinct().OrderBy(x => x);

For the next step, I imagined into being a little Scanner class, with a nice fluent interface. I wrote down the following code, which was how I wanted the Scanner to work; then, with Resharper pointing out my omissions in glaring red text, I implemented the concepts to make it work:

public IEnumerable<Range> Compact(IEnumerable<int> numbers)
{
    var preparedList = numbers.Distinct().OrderBy(x => x);

    var scanner = new Scanner<int, Range>();

    scanner.ConfigurePattern()
        .StartMatchingWhenAny()
        .ContinueMatchingWhile((nextItem, matchedItems) => nextItem == matchedItems.Last() + 1)
        .Output(details => new Range(
                                    details.MatchedItems.First(),
                                    details.MatchedItems.Last()));

    return scanner.Scan(preparedList);
}

The idea is for the Scanner to walk a sequence of objects (ints in this case), producing from it a sequence of tokens (here, Range objects – simple structs with First and Last properties). The Scanner produces its output by matching patterns of contiguous input elements. The patterns are configured using a fluent interface:

the condition that must be met in order to start matching this pattern (any integer is accepted at the start of this simple pattern)
which items are considered part of the pattern: here an integer is accepted if it is only one bigger than the previous matched integer
how to generate a token from the matched part of the sequence

The internal workings of the scanner aren’t terribly interesting. See the download link below if you’re desperate for a look.

Now don’t laugh: String.Join is my discovery of the week. It concatenates an array of strings, putting a separator of your choice between them; leaving you free to fry bigger fish than how to put a comma after every item except the last.

So my final answer looks like this:

var numbers = new[] {1, 3, 4, 5, 9, 11, 12, 13};

var compacter = new RangeCompacter();
var ranges = compacter.Compact(numbers);

// create a pretty string, each range or number separated by a comma
var display = string.Join(
    ", ", 
    ranges
    .Select(range => range.ToString())
    .ToArray());

Assert.AreEqual("1, 3 - 5, 9, 11 - 13", display);

I’ve put all the code, including my Scanner class, on Code Gallery; there’s even a sprinkling of unit tests! If you find any other uses for it, do let me know.

Broadband woes and customer service triumphs

2009-04-28T22:03:00.001+01:00

My Broadband router died the other day. One night it worked, the next morning – caput! No lights on the front panel, no response even when I prodded the reset button with a pen. Our house seems to be an unhealthy environment for electronics. I blame my wife: when she was at university, she could crash a computer just by sitting down and putting her hand to the mouse.

But my luck was in. This was a Belkin router, and it came with a lifetime guarantee – and not a gnat’s lifetime either, as it turned out.

I suspected a fried power supply, so I got chatting to technical support (Live Chat does an excellent of rendering an Indian accent intelligible to British eyes!), intending to ask them to replace it. I got more than I bargained for.

Having cleared the hurdle of First Line support, Second Line agreed that they would give me a replacement – of the whole router. In fact, they would give me an upgrade, since the model I had was obsolete. And to top it all, they emailed me a postage-paid label by which to return my old router.

Now get this: I bought the router for £20 second-hand from a colleague more than a year ago, yet that didn’t concern Belkin – at no point did they ask for so much as a whiff of a proof of purchase.

The router duly arrived, I plugged it in, and – no connection. I borrowed a friend’s router – no connection on that either. Clearly my line had rotted from lack of use.

That was when I discovered the magical iPlate from BT. It’s a widget that costs less than a tenner, that really does install in minutes (on top of your home’s master socket), and it brought my line back from the dead. It works, I’m told, by cutting out the bell wire (used, in the olden days, to ring your phone’s bell, but now defunct and the cause of much interference on the line). My download speed is pretty much as it was before, but my upload speed has almost doubled!

So now I don’t even have dead Broadband as an excuse for not updating my blog in over a month!

Project Euler 21: Getting friendly with the Amicable numbers

2009-03-27T22:26:00.001Z

I’ve remarked before that to Mathematicians, numbers aren’t, … well, they’re not just numbers. Numbers have personalities. Whilst some are deficient, there are others which are aspiring, and a few who are actually perfect; half of them are rather odd, some downright weird. Of more concern are the odious and evil numbers, especially those that consider themselves untouchable¹.

But today we’ll look at a more friendly subject: the amicable numbers. What is an amicable number? Let’s get mathematical and define a function d(n) to be the sum of all proper divisors of n (a proper divisor of n is any divisor of n less than n). Then an amicable number a is one which has a friend b where d(a) = b and d(b) = a (note that we don’t allow a to be narcissistic and count itself as a friend). If you do the math (or these days, more realistically, the google search) you’ll find that the first pair of amicable numbers is 220 and 284.

Amicable numbers have been studied since Greek times: the Pythagoreans in particular credited these special numbers with mystical powers. They’ve even by tried out as a kind of mathematical aphrodisiac:

El Madshriti, an Arab of the 11th century, experimented with the erotic effects of amicable numbers by giving a beautiful woman the smaller number 220 to eat in the form of a cookie, and himself eating the larger 284!

My sudden interest in amicable numbers was driven by strictly mathematical desire - to solve Project Euler 21². The problem simply asks us to find the sum of all amicable numbers less than 10000. And in fact, the solution to the problem pretty much falls out of its definition.

First, I’ll borrow a function from a few problems back that lists all the divisors of a number:

public static class NumericExtensions
{
    public static IEnumerable<int> Divisors(this int number)
    {
        return (from factor in 1.To((int)Math.Sqrt(number))
                where number.IsDivisibleBy(factor)
                select new [] { factor, number / factor }).Concat();
    }

}

With that, the answer is straightforward:

[EulerProblem(21, Title = "Evaluate the sum of all amicable pairs under 10000.")]
public class Problem21
{
    public long Solve()
    {
        Func<int, int> d = n => n.Divisors().Sum() - n;

        return 	(
				from a in 1.To(10000)
                let b = d(a)
                where a != b && d(b) == a
                select a
				)
                .Sum();
    }
}

As always, full code is available on the Project Euler Code Gallery page.

Footnotes

If you want to learn more about number personalities, see this catalogue.
Thanks to Bela Istok who sent me a nice functional solution to the problem, which prompted me to think about how I would solve it myself.

Functional Fun on Twitter

2009-03-17T14:21:00.001Z

I’ve just taken the plunge, and started tweeting on Twitter, user name @samuel_d_jack.

There have often been times when I’ve been intrigued or amused by something, but haven’t felt sufficiently creative to make a full blog post out of it: micro-blogging on Twitter seems to be the ideal solution.

I’ve added my Twitter feed to the right-hand side of my blog; and if you don’t find my drivel to be too deleterious you can even subscribe to the RSS feed.

Leaky Abstractions at the Petrol Pump

2009-03-11T14:00:00.001Z

Even as a software developer, I'm still ocassionally surprised when events remind me that Spolsky's Law of Leaky Abstractions applies to hardware as much as to software.

Here's an example from my holidays last year, when I went to fill up with petrol (how can you Americans call it gas when it's clearly a liquid?):

Any non-technical motorist who peered at the tiny writing on that blue screen and read "DRIVER_ERQL_NOT_LESS_OR_EQUAL" would surely feeel that he's being blamed for the failure, but what did he do wrong? Sounds like he failed some important existential test.

I'm clearly not the only one who enjoys spotting BSODs in the wild: Miguel Carrasco has put together a Blue Screen of Death Top Ten. And on Gizmodo they have a snapshot of a BSOD that appeared in the Stadium during the Opening Ceremony at the 2008 Olympic games.

Practical LINQ #2: Reporting duplicate names

2009-03-04T07:00:00.000Z

So my Widget editor can helpfully suggest default names, but it also lets users change the names of widgets. Ohh! Danger ahead: what if they give two (or more) widgets the same name? We can’t have that! The poor dears might confuse themselves. So we better make sure we warn them; that means we have to write code to detect duplicate names. And that gives me another opportunity to show some elegant LINQy C# for solving this real-life problem.

My requirements are simple: I want to generate an error for all widgets with a shared name, except for the first one with that name – no point in overburdening a user with error messages. I also want to ignore Widgets without a name – I’ve got another rule that deals with them.

The code is straightforward: group the widgets by name, and ignore any groups containing just one widget. Then for each group generate error messages for all items except the first. Translating that into proper English:

private static IEnumerable<TMessage> DetectDuplicates<T,TMessage>(IEnumerable<T> instances, Func<T, string> nameSelector, Func<T, TMessage> messageGenerator)
{
   var groupedDuplicates = instances
       .GroupBy(nameSelector)
       .Where(group => group.Count() > 1 && !string.IsNullOrEmpty(group.Key));

   var errors = groupedDuplicates
       .SelectMany(group => group.
                                Skip(1)
                                .Select(messageGenerator));

   return errors;
}

All the angle brackets in the method signature can mean only one thing: I’ve made the method generic, so it doesn’t just work with my Widgets; it will work with anything that has a property vaguely resembling a name. Along with your list of instances, you pass in a function that can extract a name from each of your objects, and a function that will generate the appropriate message for each duplicate. In fact it doesn’t just have to a message: you could return a rich error object if you wanted to be really sophisticated.

Here’s an example¹:

static void Main()
{
   var widgets = new[]
                     {
                         new Widget {Name = "Super"},
                         new Widget {Name = "Competent"},
                         new Widget {Name = "Competent"}
                     };

   var errors = DetectDuplicates(
       widgets,
       w => w.Name,
       w => "There's already a widget called " + w.Name + ". Be more original!");

   foreach (var error in errors)
   {
       Console.WriteLine(error);
   }

   Console.ReadLine();
}

Footnotes

The name of one of the widgets here was inspired by a brand of AEG oven that I spotted the other day: they named them “Competence”. I thought brand names were supposed to be aspirational!

Happy Holidays

2009-03-03T14:10:00.001Z

How will you be celebrating square root day?

Maestro: A new .Net language for parallel programming from Microsoft

2009-02-28T21:50:00.001Z

How did I miss this? At PDC 2008 (in the Parallel Symposium, apparently), Microsoft started talking about a new language that may be joining the .Net family. Continuing the musical theme of certain other languages, this one is called Maestro.

According to an article in Dr Dobbs Journal, Maestro is a special purpose language designed to simplify the writing of scalable parallel programs. It will integrate with other .Net components, and it seems that the intention is for the compute-intensive parts of applications to be written in Maestro, while the staple .Net languages continue to power the rest.

It’s based around the idea of agents in isolated domains passing messages to each other. On the new Maestro blog there’s an article giving some examples of the funky syntax they’re introducing:

The forwarding operator, ==> which is used to indicate that messages should be passed from a source to a target
The broadcast operator, –<< that broadcasts messages to a number of targets
The multiplex operator, >>- which combines messages from several sources before passing them to a single target

Don’t get too excited just yet: Maestro is being described as an “incubation project”. That appears to mean that it’s a bit more than a research project, but not one that anybody has yet committed to shipping. I don’t think they’ve even released a version of this yet – I certainly can’t find a download.

Once you’ve read the book, see the film on Channel 9.

Update (16/4/2009): Maestro has been renamed to Axum

As Mary-Jo reported, Maestro has now been given the less musical code name of “Axum”. This is possibly due to a code-name clash with another Microsoft project, that one to do with business intelligence.

Observing a bug in the dorsolateral prefrontal cortex

2009-02-26T08:37:00.003Z

Just occasionally the self-censorship feature in my wife’s brain malfunctions, with amusing consequences: it kicks in the instant after she has spoken, so that her next words are “don’t tell anybody I said that!”

But I’m sure she won’t mind my sharing a few choice moments with you.

First I should point out that my wife graduated with honours from one of the top medical schools in the UK, so there’s clearly nothing lacking in the rest of her brain. I speculate that Auto Update got turned off in this one area.

The most recent example was when we were discussing a diagram of the solar system with our daughter. “So did the Greeks and Romans know what the planets are called when they named their gods?”, my wife asked me – then immediately put her hand over her mouth in embarrassment.

But the funniest was a few years ago as we were driving through our neighbourhood at night, after there had been a power cut. The houses on either side of the road were eerily dark, and we were suddenly dazzled as another vehicle went past us in the opposite direction. My wife piped up,

“So how come that car’s headlights are still working?”