You can find more details about the event here and here.

In this particular industry, there exists a well know database schema that is used commonly to shuttle data to and from a DMS and this often requires a full ETL workflow. The application we are currently working on is targeting a “Transformation” process and hence our model is to a large degree dependent on this ‘little’ schema, which by the way finds it’s way into the physical world as an Access Database(s). Therefore some of the entities in our model were modelled against this database and when you think about DDD this sounds a bit strange since one of the common tasks in that process is to model entities to business concepts and then map those entities to a database. It became even more interesting when we interviewed the business stakeholders and asked them questions about what language and common expressions they use when they describe this database, it’s tables and rows and what they do with it all.

It quickly became apparent that the ubiquitous language in this case was to a large degree describing a database. Strange. At least I thought so.

The venue for “Doing .NET Days” will be static for the time being and the event be conducted at the Point Cook Community Centre in Point Cook Melbourne Australia. The number of seats for the event is limited (size of the room) and for the moment it caters to 10 seats (each with a PC supplied) so if you want to be involved you will need to be in the first 10 to register. if you want to be introduced to something new that you might not have had the time to check out till now.

Doing .NET Days – Day #1 Agenda

To kick things off were going to take a look at the following:

• An introductory look at messaging with NServiceBus.
• An introductory look at LINQ and it’s flavour of providers (LINQ To Objects, XML, SQL and Entity Framework)

To start off with I am holding 5 seats for graduates yet to find their first developer role in the workforce. I remember what it’s like trying to break in and get that first gig and I would have appreciated the help back then! If the graduate positions are not taken up within the next two weeks, I will open those seats up as well. Here are the rest of the event details:

• Saturday 22th August 2009
• Location – Point Community Centre
• 10:00 AM – 4:00PM
• Lunch is BYO or there are a number of cafes and restaurants in the town centre.
• To register email me your details and I will contact you with further details.

I will post a comment on this post every time a position is taken up so people can tell how many positions remain open.

The first change to Udi’s sample code comes in the publisher where the main method’s body no longer contains any configuration code whatsoever.

using System;
using Common.Logging;
using NServiceBus;
using Messages;
using System.Collections.Generic;
using System.ComponentModel;
using Org.TechA.Wpf.Controls;
using NServiceBus.Unicast.Transport.Msmq.Config;
using NServiceBus.Unicast.Transport.Msmq;
using NServiceBus.ObjectBuilder;

//register the extensions for configuration
//so IronPython can see the extension methods

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureSpringBuilder))]

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureMsmqSubscriptionStorage))]

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureXmlSerializer))]

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureMsmqTransport))]

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureUnicastBus))]

[assembly: Microsoft.Scripting.Runtime.ExtensionType(
    typeof(Configure),
    typeof(ConfigureUnicastBus))]

namespace Server
{
    class Program
    {
        static IBus bus = null;

        [STAThread]
        static void Main()
        {
            LogManager.GetLogger(“hello”).Debug(“Started.”);
            var ir_window = new ConsoleWindow();
            ir_window.ShowDialog();
        }
    }
}

What’s been added here is the decoration of the assembly with a set of ExtensionType attributes from the DLR to allow us to program against the NServiceBus fluent interfaces extension methods from IronPython. The other thing to note in the code above is that the configuration code from the PubSub sample is removed and what now remains is to create and run an instance of the IronPython Application Shell, effectively embedding IronPython into my NServiceBus publisher. Once this is done we are all set to start scripting our services and NServiceBus. If I run this code above I expect to see the the IronPython Application Scripting Window pop up ready for action.

Configure the Bus and Send a message

Here’s a look at a sample script typed at the console window (see above) to configure the bus and start sending some messages.

#import the relevant libraries
from System import *
from NServiceBus import *
import clr

#add a reference to the messages
#library from the pubsub sample
#and import it
clr.AddReference(“Messages”)
from Messages import *

#configure the IBus 
#NOTE: type this line as a WHOLE in the 
#IronPython Console Window
bus = Configure.With()
                .SpringBuilder()
                .MsmqSubscriptionStorage()
                .XmlSerializer().MsmqTransport()
                .IsTransactional(True).PurgeOnStartup(False)
                .UnicastBus()
                .ImpersonateSender(False)
                .CreateBus()
                .Start()

