As software developers we are forever scheming on ways to increase the quality of our software.  It’s a great feeling when customers are enjoying some bit of code that you wrote, so making it even better next time is a worthwhile goal.  In contrast, I’ve observed at a number of SaaS development shops have a lack of quality when it comes to the delivery mechanics.  It’s as if once the software is written, the development effort is over and it’s time to tediously prepare for the deployment ceremony.  What I want to write about is the deployment process itself – there’s a whole other topic relating to deployment project management which includes tracking changes, scheduling – perhaps another day on that.

The fact is that many software shops will deploy their services manually.  This may (hopefully) include multiple environments for development, QA, staging, and finally production.  Deployments will have checklists looking something like:

1. Log into target machine.
2. Shut down service.
3. Copy updated binaries.
4. Make any configuration changes.
5. Restart service.
6. Repeat for every target.

If the application has data/schema updates, it could be added as another step in the deployment process.  Likewise, in a multi-target environment there may be preliminary steps for switching out the targets from an application pool.  Finally, in the case of a software emergency, a working roll-back strategy is essential.  A few points:

• Deployment is time consuming
• While each step may only take a few minutes, together it can add up to a significant chunk of a work day.  Multiply that by the target count for the environment - lather, rinse, repeat.
• Steps are error prone
• A missed or botched step may not be noticed until it’s time to turn on the service – or worse, afterwards.  There’s a lot of click-click-typedy-typedy-clicking with not a lot of feedback.
• None of the steps actually require human interaction
• I have never seen a deployment plan where all of the steps and details were not known before hand.  If the plan is not 100% deterministic, it’s probably more of a deployment idea and should be re-thunk’d.

Automating the deployment seems like a no-brainer.  Ayende Rahien makes his views clear -

If you don't have an automated deployment, it generally means that you are in a bad position. By automated, I mean that you should be able to push a new version out by double clicking something. If you can't get automated deployment script in under an hour, you most certainly have a problem.

But how to get from source code to having it automatically deployed?  It takes a bit of setup, but it’s well worth the effort for a project in active development.  Here’s one potential dataflow:

 

1. Code gets written for the project and placed in source control
• All code needs to be in source control – no exceptions!
2. Continuous integration triggers a build
3. Builds artifacts are created by the build server
• For reliable builds, it’s important to have a dedicated build machine - magical or not
4. Project configurations for each potential target
• This includes setting environmental variables and injecting any content needed to make the code run correctly once it is deployed
5. Automated Deployment
• This is essentially a scripted equivalent of the manual deployment process

There are many open source and commercially available technologies catering to each of these functions – I’ll dig into a few of them in some future posts.  In broad terms, it’s a worthwhile endeavor to have an end-to-end software delivery process.  It’s a guarantee that your time and energy are kept focused on doing what’s important – developing software!

Being a Resharper user for the past 5 years, I had to jump on opportunity to try out the publicly released beta for the new 5.0 version.  I’m currently using Visual Studio 2008, but I’ll be glad to have the updated VS2010 support from Resharper once it’s released.  As for the changes in this major revision, I’m excited to try out new code inspections, LINQ integration improvements, and native NUnit integration.

Installation

• Install was quick and easy.  It uninstalled the version 4.5 and questioned me about killing a task that was getting in the way.
• Starting Resharper, I’m greeted with a “License to version 4.0 is not acceptable”.  This is troubling in two ways:
• The license that I bought is for 4.5 C# Edition.
• Why does a beta need a license?
  
• For now, using “free evaluation” – this seems to do the trick.
• As expected, the AgentSmith plugin is no longer installed (duh), but an updated version is available on their site.

New Features

I’d like to be pretty thorough in acquainting myself with the enhancements, so I’ll touch on each of them from the list here.

• Structure Patterns
• Custom built code refactorings.  This could be a godsend for brownfield development – enabling project-wide cleanup for stinky “code smells”.  The real power is in the “Placeholder” templating – it’s much like the Live Templates but for refactoring.  The image onthe right has a pattern that I made to change from timeSpan to happyHour.  Needless to say, this is trivial (and useless!), but I’m readily awaiting the next time I find a code smell I can’t live with.
• Project Refactoring and Dependencies View
• I’ve been waiting for the ability to mass-rename namespaces.  Resharper5 : check. 
• So what does “Project Refactoring” mean?  Does a project have a bunch of types declared in the same files?  After a few clicks, they can all moved into their own:
   
