Why?  I have a few reasons.  Number one is I want to remove all of my JavaScript from the html, so the JavaScript is loaded via script tags.  Once that happens, then I can have the JavaScript cached by the browser and speed up my application a bit.  What I need the Asp.Net engine for was to give me accurate links to web site resources (images, web services, call, other javascript files, etc).  These are thing that I don’t want to hard wire, mostly because I’ve bitten off the Asp.Net Routing engine bug.  So, I want to use the Asp.Net Routing engine to tell me where to find stuff.

Not that I’ve committed to Asp.Net MVC I’ve come to a realization that making dynamic javascript files is well within my reach.  Actually, it is almost there already; Asp.Net MVC ships with a JavaScriptResult.  The downside of that result action is that the object expects you to hand it the JavaScript as a string, which it pushes to the browser as a file.  I want to give a method a JavaScript View for that.  The other good news about JavaScriptResult is that it doesn’t do much (just set the response.ContentType  to application/x-javascript).  So I could grab all of the View methods, turn them into extension methods, rename them, and then use them for my own underhanded affairs.

Luckily we can all grab the Asp.Net MVC source code and go to town.  I didn’t modify the original source, but I defined a new class (JavaScriptFileResult) and a bunch of extension methods for the Asp.Net MVC Controller to give you JavaScriptView methods.  You can see a usage in the first piece of code.

   1: public ActionResult JsConstants( )

   2: {

   3:     return this.JavaScriptView();

   4: }