#create some messages
msg1 = EventMessage()
msg1.EventId = Guid.NewGuid()
msg1.Duration = TimeSpan(99999)
msg1.Time = DateTime.Now 

msg2 = EventMessage()
msg2.EventId = Guid.NewGuid()
msg2.Duration = TimeSpan(99999)
msg2.Time = DateTime.Now.AddYears(-1)

#prove that the messages have values
print msg1.EventId.ToString()
print msg2.EventId.ToString()

#put the messages in an array 
msgs = Array[EventMessage]((msg1, msg2))

#publish the messages
bus.Publish[EventMessage](msgs)

Running the Code

After running this script above we can expect our subscribers to start receiving the messages and we can check to see if indeed the Guid and DateTime property values in the messages match up once being received by the subscribers.

As you can see, our EventId values and other properties all match those created using a REPL experience with IronPython embedded as our publisher. The Dynamic languages turn out to be useful in other places when it comes to NServiceBus but we will leave that for another post soon.

Also, I would like to point out that you could leave the configuration code in the C# code that starts up the publisher and push the IBus instance as a variable into the scope of the IronPython runtime and then execute a similar (smaller) script against it. The IronPython Application Shell has a method that allows you to add variables into the scope ad-hoc from the statically typed side of the publisher. Here’s how to achieve that:

[STAThread]
static void Main()
{
    LogManager.GetLogger(“hello”).Debug(“Started.”);

    bus = NServiceBus.Configure.With()
        .SpringBuilder()
        .MsmqSubscriptionStorage()
        .XmlSerializer()
        .MsmqTransport()
            .IsTransactional(true)
            .PurgeOnStartup(false)
        .UnicastBus()
            .ImpersonateSender(false)
        .CreateBus()
        .Start();

    var ir_window = new ConsoleWindow();

    var vars = new Dictionary<string, object>();
    vars.Add(“bus”, bus);
    ir_window.ctlIronPythonConsole.OnVariablesAdded(vars);

    ir_window.Title = “NServiceBus IronPython Publisher”;
    ir_window.ShowDialog();
}

You can find the full code here and if your interested in downloading The IronPython Application Shell, it can be found here.

Below is the link to the full sample including the the NServiceBus PubSub sample, however you should remember to setup the queues that are required (by the NServiceBus samples themselves) by running the VbScript that comes with the download of NServiceBus itself.

NServiceBus-Pub/Sub Example with IronPython Application Shell

It’s hardly a feature that gets in your way but it’s damn annoying. Even if I hover over the vertical scrollbar I can see the damn thing. Apparently there has been some history of tooltip strangeness with Firefox in the past but I haven’t really delved into it too deeply.

Anyone heard of this problem before or experiencing it with the current version?

Deployment is a snap and in a project based environment where small systems are regularly custom built to order for heavy load batch processing, NServiceBus will make rolling out a highly scalable solution a very quick and reasonably simple process. Also, NServiceBus configuration is far simpler these days and to be honest, compared to some frameworks it’s downright simple to understand.

The kind of processing numbers we are achieving in current proof of concepts for new projects are impressive and the deployment story is going to let us ring out every last drop of blood from hardware otherwise considered as redundant and useless. Not a web server in sight!

One thing on MY the Network Administrators wish list is a zero deployment transactional queue (transport). Andreas created a file based ITransport implementation but unfortunately no support for transactions, however it does show just how extensible NServiceBus is.

The New IronPython Version

So to move forward with the WPF user control console project I decided to refactor it to support IronPython. Mark has jumped in just recently and started to contribute by adding the new “cached commands”, which offer up / down arrow repeat command behaviour such as found on a DOS console. You will also notice from the screenshot above I have imported the entire System namespace to demonstrate that it is possible (using the environment menu) to print the entire state of the default scopes current set of variables.

Now it’s true I could have done this in a way that allowed for switching between the languages, however I have delayed that decision until IronRuby reaches it’s version 1.0 official release. In the meantime you can now use the IronPython version or the IronRuby Version seperately.