• Dependency View is basically “find usages by project” – which could certainly be useful for larger solutions. 
• Call Tracking, Value Tracking
• Examines method, variable, field or property usage through the solution and finds where it’s being generated or called from, as well as the opposite - where it’s being used.  It’s the static-analysis version of the call stack.
  
• Internationalization
• I’ve never worked on a project using Internationalization, but it’s bound to happen sooner than later. Resharper 5 adds the ability to move string to resource files as well as refactoring and inspection to support multiple languages.
• ASP.NET
• Syntax highlighting!  Check it out - unused namespaces inside ASP.NET markup will now appear grayed out, just as they do in source code.
• Templates for ASP.NET:
  
• ASP.NET MVC
• View name autocomplete from the controller, as well as navigation to and from actions.
• … and navigation to Views.  Shift+Click on a view name to jump there:
  
• Aside: Our project has some calls to HtmlHelper.RenderPartial(“<ViewName>”) called inside of a class instantiated with an instance of HtmlHelper (it’s a Helper for HtmlHelper). Resharper can’t resolve these names… but I wouldn’t expect it to.
• IntelliSense Changes
• In addition to performance improvements, completion can now done using abbreviated names based on CamelHumps:
   
• Bookmarks
• Set and jump to bookmarks with quick keystrokes.  Ctrl+Shift+[0-9] to set, and Ctrl+[0-9] jump back.  Ctr+~  to see which bookmarks are available:
   
• Upgrade to LINQ
• Now this is pretty slick – parses a foreach loop and its innards and translates it to a single LINQ statement:
  
• New and Improved Code Inspections
• So, JetBrain’s says they’ve added a bunch of new code inspections – I’m counting a little over 100 C# Context Actions in 5.0, where as 4.5 had closer to 80.  There appear to be some LINQ related ones in there. They’ve also called out that it can now highlight errors in XML comments (something which the AgentSmith plugin already did quite well).
• Native NUnit Support
• To be honest, I’ve been using the previous Resharper version’s NUnit support without complaint.  I’m thinking that the that the improvements are “under the hood” – it works just as well now as it did before.
• XML Formatting
• Inspection and refactoring support - “Reorder attributes” and “Collapse Empty Tag”, for instance.
    
• External Sources
• This promises to add navigation to referenced libraries that before could only be accessed at the higher namespace-class-method  level via Visual Studio’s Object Browser.  I poked around a bit on JetBrain’s site looking how to configure the symbol locations, but it doesn’t seem to be documented yet.  Perhaps it might need to have the symbols locations populated in VS->Options->Debugging-Symbols, but perhaps not.

Surprises

• Transparently imported settings from 4.5 – horray!  Appears to be able to use the 4.5.resharper shared solution settings
• Running “Find Usages” on a class is taking much longer – in previous version it was instantaneous, now it appears to be scrounging through files instead of an index (could be External sources feature?)
• Quick navigate to Type/Filename/Symbol now match partial names – no more needing to put in a “*” to match wildcards.
• In the day or two I’ve been using it, I don’t think I’ve encountered any crashes.  This is a good thing – the multitude of errors being automatically reported seem to be going to good use.

Wish List

• Javascript.  Being a dynamic language and all, it’d be pretty difficult to implement the full set of navigation and refactoring helpers Resharper provides for C# and VB.  But oh, wouldn’t it be slick if it could.
• Community sharing for code-style and and structure patterns. There’s already preference and template sharing with team members via a shared settings file. The next evolution is to extend this to the cloud and create a public library to exchange ideas with all Resharper users.

For every one of the new features I’ve encountered in the past couple of days, I’m sure there are two or three that I haven’t stumbled over yet.  That’s a great thing about this product – utilizing a small subset of it’s features can greatly streamline development and increase productivity.  Even after years of use, I am still happily surprised to discover new facets of the tool I hadn’t noticed or investigated before.

From ASP.NET MVC in Action section 4.4.1:

Views are difficult to unit test, so we want to keep them as thin as possible. … Notice in [the View Model] that all of the properties are strings. We’ll have the [properties] properly formatted before this view model object is placed in view data. This way, the view need not consider the object, and it can format the information properly.

To facilitate the formatting between the Domain Model and the View Model, a few of AutoMapper’s features may be utilized. Here’s a DomainModel containing a CurrencyProperty which will needed to formatted for human consumption:

public class DomainModel
{
    public decimal CurrencyProperty { get; set; }
}

Now, here is a ViewModel which will be used to transport the formatted value to the View:

public class ViewModel
{
    ///<summary>Currency Property - formatted as $#,###.##</summary>
    public string CurrencyProperty { get; set; }
}

Mapping from Domain Model to View Model

AutoMapper provides an easy way to create a mapping between two object types.  For particular tweaks for individual property mappings, the ForMember method can be used like:

///<summary>Setup mapping between domain and view model</summary>
static ViewModel()
{
    // map dm to vm
    Mapper.CreateMap<DomainModel, ViewModel>()
      .ForMember(vm => vm.CurrencyProperty, mc => mc.AddFormatter<CurrencyFormatter>());
}

This sets up a mapping between the DomainModel and ViewModel and additionally applies a custom formatter for CurrencyProperty.  The formatter must implement the IValueFormatter interface like so:

public class CurrencyFormatter : IValueFormatter
{
    ///<summary>Formats source value as currency</summary>
    public string FormatValue(ResolutionContext context)
    {
        return string.Format(CultureInfo.CurrentCulture, "{0:c}", context.SourceValue);
    }
}

…and a simple conversion constructor on the ViewModel:

/// <summary> Creates the view model from the domain model.</summary>
public ViewModel(DomainModel domainModel)
{
    Mapper.Map(domainModel, this);
}

Now, neither the Controller or View need concern about any formatting and can stay focused on orchestrating and layout:

public ViewResult Index()
{
    var model = new DomainModel{CurrencyProperty = 19.95m};

    var viewModel = new ViewModel(model);

    return View(viewModel);
}

<%@ Page Language="C#" Inherits="System.Web.Mvc.ViewPage<ViewModel>" %>
<asp:Content ContentPlaceHolderID="MainContent" runat="server">
<% using(Html.BeginForm()) {%>
    <%= Html.TextBoxFor(m=>m.CurrencyProperty)%>
<%} %>
</asp:Content>

Aside: TextBoxFor is an upcoming ASP.NET MVC 2 feature that’s available today in MVC Futures or the RC.  Check out Matt’s post for some neat stuff.

Mapping from View Model back to Domain Model

So now the formatted value is being rendered – but how do we go about the reverse trip back to the server?  First, to define an action:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Index(ViewModel viewModel)
{
    var model = new DomainModel();
    
    viewModel.MapTo(model);

    // ... return a view or action result
}

Aside: for validating that what the user enters is in the correct format, see another post about jQuery Validate here.

… and a Map method on the ViewModel:

public void MapTo(DomainModel domainModel)
{
    Mapper.Map(this, domainModel);
}

But this mapping will fail without first creating a definition back from the ViewModel to the Model.  In the ViewModel’s static constructor:

  // from vm to dm
  Mapper.CreateMap<ViewModel, DomainModel>()
   .ForMember(dm => dm.CurrencyProperty, 
    mc => mc
     .ResolveUsing<CurrencyResolver>()
     .FromMember(vm => vm.CurrencyProperty));

This utilizes another AutoMapper method - ResolveUsing - which can be used to get the string property back to a decimal.  The ValueResolver<TSource,TDestination> is defined like so:

public class CurrencyResolver : ValueResolver<string, decimal>
{
    ///<summary>Parses source value as currency</summary>
    protected override decimal ResolveCore(string source)
    {
        return decimal.Parse(source, NumberStyles.Currency, CultureInfo.CurrentCulture);
    }
}

Conclusions

There may be more elegant ways to accomplish formatting for MVC Views, but this method is quite workable.  In particular, I can imagine utilizing DataAnnotations’s DisplayFormatAttribute to decorate the Model or ViewModel and the framework automagically applying the formatting while rendering the View.

When using Jeditable, there is no form element to bind jQuery Validate rules with.  Instead, when an editable element is clicked or activated, it dynamically creates a new form and input element and destroys them after the user is done editing.  For the ViewModel from Part 1, the View might be rendered like so for Jeditable:

<%@ Page Language="C#" Inherits="System.Web.Mvc.ViewPage<ValidateViewModel>" %>
<asp:Content ContentPlaceHolderID="MainContent" runat="server">
<% using(Html.BeginForm()) {%>
    <%= Html.ValidationSummary() %>
    <label for="StringRequired">StringRequired:</label>
    <div class="editable" id="StringRequired" name="StringRequired">
        <%= Model.StringRequired %>
    </div>
    
    <label for="DoubleRange13_100">DoulbeRange13_100:</label>
    <div class="editable" id="DoubleRange13_100" name="DoubleRange13_100">
        <%= Model.DoubleRange13_100%>
    </div>
<%} %>
</asp:Content>

xVal’s ClientSideValidation<TViewModel>() used in Part 1 won’t work to validate this.  The reason?  It generates a script that binds validation directly to the form elements on page load.  The rendered script looks for the ViewModel looks like:

<script type="text/javascript">
xVal.AttachValidator(null, 
    {"Fields":[
      {
         "FieldName":"StringRequired",
         "FieldRules":[
            {
               "RuleName":"Required",
               "RuleParameters":{

               },
               "Message":"This string is required"
            },
            {
               "FieldName":"DoubleRange13_100",
               "FieldRules":[
                  {
                     "RuleName":"Range",
                     "RuleParameters":{
                        "Min":"13",
                        "Max":"100",
                        "Type":"decimal"
                     },
                     "Message":"Must be between 13 and 100"
                  }
               ]
            }
         ]
      }
    ]}, {})
</script>

The rules are in the xVal’s StandardJSON format and the AttachValidator function (in xVal.jquery.validate.js) scans the DOM and attaches jQuery Validate rules as attributes to the matched input elements.  Since Jeditable doesn’t create these elements until they’re actively being edited, the rules have nothing to attach to since they don’t exist yet.  Fortunately, jQuery Validate provides several strategies for defining the rules.  In addition to being able to attach attributes to the input elements, the rules can be placed in a separate data structure.  jQuery Validate refers to these as “static rules”.  Instead of attaching the xVal rule set directly to the elements, it can be adapted to the static rule set that jQuery Validate can use directly.  The structure for the ViewModel rules will look like:

{
    rules: {
        StringRequired: {
            required: true
        },
        DoubleRange13_100: {
            number: true,
            range: ["13”, "100"]
        }
    }
    messages: {
        StringRequired: {
            required: "This string is required."
        },
        DoubleRange13_100: {
            range: "Must be between 13 and 100"
        }
    }
}

.  To get the ViewModel’s rules into this format for javascript consumption, this line is added:

<script type="text/javascript">
    var validateOptions 
        = convertXvalToValidateOptions(
            <%= Html.ClientSideValidationRules<ValidateViewModel>()%>
        );
</script>

 

To get these attached to form elements as soon as the user activates them, Jeditable’s “plugin” feature is utilized:

$(function() { // <- on document ready
    // register plugin with Jeditable to tie in jQuery Validate
    $.editable.types['text'].plugin = bindValidate;
    
    // attach Jeditable to each element with class "editable"
    // Note: this must be done one-by-one so that the 
    // element's name can be assigned to Jeditable's "name" 
    // option which is used by jQuery Validate
    $('.editable').each(function() {
        var element = $(this);
        
        element.editable(
            'SaveUrlOrFunctionGoesHere',
            {
                // submit when the element is blurred
                onblur: 'submit',
                onsubmit: jeditableValidate,
                // assign the name of the input element 
                // from the element's name - this is needed 
                // because it's what jQuery Validate uses 
                // to bind the rules to the input element
                name: element.attr('name')
            }
        );
    });
});

// Jeditable plugin
function bindValidate(settings, self) {
    // attach jQuery Validate to 
    // Jeditable's dynamically created form
    $('form', self).validate(validateOptions);
}

// runs before values are submitted to server
function jeditableValidate(settings, self) {
    // validate the Jeditable dynamically created form
    return $('form', self).valid();
}

With this glue in place, the form elements will now be validated with the rules defined in the ViewModel.  All fields valid:

…and here after both have invalid values:

A few notes:

• Any additional options to be sent to jQuery Validate can be attached to the validateOptions object. I’ve used this to place all error messages into a separate errorLabelContainer (like here).
• I feel that AttachValidator function in xVal.jquery.validate.js from could become more loosely coupled by separating the rule conversion from the DOM element attachment.

I think both of these jQuery libraries provide a great benefit when creating interactive and helpful forms.  Kudos to Jörn Zaefferer and Mika Tuupola for the good work.  xVal is likewise an excellent library – thanks to Steve Sanderson.

I was recently tasked to add server-and-client-side form validation for an ASP.NET MVC site - which already uses in-place editing courtesy Jeditable.  I really like the field editing experience that Jeditable provides – it makes form entry in the browser interactive, is fairly straightforward to integrate, and it’s adaptable to many scenarios.  It does not, however, have any validation mechanism built in. 

Our project already used jQuery Validate for a few forms by using the HTML class definitions – like adding class=”required phone” to an INPUT element.  This works great, but doesn’t provide any server-side validation tie-in.

Earlier this year, I remembered having seen a presentation by Elijah Manor who mentioned using xVal for robust server and client side validation. And with the news that MVC 2 will have a built in validation technique similar to xVal, it was an easy decision to start investigating this library.

xVal is a pretty easy to get integrated.  The first step is to decorate the model with validation rules – I’ve decided to use .NET framework’s DataAnnotations, which ends up looking like:

public class ValidateViewModel
{
    [Required(ErrorMessage = "This string is required")]
    public string StringRequired { get; set; }

    [Range(13, 100, ErrorMessage = "Must be between 13 and 100")]
    public double DoubleRange13_100 { get; set; }
}

public class ValidatedController
{
    public ViewResult Index()
    {
        return View(new ValidateViewModel());
    }
}

<%@ Page Language="C#" Inherits="System.Web.Mvc.ViewPage<ValidateViewModel>" %>
<asp:Content ContentPlaceHolderID="MainContent" runat="server">
<% using(Html.BeginForm()) {%>
    <%= Html.ValidationSummary() %>
    <label for="StringRequired">String Required:</label>
    <%= Html.TextBoxFor(m => m.StringRequired) %>
    <%= Html.ValidationMessageFor(m => m.StringRequired)%>
    
    <label for="DoubleRange13_100">Doulbe between 13 and 100:</label>
    <%= Html.TextBoxFor(m => m.DoubleRange13_100) %>
    <%= Html.ValidationMessageFor(m => m.DoubleRange13_100)%>
<%} %>
</asp:Content>

To validate this ViewModel server side, we use a DataAnnotationsValidationRunner like the one in xVal’s documentation:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Update(ValidateViewModel model)
{
    try {
        DataAnnotationsValidationRunner.ValidateModel(model);
        // it’s valid, do the actual update
        var domainObject = ValidateDomainModel.Find(model.id);
        Map(model, domainObject);
        domainObject.Update();
    }
    catch(RulesException ex) {
        ex.AddModelStateErrors(ModelState, null);
    }

    return ModelState.IsValid ? RedirectToAction("Completed")
                              : (ActionResult) View();
}

public static class DataAnnotationsValidationRunner
{
    private static IEnumerable<ErrorInfo> GetErrors(object instance)
    {
        return from prop in TypeDescriptor.GetProperties(instance).Cast<PropertyDescriptor>()
               from attribute in prop.Attributes.OfType<ValidationAttribute>()
               where !attribute.IsValid(prop.GetValue(instance))
               select new ErrorInfo(prop.Name, attribute.FormatErrorMessage(String.Empty), instance);
    }

    /// <summary>Validates the given <param name="model">model</param></summary>
    /// <exception cref="RulesException">Thrown if any errors are found</exception>
    public static void ValidateModel(object model)
    {
        var errors = GetErrors(model);
        if (errors.Any())
            throw new RulesException(errors);
    }
}

Aside: the project uses the Active record pattern via Castle ActiveRecord for data access without an intermediate business-logic layer.  For this case, the rules are defined on the ViewModel and are validated in the controller.  This does add some noise in the actions – I’m definitely interested in other methods for handling this. Such as - perhaps the validation could be placed inside the ViewModel?

The next step is to add client-side validation.  xVal’s built-in jQuery Validate rule generator makes this ridiculously simple – just reference jquery.validate.js and xVal.jquery.validate.js in the view, and then this single line:

<%= Html.ClientSideValidation<ValidateViewModel>() %>

The rules defined in the ViewModel will now be validated client side and enforced for server side actions.  This works great for a statically defined HTML form, but I learned that integrating with Jeditable’s dynamic inline forms to be not so straight forward.

Continued in Part 2…

Interacting with your computer using a mouse-driven GUI makes many tasks quick and easy to accomplish.  However, when use of the keyboard is required, a healthy amount of context shifting between these two non-complimentary input devices can occur.  And that’s bad news for turning thoughts into actions in a timely matter. So, what’s the consequence of spending a few extra seconds to switch back and forth?  As John D. Cook points out, it adds up:

It’s a matter of keeping up with your thoughts. Suppose some series of tasks takes 20 seconds with a mouse but you can accomplish the same tasks in 12 seconds using the keyboard. The big deal isn’t that you’ve saved 8 seconds; the big deal is that you’re more likely to finish your tasks before you lose the thought that motivated them.

I interact with the file system on a very regular basis.  I haven’t measured this, but I bet I’ll open Windows Explorer (or xplorer²) at least two or three times for every hour I’m at the computer.  I’m forever poking around for documents and restructuring directories so that they’ll be easier to find next time.  Many times I’ll want to execute a command line statement in the path that I’m browsing.  There are several different strategies for getting a “Open Command Prompt Here” to the explorer context menu, but they all require a right-click (or simulating one with the keyboard).  There’s an easier way.

A couple years ago I read an article on instructables about a “Drop Down”, Quake-style command prompt for Windows.  The project uses AutoHotKey to launch and hide a console window using a keyboard shortcut.  Neat!  It works great, except that it always dumps you in the your %HOMEPATH%.  I’ve taken the script and upgraded it to navigate directly to the currently open path in Windows Explorer – it’s name is Tilda.

For example – I’ve got an explorer window open in C:\console\UnxUtils\usr\local\wbin and I want to string some of those juicy unix command line utilities together.  I can now simply do Win+~, and I’ve got a new console instance in the right place.  As with the original, it will minimize/maximize the console window on subsequent usage of the key combination. 

I have this nasty habit of navigating around the file system when I’m using Windows Explorer.  After running some unix commands, I might have a hankering to run MSBuild.exe (ok, probably not, but who knows?).  I could tediously type the path, or, I could have Tilda automatically enter it for me.  From the new path in Windows Explorer, I type a combination Win+Shift+~ and the chdir command gets sent to the current console window.

Please note that I’m using (and recommend) Console as a command line window host.  Tilda is currently set to use this, but the script can be easily modified to use cmd.exe or whichever console window host you prefer.

Tilda - open and close a console window using a hot key.  Automatically navigates to the currently open explorer window.  Save some trips to the mouse and make getting to the command line easier.

Download Tilda (AutoHotKey source and binary)

Hi, I’m James Kolpack, and I’m a code-aholic.

Where I’m from

Ever since I was a kid I’ve been programming at various degrees of sophistication.  Being a child of the 80’s, I started with Basic (of the GW variety on a 8086 based IBM) with a dash of Logo and batch scripting.  Later in college I became learned in Pascal and then C and the trials and tribulations of memory management and complex data structures.  I loved the ability to solve interesting problems by the clever assembly of instructions to be executed on a computer.  It was a bit of a power trip, really - “Pow, I just made a program that can find the optimal combination of items to fill a knapsack in psuedo-polynomial time.”  This capability does not, I discovered, transcend one-to-one to “real-world” power – but you’ve got to do what you can with what you’ve got.

As for the name of the blog, “popcyclical”, it’s a dual homage to my interest in cyclical relationships and, of course, popsicles.  It also references my moniker “poprhythm” which I was given many years ago for my ever-loving devotion to excellent music.

Where I’m going

On this blog I will be exploring ideas and issues that are relevant to me at the given time.  As a developer employed at a small shop, the focus is guaranteed to wander over time.  For any given week, I may be highly invested in any number of   topics.  This may include : upcoming features of programming languages, graph algorithm design and application, development tooling, data mining, system architecture, user experience, natural language processing, semantic web, test driven development, statistics, data management, … these and many others are all fair game.  As of today, the technologies I’m working in from day to day are C# on the .NET framework, ASP.NET MVC and jQuery, WCF, and a variety of database engines.

I can use your help

When pointing the finger of blame for a problem I’m faced with, more often than not, that finger will eventually turn back to point at myself.  To err is human, and for software creators, this is repeatedly beaten into our skulls. Every time a compile fails, a stack overflows, a user is confused with our design, an out of memory exception is thrown, and every other time we’ve had a slip of the finger or a misconception about the problem or a technology. To combat this, we must flock together to overcome our individual weakness.  I welcome all relevant comments, suggestions, and criticism.