Now below is the actually extension methods and class needed.  Put this in your project some place and go to down.

   1: public class JavaScriptFileResult: ViewResult

   2: {

   3:     public override void ExecuteResult(ControllerContext context)

   4:     {

   5:         base.ExecuteResult(context);

   6:         HttpResponseBase response = context.HttpContext.Response;

   7:         response.ContentType = "application/x-javascript";

   8:     }

   9: }

  10:  

  11: public static class JavaScriptControllerExtensions

  12: {

  13:     public static ViewResult JavaScriptView(this Controller controller )

  14:     {

  15:         return JavaScriptView(controller, null /* viewName */, null /* masterName */, null /* model */);

  16:     }

  17:  

  18:     public static ViewResult JavaScriptView(this Controller controller, object model)

  19:     {

  20:         return JavaScriptView(controller, null /* viewName */, null /* masterName */, model);

  21:     }

  22:  

  23:     public static ViewResult JavaScriptView(this Controller controller, string viewName)

  24:     {

  25:         return JavaScriptView(controller, viewName, null /* masterName */, null /* model */);

  26:     }

  27:  

  28:     public static ViewResult JavaScriptView(this Controller controller, string viewName, string masterName)

  29:     {

  30:         return JavaScriptView(controller, viewName, masterName, null /* model */);

  31:     }

  32:  

  33:     public static ViewResult JavaScriptView(this Controller controller, string viewName, object model)

  34:     {

  35:         return JavaScriptView(controller, viewName, null /* masterName */, model);

  36:     }

  37:  

  38:     public static ViewResult JavaScriptView(this Controller controller, string viewName, string masterName, object model)

  39:     {

  40:         if( model != null )

  41:         {

  42:             controller.ViewData.Model = model;

  43:         }

  44:  

  45:         return new JavaScriptFileResult

  46:         {

  47:             ViewName = viewName,

  48:             MasterName = masterName,

  49:             ViewData = controller.ViewData,

  50:             TempData = controller.TempData

  51:         };

  52:     }

  53:  

  54:     public static ViewResult JavaScriptView(this Controller controller, IView view)

  55:     {

  56:         return JavaScriptView(controller, view, null /* model */);

  57:     }

  58:  

  59:     public static ViewResult JavaScriptView(this Controller controller, IView view, object model)

  60:     {

  61:         if( model != null )

  62:         {

  63:             controller.ViewData.Model = model;

  64:         }

  65:  

  66:         return new JavaScriptFileResult

  67:         {

  68:             View = view,

  69:             ViewData = controller.ViewData,

  70:             TempData = controller.TempData

  71:         };

  72:     }

Now the view, here is what it looks like:

   1: <%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>

   2: var UrlList = {

   3:     SubscriptionList: '<%=Url.Action("SubscriptionList", "Channel") %>',

   4:     MoreSubscriptions: '<%=Url.Action("More", "Channel") %>',

   5:     WaitGif: '<%=Url.Content("~/Content/img/ajaxloader.gif") %>',

   6: };

Like I stated before, I was looking to get uris for the most part.  But this could also be a strongly typed view where you have to pass in real data.

Finally, loading this view into my page.  You saw the controller action was “JsConstants” above, which was in my HomeController (not shown), so here is how I ask the routing engine for the JavaScript file.

   1: <script type="text/javascript" src="<%=Url.Content("~/Home/JsConstants") %>"></script>

So far I am happy with this technique.  But if you see something that can be improved, please let me know.

I spent the last (almost full year) taking baby steps in an effort to make our logic layer a tiny smidgen eency weency bit more testable. Trust me, trying to replace an everything’s a Singleton architecture is no easy task. I won’t go into my strong dislike for Singletons – take a look at Singletons are Evil. I’ve slowly worn the team down into an agreement that we will not propagate any more Singletons in the project.  They’ve given me a new saying “Read my lips. NO NEW SINGLETONS!”.

PowerShell assisted regular expression search and replace.

In my case, the specific regular expression needed to find

SomeBusinessLogicClass.Instance.SomeFooMethod(bar);

//  and replace it with 
Resolve<ISomeBusinessLogicClass>().SomeFooMethod(bar); 

Below is the PowerShell script I used.

# define the find and replacement regular expressions.

$regex_find = ‘([a-zA-Z]+)\.Instance\.’

$regex_replace = ‘Resolve<I$1>().’

# get all the C# files we want to search/replace through

$allFiles = Get-ChildItem -Filter *.cs -Recurse

foreach($fileToReplace in $allFiles)

{

    $fileString = $fileToReplace.FullName

    if([String]::Join([Environment]::NewLine, (Get-Content -Path $fileString)) -match $regex_find)

    {

        # make the file writable so we can update it

        $fileToReplace.IsReadOnly = $false;

        Write-Host "applying fix to – $fileString"

        # here’s where we load up the file iterate through each line   
        # replace any of the regex matches

        # and save the file back to the original location

        Set-Content $fileString -Value ((Get-Content -Path $fileString) | foreach { if( $_ -match $regex_find) { $_ -replace $regex_find, $regex_replace } else { $_ } } )

    }

}

Caveat:

• Some of the files “end of file” changed (added an extra end line in some cases)

Team Foundation Server tip to detect the changed files.

The next step requires you install the TFS Power Tools.

Once installed, fire up the PowerShell console given in the start menu

I then ran the following command to have all edited files automatically detected as modified and can then be set as pending a change in TFS.

tfpt online /adds /diff /recursive .

On one of the Views I had to move a collection of complex data from the client to the server. By complex I mean more than just a single property. An example of this might be editable rows in a table (yes I know that there are other ways to solve this problem such as using AJAX but please stick with me). In addition I didn’t like the fact that there was a duplication of the presentation logic – server side binding during the initial rendering and client side binding if data was changed. I’ve seen a lot of bugs in the past with this approach when someone makes server or client side changes but forgets about the other piece.

I decided to used JSON as a common currency for this part of the UI. I removed the server side binding. Then on the server side I created a Display Model (a View Model for a subset of the View) to represent the data that I needed to display and edit. I can serialize this to JSON (new JavaScriptSerializer().Serialize(myDisplayModel)). I can subsequently access the JSON via an AJAX request or I can stuff it into the DOM if I am sensitive about the number of calls being made (which I was here). On the client side I used a JQuery plugin ($.evalJSON(myJsonString)) to convert the JSON into a form that is easily consumable in Javascript. I could therefore use the same code to initially populate the UI and deal with any edits.

When an edit was made I simply update the UI and store the new JSON in the DOM ($.toJSON(myJSonObject)). When the form was submitted back to the server I can easily deserialize the JSON (new JavaScriptSerializer().Deserialize<myDisplayModel>(myJsonString);) and then manipulate it as I see fit.

What is nice about this technique is it allows both the client and the server to work with the same Display Model. It also resulted in nice clean “object.Property” Javascript.

As always any feedback or alternative approaches would be greatly appreciated.

One of the reasons that we were keen to work together is that we have a lot of shared values, not least of which are Integrity, Craftsmanship, Agility and Community. However we had not worked together before. And despite our ideological common ground there are always challenges with any new team. One method of visualizing the stages that you typically go through in this scenario is a model known as Form – Storm – Norm – Perform.

I’m not going to explain the concept as the referenced Wikipedia article does an excellent job of that. However I do want to emphasize that any subsequent changes in the team or the context within which it operates take everyone back to the beginning of the process. Of course if the change is small then the duration of the cycle will often be commensurately short. Understanding the process that we were going through and its psychological ramifications has certainly enabled us to be successful. I hope that it helps you too.

My original classes were similar to this:

public class MyProgress{
   public virtual Guid Id { get; set; }
   ...
   ...
   public virtual MyStatus Status { get; private set; }
}

public enum MyStatus{
   New,
   InProgress,
   Completed,
   Canceled,
   Failed
}

My new state pattern was similar to this:

public abstract class MyStatus
{
    public static readonly MyStatus New = new NewStatus();
    public static readonly MyStatus InProgress = new InProgressStatus();
    ...
}

public class NewStatus: MyStatus
{
    public override void Start(MyProgress progress)
    {
        progress.SetStatus(InProgress);
    }
    public override void Cancel(MyProgress progress)
    {
        progress.SetStatus(Cancelled);
    }
    public override void Fail(MyProgress progress)
    {
            progress.SetStatus(Failed);
    }
}
...

Here is the problem… My enumeration was persisted as an integer field on the record. Now that I had a state pattern, how should I save my state? I googled the problem and found Derick Bailey’s article on the state pattern and Fluent NHibernate. Derick’s pattern works well, but I felt that creating a lookup table in my database just so I can persist a value in another table was not the path I wanted to traverse – I wasn’t persisting an entity, I was persisting a state value on an entity. Not finding any more love from Google, I asked around and was advised to contact fellow Elegant Coder and Guild3 member, Jason Grundy. Here is Jason’s advice:

“I’ve recently changed from using Enums to an approach outlined by Jimmy Bogard here.  In the Entity I would do something like this:

protected int _orderStatusId;
public virtual OrderStatus OrderStatus
{
    get { return Enumeration.FromValue<OrderStatus>(_orderStatusId); }
    set { _orderStatusId = value.Value; }
}

Then in Fluent NH you can simply map to the protected member.”

I decided to pursue Jason’s advice.  The result is my database tables did not need to change at all. Here is some snippets of the updated classes:

public class MyProgress
{
     public virtual Guid Id {get;set;}
     ...
     protected int _status;
     public virtual MyStatus
     {
         get{ return Enumeration.FromValue<MyStatus>(_status); }
         set{ _status = value.Value; }
     }
     ...
}

public class MyStatus : Enumeration
{
     public static MyStatus New = new NewStatus();
     ...

     private class NewStatus : MyStatus
    {
         public NewStatus() : base (0,"New"){}

         public override void Start(MyProgress progress)
         {
             progress.SetStatus(InProgress);
         }
    }
     ...

Notice that the MyStatus class is no longer abstract.  However, the subclasses are all private nested classes, each with a value and a display name.  I set each subclass value to match the enumeration value it replaced.  I did not need to convert my existing data to a new schema.

And here is the Fluent NHibernate override:

public class MyProgressOverride : IAutoMappingOverride<MyProgress>
{
    public void Override(AutoMapping<MyProgress> mapping)
    {
        mapping.Map(x => x.Status)
            .CustomType(typeof(int))
            .Access.CamelCaseField(Prefix.Underscore);
    }
}

As you can see, we use convention-based automapping with overrides, but this same map could be used in a standard class map.

Thanks to Jimmy, Derick, and Jason for the inspiration and assistance!

I found the the Beta 56a7 on here.

I also had to remove Plugins.plist and the Plugins folder from ~/Library/Application Support/Quicksilver.

I am ecstatic to report that Quicksilver is up and running again, and my Mac is happy.

I must admit that getting through the first chapter, which tries to introduce the ESB, was not that easy. Too abstract and high level for my taste.

The second chapter is about the State of Integration and discusses how both business and technical drivers contributed to the ESB approach as opposed to Enterprise Application Integration (EAI). One of the best parts in the book is the discussion about “Accidental Architecture” which is an accurate and far too familiar description of the current architecture in most companies. Although the book is approximately 5 years old, it is still very relevant as the adoption rate of ESB’s is still not that common. But then again, I could be wrong about this .   

The third chapter examines the key concepts of an ESB were the author tries to prove that these are born out of necessity, based on real requirements and problems that couldn’t be solved with typical EAI broker architectures (like Biztalk for example).

Chapter 4 states that XML is the exchange format of choice for passing data structures between applications and services. Nothing new here.

Chapter 5 till 8 provide in dept information about each of the key concepts described in chapter 4, like Message Oriented Middleware (MOM), Service Containers and Endpoints, Routing, Transformation, Messaging, etc. …

Chapter 9 goes back to the real world by exploring the most common form of integration that is practiced today: bulk data transfer using ETL and an endless amount of small batch applications. Sounds familiar? This chapter also provides the necessary steps in order to migrate away from latency and reliability issues towards a real-time integration and how this affects your business.

Chapter 10 is a bit more technology focused as it talks about Java Components in an ESB. However, this could equally be .NET or any other platform.

For me, chapter 11 is a real masterpiece especially the part on Portal Server Integration patterns like Forward Cache and Federated Query. Highly recommended reading.

The final chapter discusses the WS-DeathStar (WS-*) specifications and what they could mean for an ESB.

In the end, I have a lot to think about after reading this book. It challenged a lot of my earlier assumptions on distributed computing and it certainly helped me understand a couple of things while I was exploring NServiceBus.

Till next time

In this code case we have Elegant Coders Chris Brandsma and Richard Cirerol (listen as Chris completely stumbles over Rich’s last name), and we are joined by Cory Isakson.  For those of you outside of Bosie, Cory is a local usergroup leader, Code Camp presenter, and .net junky.  We keep trying to get Cory to blog, but so far he is resisting our calls.

• Jimmy’s Blog
• AutoMapper
• StructureMap

Get the show here

Recently, it occurred to me to ask her a seemingly innocuous question:

When a client asks you to make something you’ve never made before, what do you tell them it will cost?

“First of all,” she replied, “every single job is something I’ve never done before.”

Boom. I think we’re on familiar ground here.

I wrote some questions for her to answer in an email and this post shows her responses. Her answers appear in italics.

I find this a fascinating discussion of project estimation and craftsmanship.

What do you do when the client doesn’t know what they want?

There are two kinds of clients that fit into that category: 

1. Those who have some sort of unqualified vision and hazy idea of what they want, but lack the vocabulary and expertise to complete their thoughts
2. Those who want something different from what they have, and don’t really care much beyond that.

Customer  #1 is the most work of the two.  They deserve and require time, since they are paying me for my services.  It takes time sitting with these clients, talking through concepts, drawing things on paper, asking questions and offering ideas trying to get to the core of what they want, what they actually need and what’s physically possible.  I have found that it takes a high level of skill to create something that is perfect to someone else.

Customer # 2 doesn’t happen often, but is a lot of fun!  These are the rare clients that enable my inner artist to flourish and shine, with no constraints or outside demands.  These are the clients want something new and shiny, but don’t have a huge list of demands. They want some sort of element of surprise. 

Problems ensue when I think I’ve got a #2 and didn’t ask enough question to realize I was dealing with a #1. 

How do you charge your clients?

Certain jobs have a set fee.  These are tasks I’ve done for 20 years; I know how long they take, I could do them in my sleep, and they’re the same regardless of the client.  On the incredibly rare occasion one of these jobs isn’t what it appeared to be, my bad and I eat the cost (and I’ll pay more attention next time!).

Other jobs, the custom jobs, are harder to price out.  Now that I have a larger body of work, I have a better idea of how long things take.  If it’s something I’ve never done, I estimate my time in my head, and then (because I’m always overly optimistic in my estimation) I double that to come up with my estimated total of time.  Then I factor in  what my time is worth per hour. 

I also have to know what other professionals are charging for similar services, as it’s tough to get clients if I’m charging twice what everyone else wants for the same service.

Do you tell them up front what a job will cost?

If it’s not a custom job, I always tell my clients the cost up front.  I may adjust the cost of a task between clients, but I don’t change the price after I’ve quoted on non-custom jobs.

Pricing custom jobs is a lot harder.  I run my formula:  estimated time, doubled, multiplied by an hourly rate.  And I offer that as an estimate.  I explain to my customer that it is an estimate to the best of my abilities, and that the price could fluctuate up or down.  I’ve learned that I don’t want the clients who aren’t willing to work within this structure;  these tend to be the people who really, really want custom work and really, really don’t want to pay custom prices.

What do you do when it takes longer than you thought?

I’ve found that the bigger the project, the more willing the customer is to accommodate  an extended deadline.  At the first sign of missing a deadline, I call the customer. It helps a lot, at this point, to be able to show my customer what I have actually accomplish already.

Also, if it’s something I’ve never done before, I tell the client that I’ve never done a job exactly like that one, and my time estimate is only an estimate.

On a long or complex project, when do you consult with the client to guide your decisions?

If it’s a client #2, I don’t usually consult with them once I’ve started the project.  If I’ve come to a point where things veer wildly in opposite directions, I may have the client stop by to choose option A or B.  Usually, with customer #2, I do it how I want to do it.

Custom jobs for a client #1 elicit a lot of phone calls.  I like to check with the customer at each phase when I’m not completely sure what they’d choose;  a 2 minute phone call takes a lot less time than picking 150 staples out of someone’s wingback chair.  I have never had a customer be irritated with me for making sure I was meeting their needs.