I am going to follow up shortly with an example of how this little window can be become quite useful in a practical way.

Downloads

IronPython Console Window Project

IronRuby Console Window Project

After having spent a less than insignificant amount of time invested in IronRuby I decided to bite the bullet and invest the effort into IronPython instead and the reasons were entirely pragmatic. Microsoft seem to be putting more effort into IronPython, has already found it’s way into other stacks, such as Oslo’s Intellipad (which I plan to leverage) and it’s significantly more mature than IronRuby.

I am constantly finding uses for IronPython in my work and the list of problems that it’s going to help solve is growing quickly. As a side note, if you are looking to use IronPython and are ready to let the experience pass you by because of lack of IDE support then check out using NetBeans (for Python) and instead using IronPython. As previously detailed by Steven and David, you can use the NetBeans Tools menu and make the selection ‘Python Platforms’, then you can configure a new default platform setting and redirect the IDE to use IronPython (see above screenshot). I haven’t used this configuration for long but for now it seems to work nicely.

For my part so far I have delved into IronRuby and started to employ it for scripting my C# applications. Why did I choose IronRuby over IronPython? It began with curiosity in the Ruby language in general and led inevitably to IronRuby. I quickly acquired a taste for Ruby but there is something nagging in the back of my mind and I can’t get to the bottom of it - “did I choose the right language” and really after all “does it matter which one I choose?”

Given Pythons relationship to C and my emotional connection to the C family of languages, would IronPython have been a better choice? Certainly IronPython is further down the track and more mature than IronRuby at this stage, but what does that count for at this early stage? All these questions make me curious for some other opinions which I would leave to hear right here, so please tell me – what do you think? What criteria would you use to make a choice?

In the first part I wasn’t particularly happy with the underlying behaviour of the language statements; we were producing a cascading set of queries, rather than composing a query structure. This time around we look to achieve this compositional affect with a fluent interface that issues a beginning statement and subsequently composes a query until a finalizing command is submitted to indicate that execution should take place against the database. If we use Specifications to compose the predicates in querying the database we can achieve the composition through chaining extension methods and thus build up an execution context from the syntax in our language.

Consider this fluent interface:

public void prints_order_lines_grouped_by_customer_and_orders()
{
    NorthwindLangQuery
    .BeginQuery()
    .Customers()
    .With_An_Id_Equal_To(“ALFKI”)
    .With_Orders_Shipped_From(“Germany”)
    .That()
    .Are()
    .Older_In_Years_By(2)
    .EndCustomerQuery()
    .Print_Customer_Orders_To_Console_Window();
}

Instead of cascading sub queries that work on an initial database query as with the code shown in part 1, we use the specification pattern to build up predicates that we submit with a single SQL (LINQ To Entities) query to the database. If we pull apart the NorthwindLang query above and follow it method by method here is what it looks like:

public static NorthwindLang BeginQuery()
{
    _customerSpec =
        new Specification<Customer>(c => c == c);

    _orderSpec =
        new Specification<Order>(o => o == o);

    _orderLineSpec =
        new Specification<OrderLine>(ol => ol == ol);
    return new NorthwindLang();
}

The BeginQuery() method simply primes each of our specifications which progressively are built upon in the following chained method calls.

No change required in the method body below as we already know we are dealing with a customer.

public static Specification<Customer> Customers(this NorthwindLang query)
{
    return _customerSpec;
}

Next the specification has a filtering expression to the customer ID appended using the logical AND operator.

public static Specification<Customer> With_An_Id_Equal_To
            (this Specification<Customer> customers, string id)
{
    var cust_id_spec =
        new Specification<Customer>(c => c.CustomerID == id);
    _customerSpec &= cust_id_spec;
    return _customerSpec;
}

The customer orders are also required in the query so we are going to need to setup the Orders specification with it’s required predicate.

public static Specification<Order> With_Orders_Shipped_From
            (this Specification<Customer> customers, string country)
{
    Specification<Order> order_shipcountry_spec =
        new Specification<Order>(o => o.ShipCountry == country);
    _orderSpec &= order_shipcountry_spec;
    return _orderSpec;
}

