Living in the Tech Avalanche Generation

Here’s an excerpt from a job add I have just now seen where the item below is listed as an essential requirement.

• A high-level technical knowledge of all software development environments and programming languages.

This was part of the requirements for a Senior developers role. And Yes that’s verbatim! Hmmm. Good luck filling that role? Yikes…

There has been a lot of buzz lately about the ‘other’ styles of programming that exist outside of our warm and cosy statically typed imperative world. Dynamic and Functional programming languages are starting to generate some deep interest in the community and anyone who reads this blog from time to time would know that I too have been dragged in by the gravity of IronRuby.

F#, whilst interesting to me, alas must take a back seat to IronRuby as it’s going to have to be one language at a time for this little polyglot, however I keep coming across interesting information that promotes a Functional approach in C# and VB.NET. The approach leverages some of the newer (3.5) language features syntactically but really the core of what’s possible lies in the what became available in C# 2.0. There is of course always a ubiquitous example so lets stick with that - a function that takes an integer as an argument and returns a function that also takes an integer as an argument and returns an integer that adds the two together. Consider this code:

[Test()]
public void CurryInTwoDotZeroFramework()
{
    FuncInTwoZeroStyle two_zero_func =
        new FuncInTwoZeroStyle(delegate(int x)
            {
                return delegate(int y)
                {
                    return  x + y;
                };
            });

    var first_func_has_10 = two_zero_func(10);
    var second_func_has_another_10_makes_20 =
        first_func_has_10(10);

    Assert.AreEqual(20,
        second_func_has_another_10_makes_20);
}

What’s happening here is that we get a kind of closure behaviour where 10 gets stored away with the function. From the compilers point of view we know that delegates at runtime have a class generated with a target and a method and in our example we have 10 as the object instance being the target and the returned function is the “Method” that gets wrapped up in our runtime generated class. For a good discussion on how delegates work under the hood it’s worth reading this post.

Currying – a style of cooking or programming practice?

Something that Functional devotees often talk about is the ability to write functions that return functions, often referred to as “currying”. Interestingly the Wikipedia definition includes the following:

The practical motivation for currying is that very often the functions obtained by supplying some but not all of the arguments to a curried function (often called partial application) are useful; for example, many languages have a function or operator similar to plus_one. Currying makes it easy to define these functions.

Our .NET 2.0 example above can be redefined in 3.5 with some syntactic sugar like this:

public void basic_add_Curry()
{
    Func<int, Func<int, int>> curry_add_ten =
        x => y => x + y;

    var add_to_10 = curry_add_ten(10);

    var should_be_20 = add_to_10(10);
    var should_be_30 = add_to_10(20);
    var should_be_40 = add_to_10(30);

    Assert.AreEqual(20, should_be_20);
    Assert.AreEqual(30, should_be_30);
    Assert.AreEqual(40, should_be_40);
}

You mentioned Events?

I don’t want to go over ground already largely covered elsewhere so let me focus in what I thought was a slight deviation that offered up an interesting possibility. What about event subscriptions? Can we ‘curry’ event handlers? The answer is yes of course we can. Let me demonstrate.

internal class MyObjectWithAnEvent
{
    internal event EventHandler subscribe_with_action_event;

    internal void on_subscribe_with_action_event()
    {
        if(subscribe_with_action_event != null )
            this.subscribe_with_action_event
                ("’an event subscribed to by Action<>’",
                    new EventArgs());
    }
}

and we can subscribe to the event in this class like this:

public void event_handling_curry()
{
    //simple Action delegate
    Action<int, int> takes_two_ints =
        (x, y) => Console.WriteLine(x + y);

    takes_two_ints.Invoke(2,3);

    //Action matching signiture of EventHandler delegates
    Action<object, EventArgs> a_standard_event_delegate =
        (x, y) => Console.WriteLine(String.Format("{0}:{1}", x, y));

    //new up an object that has an event to subscribe to
    MyObjectWithAnEvent obj_to_subscribe_on =
        new MyObjectWithAnEvent();

    //subscribe to the event that implements 
    //an EventHandler delegate
    obj_to_subscribe_on.subscribe_with_action_event +=
        new EventHandler(a_standard_event_delegate);

    //call a method to raise the event
    obj_to_subscribe_on.on_subscribe_with_action_event();

    //declares a function that returns an event handler
    Func<int, Action<object, EventArgs>>
        func_that_returns_event_delegate =
        x => (y, z) => Console.WriteLine(
            string.Format("The values passed to the function was {0} " +
            "and the sender was {1}", x, y));

    //store the value of 100 with the returned event handler
    var action_with_int = func_that_returns_event_delegate(100);

    //subscribe to an event with the delegate 
    //returned by the function
    obj_to_subscribe_on.subscribe_with_action_event +=
        new EventHandler(action_with_int);

    //raise the event
    obj_to_subscribe_on.on_subscribe_with_action_event();
}

What is evident here is that we have returned a delegate that also has access to the contextual data that we had available at runtime when the delegate was computed. This delegate along with the the contextual data (x being equal to 100) might subsequently be used in a further computation at such time as any event is raised in which that delegate in question has been applied as a handler in any such events invocation list. I call this ‘contextual delayed subscription’. Perhaps I want to get a reference to a handler for an event that has not yet occurred and upon certain conditions or actions I will subscribe to that event at a later time or perhaps Just in Time. For example you might choose to store away the delegates and their contextual state until a user of your application indicates that they are interested having an event subscribed where actions occurring in the past are also of interest.

I’m reasonably sure that my experience so far with WPF and Silverlight is not unique in this respect. Most days (right now) are filled with open IDE’s galore and luckily having lots of memory is cheap. Typically a coding session will see that I have at least one instance of both Expression Blend and Visual Studio open at the same time and usually it’s more.

Behaviours Observed

Invariably I find myself doing nearly all the layout in Expression Blend as I find it’s design time environment far more satisfying for the following reasons:

• The ease in setting properties via the Properties Window
• Setting styles etc in the Resources Window
• The availability of the interaction Window
• Designer View in Expression Blend is far superior (and works)
  • Better Viewing Experience
  • Better Element Navigation Experience
• And setting animations in the Objects and Timeline Window

I have become proficient at flipping between IDE’s in an effort to take advantage of each of their strengths. At any given moment I can be doing some layout in Expression and then quickly flip over to VS.NET to take advantage of intellisense if I want speed in writing XAML by hand. If Expression had intellisense then I must admit that I would spend very little time in VS.NET other than to work on C# code directly.

Now that’s obvious you say! How else could you possibly manage? Well, some people are working exclusively in VS.NET with WPF and I just can’t comprehend how or perhaps it would be better stated that I can feel their pain. Perhaps they are die hard Windows Forms developers who just can’t bring themselves to leaving that IDE or maybe they just don’t have access to Expression Blend? Whatever the case it would prove both slower and far more frustrating to work without Expression Blend in my view. So if your a die hard? Let the VS.NET apron strings down and give Expression Blend a fair go, it’s not a perfect world but I believe it’s the best option for the time being.

I have heard a lot of people express the opinion that both these tools should be rolled into one (namely VS.NET). No prizes for guessing that that’s an opinion expressed by developers! I cant speak for devigners / designers but I am fairly sure they wouldn’t enjoy VS.NET at this stage as it’s really still quite unwieldy for XAML based applications. Personally I am quite happy to work in both IDE’s concurrently however my main wish at the moment is to give Expression Blend intellisense, then it’s safe to say that I will pretty much avoid VS.NET for everything other than C# code files. Version 3 of Blend does offer intellisense and code file editing however the lack of debugging will see us continuing to use both tools for a while yet. You can find a list of the new features here.