The next two parts of the query are benign and have no effect on the composition of the query and only play a part in providing a more natural syntax composition for the language.

public static Specification<Order> That
            (this Specification<Order> orders)
{
    return _orderSpec;
}

public static Specification<Order> Are
    (this Specification<Order> orders)
{
    return _orderSpec;
}

Next we add a further Orders specification limiting the result set to orders more than twelve years old.

public static Specification<Order> Older_In_Years_By
            (this Specification<Order> orders, int age)
{
    var date = DateTime.Now.AddYears(-age);
    Specification<Order> order_older_spec =
        new Specification<Order>(o => o.OrderDate < date);
    return _orderSpec &= order_older_spec;
}

Finally we demarcate the end of the query by calling one of the finalization methods that can only be followed by subsequent printing methods.

public static IEnumerable<LangDomain.Customer>
    EndCustomerQuery(this Specification<Order> orders)
{
    return DomainQuery<LangDomain.Customer>
        .CreateQuery(_customerSpec, _orderSpec);
}

This is still all proof of concept stuff and I plan to follow up with putting a harness together with the Fireball code editor API. Here is a further list of some of the other language statements that the fluent interface is capable of producing at the time of this writing.

public void prints_order_lines_grouped_by_customer_and_orders()
{
    NorthwindLangQuery
        .BeginQuery()
        .Customers()
        .With_An_Id_Equal_To(“ALFKI”)
        .With_Orders_Shipped_From(“Germany”)
        .That()
        .Are()
        .Older_In_Years_By(2)
        .EndCustomerQuery()
        .Print_Customer_Orders_To_Console_Window();
}

public void selects_customers_by_id()
{
    var cust = NorthwindLangQuery
        .BeginQuery()
        .Customers()
        .With_An_Id_Equal_To(“ALFKI”)
        .EndCustomerQuery()
        .As_Unique_Where_Customers_Ids_Are_The_Same();

    foreach (var c in cust)
    {
        Console.WriteLine(c.CompanyName);
    }
}

public void selects_orders_specified_by_age_of_orders_with_
    specified_freight_costs()
{
    var query = NorthwindLangQuery
        .BeginQuery()
        .Orders()
        .Older_In_Years_By(12)
        .With()
        .Freight_Costs_More_Than(360)
        .EndOrderQuery();

    foreach (var o in query)
    {
        foreach (var ol in o.Order_Details)
        {
            Console.WriteLine(o.OrderID +
                ” : “ + o.Freight +
                ” : “ + ol.ProductID);
        }
    }
}

public void selects_customers_by_id_for_advanced_users()
{
    var cust = NorthwindLangQuery
        .BeginQuery()
        .Customers()
        .EndCustomerQuery()
        .As_Unique_Where((cLeft, cRight) =>
            cLeft.CustomerID == cRight.CustomerID);

    foreach (var c in cust)
    {
        Console.WriteLine(c.CompanyName);
    }
}

You can download the entire source code from the repository here.

public class MemberNameResolver<T>
{
    public static string ResolveProperty<TPropertyType>
        (Expression<Func<T, TPropertyType>> expression)
    {
        Func<Expression<Func<T, TPropertyType>>, string>
            prop_name_function = l =>
        {
            return GetNameFromExpression(l.Body);
        };
        var property_name =
            typeof(T).GetProperty(prop_name_function(expression)).Name;
        return property_name;
    }

    public static string ResolveMethod(Expression<Action<T>> expression)
    {
        Func<Expression<Action<T>>, string>
            prop_name_function = l =>
            {
                return GetNameFromExpression(l.Body);
            };
        var property_name =
            typeof(T).GetMethod(prop_name_function(expression)).Name;
        return property_name;
    }

    public static string ResolveField<TPropertyType>
        (Expression<Func<T, TPropertyType>> expression)
    {
        Func<Expression<Func<T, TPropertyType>>, string>
            prop_name_function = l =>
            {
                return GetNameFromExpression(l.Body);
            };
        var property_name =
            typeof(T).GetField(prop_name_function(expression)).Name;
        return property_name;
    }

    private static string GetNameFromExpression(Expression body)
    {
        if (ExpressionType.MemberAccess == body.NodeType)
        {
            var memberExpr = (MemberExpression)body;
            return memberExpr.Member.Name;
        }
        else if (ExpressionType.Call == body.NodeType)
        {
            var methodExpr = (MethodCallExpression)body;
            return methodExpr.Method.Name;
        }
        else
        {
            throw new NotImplementedException(
                string.Format(“Resolving names from expression types “ +
                “of {0} is not implemented!”,
                body.Type.Name));
        }
    }
}

Notice the newly specialized Resolve methods now allow a usage like the following:

var member1 =
    MemberNameResolver<Criteria>
    .ResolveProperty<int>(c => c.PageCounter);
var member2 =
    MemberNameResolver<Criteria>
    .ResolveMethod(c => c.SomeMethod());
var member3 =
    MemberNameResolver<Criteria>
    .ResolveField(c => c.Percent);
var member4 =
    MemberNameResolver<Criteria>
    .ResolveMethod(c => c.SomeMethodWithArgs(default(string),
        default(int), default(string[])));

Console.WriteLine(member1);
Console.WriteLine(member2);
Console.WriteLine(member3);
Console.WriteLine(member4);

Producing the following output:

Getting more out of Functions

So far the approach is a little static from a functional point of view so perhaps we could do this a little differently? If we define the following functions we get some equivalent behaviour to our utility class.

Func<Expression<Func<Criteria, int>>, Expression> criteriaFunction =
    c => c.Body;

Func<Expression, string> propertyResolverFunction = e =>
{
    if (ExpressionType.MemberAccess == e.NodeType)
    {
        var memberExpr = (MemberExpression)e;
        return memberExpr.Member.Name;
    }
    else if (ExpressionType.Call == e.NodeType)
    {
        var methodExpr = (MethodCallExpression)e;
        return methodExpr.Method.Name;
    }
    else
    {
        throw new NotImplementedException(
            string.Format(“Resolving names from expression types “ +
            “of {0} is not implemented!”,
            e.Type.Name));
    }
};

var propertyName =
    propertyResolverFunction(
        criteriaFunction(c => c.PageCounter));

Console.WriteLine(propertyName);

Here we have created two functions that can be used together to achieve our required end result. The first function criteriaFunction, takes a generic expression as an argument and returns an expression. The second function propertyResolverFunction, takes an expression as it’s argument and returns a string. By passing one function as an argument to the other, we achieve the same results as with the static utility class already demonstrated. To collapse this even further we can wrap up both those functions  into one.

Func<Expression<Func<Criteria, string>>, Func<Expression, string>> allInOne =
    c => e =>
    {

        if (ExpressionType.MemberAccess == e.NodeType)
        {
            var memberExpr = (MemberExpression)e;
            return memberExpr.Member.Name;
        }
        else if (ExpressionType.Call == e.NodeType)
        {
            var methodExpr = (MethodCallExpression)e;
            return methodExpr.Method.Name;
        }
        else
        {
            throw new NotImplementedException(
                string.Format(“Resolving names from expression types “ +
            “of {0} is not implemented!”,
                e.Type.Name));
        }
    };

Expression<Func<Criteria, string>> exp = c => c.Levels;
var property_name_allinone = allInOne(exp)(exp.Body);

Console.WriteLine(property_name_allinone);

When we call the allinone function with the expression argument, it returns a function that in turns take the body property of the same expression that was passed to the higher order function. All the code in the post presumes the the following class:

public class Criteria
{
    public decimal Percent;

    private int _pageCounter;

    public int PageCounter
    {
        get { return _pageCounter; }
        set { _pageCounter = value; }
    }

    private string _levels;

    public string Levels
    {
        get { return _levels; }
        set { _levels = value; }
    }

    public void SomeMethod() { }

    public void SomeMethodWithArgs(string arg1, int arg2,
        params string[] arg3) { }
}

For anyone who just happened upon this post and perhaps those who know me or have followed this blog may or may not be aware, I was a musician in one of my previous careers. I have not abandoned my music completely in the decade or so that I moved into software however let’s just say it took a very big back seat.

Initially drawn to software development as a better paying yet still highly creative profession, I would often tell myself that writing good code was like writing or producing a good song and though the output was different in format and audience expectations, the experience was still fulfilling a side of me that required feeding.

A decade into my software development career and I can now say that whilst it does satisfy a creative urge, it can never come close to the emotional connection and responses that music emote in me. Recent days spent with headphones and my MP3 player have me on the verge of propelling myself into some musical journey and exactly what that is I am not sure right now but I am filled with excitement and overwhelming sense of promise.

My final observation is this: even with a strong resolve to travel some undiscovered musical road, I still feel the ‘coding’ drug flowing through my veins. I am, I code, I live, I die.

public class Criteria
{
    private int _pageCounter;

    public int PageCounter
    {
        get { return _pageCounter; }
        set { _pageCounter = value; }
    }

    private string _levels;

    public string Levels
    {
        get { return _levels; }
        set { _levels = value; }
    }
}

I want to dynamically resolve any property name using an Expression such as:

Expression<Func<Criteria, string>> f = c => c.Levels;

After fumbling around for a while it occurred that functional programming was yet again the simplest way to approach this.

public class PropertyNameResolver<T>
{
    public static string Resolve<TPropertyType>
        (Expression<Func<T, TPropertyType>> expression)
    {
        Func<Expression<Func<T, TPropertyType>>, string>
            prop_name_function = l =>
            {
                int posDot = l.Body.ToString().LastIndexOf(“.”) + 1;
                return l.Body.ToString().Remove(0, posDot);
            };
        var property_name =
            typeof(T).GetProperty(prop_name_function(expression)).Name;
        return property_name;
    }
}

By supplying the expression and encapsulating the function that takes the expression as an argument, we get access to the body and parameters in the expression tree built by the original lambda and when be execute the outer function we can extrapolate the property name. Here’s an example of the usage:

var pc = PropertyNameResolver<Criteria>.Resolve<int>(c => c.PageCounter);
Console.WriteLine(pc);

Functional goodness in C#.

var customer_to_make_preferred = Get_Customer_By_Id<ICustomerMakePrefered>();

//OR METHODS LIKE THIS

public void Group_By_Orders_And_Print_To_Console_Window()
{
    //…..etc
}

I really find a benefit in greater understanding when reading code when I take this approach. Now it’s true I have been programming in C# for some 10 years and I don’t know if this kind of behaviour will see me excommunicated from the circle of brethren or not but I would like to know what others think.

Opinions please! And yes I know this is gonna be like waving a red flag in front of a raging bull :). And for the Ruby people, I am only proposing the extended underscored naming convention and nothing else – it’s all about naming and that’s it – ya basta!

Part 1
Part 2
Part 3
Part 4
Part 5
Part 6
Part 7
Part 8
Part 9
Part 10
Part 11

The Code is here.

This really is one of my pet hates and I keep seeing it over and over again and recently came across it again whilst reading the Microsoft primer document on MGrammer. At the time of this writing the link provided here is not available, presumably due to the timing of the latest CTP drop of the Oslo tools (which now includes Quadrant) but I digress.

This is just the latest offence of the COMMON misdemeanour that I have come across.

module SongSample
{
    language Common
    {
        // Parameterized List rule
        syntax List(element)
            = e:element => [e]
            | es:List(element) e:element => [valuesof(es), e];
        // Whitespace
        syntax LF = “\u000A”;
        syntax CR = “\u000D”;
        syntax Space = “\u0020″;
        syntax Whitespace = LF | CR | Space;
    }
    language Song
    {
        // Reference List rule in Common language
        syntax Bars = bs:Common.List(Bar) => Bars[valuesof(bs)];
        syntax Songs = ss:Common.List(ASong) => Songs[valuesof(ss)];
        // Reference Whitespace rule in Common language
        interleave Whitespace = Common.Whitespace;
    }
    language AnotherLanguage
    {
        // Reference List rule in Common language
        syntax ListOfAs = Common.List(“A”);
    }
}

Here we can see that in an effort to describe reusable rules across languages, a language call COMMON has been created with the idea the the syntax rule definitions might be reused, therefore becoming ‘common’ amongst the other languages that reuse them. The thing that starts me wanting to chew on my ear is the use of the word COMMON, which is a word that is descriptive of nothing! COMMON tells me nothing by looking at it. COMMON ensures that I must read the contents if I want to begin to gain an understanding. If we consider that the ‘so-called’ common language (above) contains a parameterized list rule and a set of syntax rules for whitespace, space and line termination then perhaps we can craft some description around those elements? Perhaps we might take the LF, CR, Space and Whitespace elements and put them in a language called MusicalWhitespace? Now I’m sure plenty of you can come up with a better name than that, but I guess the point is that MusicalWhitespace gives me some idea of what it might be about. I still prefer not to let my intent get lost by being common.

Let me finish by saying that I know that the author of the MGrammar in a nutshell document was using this to convey the reuse in as simple and obvious fashion possible and I am not taking a swipe at that document, on the contrary it’s a great quick start into MGrammer, it simply offered an example (albeit a non real world one) where the concept was present and could be highlighted.

Whilst Orion’s project provided the basis of what I was after, I was under no illusion that I would find exactly what I was after and would therefore have to build out the rest of the functionality I required.

The Basic Requirements List

• Reusable WPF User Control
• The Console should allow users to write script against in memory objects of the host application.
• Should persist (to a log) the state of variables in the IronRuby runtime scopes.
• Extensible Application Design and easily maintained and Testable.

So rather than re-invent the wheel I started out with Orion’s code and worked it into a WPF User Control that followed the MVP pattern. This version supports printing of all scope variable state to the console window, clearing of the console window text and all the out of the box access to the IronRuby runtime from the console itself. The IronRuby Console User control also allows the consumer application to pass through in memory variables from your managed CLR hosting application.

Finally I need to also make mention that some of the classes used to stream the STD/IO came directly from Ben Halls wonderful IronEditor. And before I forget, the code can found here on my blogs subversion repository.

Something that has stayed with me in the weeks passed since listening the to discussion, is Scott’s description of developers as ‘high functioning autistics’. The context in which Scott makes the observation is one where he expresses a desire for developers to speak more fluently in the language of the business and desist in articulating implementation details or information of no business value. I’m sure that most people will find that idea logical and reasonable (as I do) however I feel that it’s worth throwing some attention onto the business and how it communicates in the reverse direction.

Any relationships success relies on the mutual respect and determination of all parties to participate in functioning cohesively to achieve a common goal. Yes developers should aim to achieve communicating more effectively with the business but it should be said that business people must take an equal position of responsibility for the success of communication between the parties. I’m pretty sure that most developers have worked in environments with little structure or discipline, where ad-hoc is the methodology of the day and expectations are generally unreasonable. I am sorry to say that I have seen developers purposefully communicate in an abstract way with business people, in an attempt to shield themselves from the kind of environment I just described.

I find it curious that we even speak of ‘developers’ and the ‘business’ as separate entities almost as though they exist in different dimensions; surely we developers work for the very same business as do those in HR, Sales or Warehousing? By definition we must also be considered part of the business. Seriously though, I understand the distinction when we speak about ‘software’ and the ‘business’ in terms that express a notion of separation, but I guess I am starting to think that it’s a consequence of the inadequacy of language that helps in promoting exactly some of the problems that Scott wants to see eradicated.

I think it’s worth making the observation that whilst developers should take responsibility for themselves in communicating more effectively across the organisation they serve, it’s incumbent on all parties to create environments designed for successful communication that travels in all directions. There have been plenty of occasions where I have seen ‘business people’ behave in a fashion that demonstrated a lack of respect and understanding of those sitting on the IT side of the fence. Respect is a two way street.

Let’s consider the workers of the Northwind Trading company as an example of some possible beneficiaries to such a Data Centric DSL modelled around a specific business. Of course workers at Northwind have MS Access and SQL Server GUI tools (often called Graphical DSL’s), to help design their queries.

A snippet

So what would our Northwind language look like? Given that we set up from the start to consider an internal DSL, I have chosen to use C# to implement this “little language” (very little) and we will use a fluent interface to accommodate our design. A query might be expressed like this:

public void Do()
{
    var custs = NorthwindLang
        .Customers
        .WithOrdersShippedFrom(“Germany”)
        .That()
        .Are()
        .OlderInYearsBy(5);
}

The Language

public static class NorthwindLang
{
    public static Customer[] Customers;
    private static NorthwindEntities ctx = null;

    public static Customer[] WithOrdersShippedFrom(this Customer[] customers,
        string country)
    {
        ctx = new NorthwindEntities();
        var customers_and_orders =
           (ObjectQuery<Customer>)
           from c in ctx.Customers.Include(“Orders”)
           where c.Orders.Any(o => o.ShipCountry == country)
           select c;

        Console.WriteLine(customers_and_orders.ToTraceString());

        customers = customers_and_orders.ToArray();

        customers.ToList()
            .ForEach(c => c.Orders.ToList()
                .ForEach(o => {
                    if (o.ShipCountry != country)
                    {
                        ctx.Detach(o);
                    }}));

        return customers;
    }

    public static Customer[] That(this Customer[] customers)
    {
        return customers;
    }

    public static Customer[] Are(this Customer[] customers)
    {
        return customers;
    }

    public static Customer[] OlderInYearsBy(this Customer[] customers, int years)
    {
        var years_ago = DateTime.Now.AddYears(-years);

        var newOrds = new EntityCollection<Order>();

        var coolFunc =
            new Func<IEnumerable<Order>,
                EntityCollection<Order>>(o =>
            {
                newOrds = new EntityCollection<Order>();
                o.ToList().
                    ForEach(ord => { ctx.Detach(ord);
                        newOrds.Add(ord); });
                return newOrds;
            });

        var filtered_customers =
            from c in customers
                 let neworders =
                      (from o in c.Orders
                      where (o.ShippedDate.HasValue) &&
                            (o.ShippedDate.Value < years_ago)
                      select o)
                 select new Customer()
                 {
                     CustomerID = c.CustomerID,
                     CompanyName = c.CompanyName,
                     Orders = coolFunc(neworders)
                 };

        customers =
            filtered_customers
            .Distinct()
            .ToArray();

        return customers;
    }
}

Problematic

Something worth noting about the OlderInYearsBy() method is the projection taking place with the Orders property assignment for each new Customer entity projected in the queries select clause. You can see that we are “projecting” the orders that match the criteria into the customers Orders collection, however as they have already been fetched from the Database and are attached to an ObjectContext, we need to detach them so they can be referenced by a new Customer Entity that is being returned in the array of Customers produced by the function. Also, you may have observed that we are working with extensions to Customer arrays and not EntityCollection<T> where T is of type Customer, further to that, the code presented is filtering data selected from method calls higher up the call chain of the fluent interface and their is nothing stopping a user from composing a query that does not work with the assumptions present in the fluent interfaces design, and consequently the behaviour may not be as expected. Another issue with this approach is grammar and creating sentences that make little sense and don’t adhere to the DSL’s intended use or rules.

public void Do3()
{
    var custs = NorthwindLang
        .That()
        .OlderInYearsBy(15)
        .WithOrdersShippedFrom(“Italy”)
        .Are()
        .That()
        .OlderInYearsBy(15);
}

Where to from here?

I want to follow up with a post on how to achieve similar outcomes using a functional approach and building compound queries using lambda expression that have been joined together with the logical & and | operators. A perfect candidate for this requirement is (dare I say it) the specification pattern. What I hope to achieve with this more functional approach is to be able to compose sentences of intent that build our query so that it can be submitted as one single SQL query. The issue of grammar still remains a problem and I have considered previously that a graphical designer that sits in front of a fluent interface might offer a solution and offer some options with respect to constraining the use of the fluent interface. Consider a UI design surface built with the VSX DSL tools that sits on top of our NorthwindLang fluent interface. Anyway we shall see where this journey takes us!

One final thing

I don’t recommend using an ORM for reporting purposes. The scenario under which this idea was proposed (rather envisioned) was one where the database in question is a constantly renewed small set of data that is exported from an enterprise Document Management System and it’s purpose is to provide an offline view of partitioned data relevant to a consultants work for a given client. This precludes the requirements from having to deal with issues such as concurrency, given that each instance of this database is usually single user in the most literal sense.