blog.adamjcooper.com

Why is my exception being swallowed in my Form’s Load handler?

noreply@blogger.com (Adam Cooper) — Wed, 04 May 2011 21:29:00 +0000

So, you’ve got a WinForms app and you expect an exception to be thrown within your Form’s Load handler. Maybe you even deliberately throw one yourself. But when you start debugging, the execution of your Load handler terminates at the point where the exception was thrown, but no exception is reported and your application keeps running!

This issue was baffling me for several hours today when a colleague of mine pointed me to a helpful post at StackOverflow that explains the problem.

If these conditions are met:

You are running on a 64-bit version of Windows (whether your application is built for 32-bit or 64-bit doesn’t matter; only the bit depth of the OS)
You are building a WinForms app
You are debugging the application with Visual Studio (using default options for Exception catching)
Your main form has a Load event handler
During the execution of your Load handler, an exception occurs

Then:

The exception will be silently swallowed by the system and, while your handler will not continue execution, your application will continue running.If you wrap your handler code in a try/catch block, you can still explicitly catch any thrown exceptions. But if you don’t, you’ll never know anything went wrong.

Note that all of the conditions must be met. If, for instance, you run the application without debugging, then an unhandled exception still be correctly thrown.

According to this Microsoft Connect post, this has been a known issue with 64-bit Windows since 2008:

This is a known issue on 64-bit OS platform. The reason is that the 64bit OS core does not allow user mode exception through kernal mode stacks. The exception is swallowed by OS sliently. That happens in FormLoad handler, because it is called in an OS callback. 32bits OS doesn't do this, so it doesn't repro there.

Paul Betts sheds more technical light on what’s going on, although I believe his post addresses the swallowing of such exceptions even without debugging, something that is supposed to have been resolved for Windows 7 SP1.

Workarounds

If you need the debugger to break during your load method, there are a few things you can do:

Break whenever a CLR Exception is thrown

You can optionally tell Visual Studio to break whenever a CLR exception is thrown, even if it normally would have later been caught (via Debug… Exceptions… or Ctrl+Alt+E).

The downside to this approach is that you may see a lot of “noise” about thrown exceptions that are eventually handled (although in some circumstances this is an invaluable tool to discover exceptions that are being thrown that shouldn’t be).

You can catch exceptions in the other categories as well, but typically it’s the CLR exceptions you’ll be interested in.

Use the Application.ThreadException Handler as a Breakpoint

You can attach a handler to the Application.ThreadException event before running your app, and you can set a breakpoint within it to inspect the original exception that was thrown.

static class Program
     {
         /// <summary>
         /// The main entry point for the application.
         /// </summary>
         [STAThread]
         static void Main()
         {
             Application.ThreadException += (o, args) =>
                 {
                     var x = args.Exception; //Set breakpoint here to inspect args.Exception
                 };
 
             Application.EnableVisualStyles();
             Application.SetCompatibleTextRenderingDefault(false);
             Application.Run(new Form1());
         }
     }

The downside to this approach is that you can get into this handler for all sorts of other things as well. But if you’re just trying to see what’s being thrown during startup, this will do it.

Use a 32-bit Version of Windows

Yeah, it’s drastic, but if you’ve got VMs or other machines available, you can always debug on a 32-bit version of Windows.

Rake for .NET in 5 Minutes

noreply@blogger.com (Adam Cooper) — Thu, 28 Apr 2011 03:54:00 +0000

There’s no question—when it comes to writing build scripts, I’ll take rake over just about anything. Especially anything that requires defining a script using declarative markup (I’m looking at you, MSBuild and NAnt).

If you want to build .NET projects with Rake, here’s the fastest way to get started with Ruby and Rake on a Windows machine (you can skip to the end for an even shorter list).

Install Ruby 1.9

Visit http://rubyinstaller.org/downloads/

Download the latest Ruby 1.9 installer:

Run the installer.

I recommend checking the option to add Ruby executables to your PATH.

Install DevKit

Ruby libraries are called gems. They can be installed and uninstalled from your system as easily as adding and removing an app from an iPhone. Usually.

Some gems come with source code in a language other than Ruby, such as C or C++, and they assume that they’ll be installed on a Unix or Linux style machine system where tools like make, gcc, and sh are present. Naturally, these gems don’t install so well on Windows. DevKit fixes that.

Download the DevKit self-extracting archive from the same page you downloaded the Ruby installer: http://rubyinstaller.org/downloads/

Run the DevKit executable.

When the dialog asks where to extract to, change the folder to C:\DevKit (just consider this the DevKit installation directory).

Open a command prompt and do the following:

cd \DevKit

ruby dk.rb init

ruby dk.rb install

Then, to make sure it installed correctly, do:

gem install rdiscount --platform=ruby

If all is well, you should see the following line while rdiscount is being installed:

Temporarily enhancing PATH to include DevKit...

Update the Gem System

At the command prompt:

gem update --system

This will update the gem system to the latest available version.

Install Gems

faster_require

gem install faster_require

This little gem speeds up the performance of the ruby “require” statement on Windows. In some cases, quite a lot. I always include it on any Windows machine I use.

rake

gem install rake

This is what we’re after, after all.

albacore

gem install albacore

Albacore is a gem with a set of rake tasks that help with building .NET projects, including a task for executing msbuild which you can use to easily build a Visual Studio .sln file.

Done!

That’s it. You’re ready to start building your .NET projects with rake on Windows.

Recap: The Short List

Here’s the shorter list:

Download and install the latest Ruby from http://rubyinstaller.org/downloads. Include Ruby executables in PATH.
Download DevKit from http://rubyinstaller.org/downloads. Extract to C:\DevKit
Install DevKit

cd \DevKit
ruby dk.rb init
ruby dk.rb install

Verify DevKit install

gem install rdiscount --platform=ruby
Should see: Temporarily enhancing PATH to include DevKit...

Update gem system

gem update --system

Install gems

gem install faster_require
gem install rake
gem install albacore

Bad Programmers Will Doom Your Company

noreply@blogger.com (Adam Cooper) — Wed, 09 Mar 2011 16:48:00 +0000

In technology, once you have bad programmers, you’re doomed. I can’t think of an instance where a company has sunk into technical mediocrity and recovered. Good programmers want to work with other good programmers. So once the quality of programmers at your company starts to drop, you enter a death spiral from which there is no recovery.

- Paul Graham, What Happened to Yahoo

How to Open the Classic Logon Screen from XP’s Welcome Screen

noreply@blogger.com (Adam Cooper) — Sat, 29 Jan 2011 11:43:00 +0000

So, there’s this wonderful “feature” for Windows XP that, when you logoff, the password boxes on the Welcome screen don’t actually accept keyboard input (this was affecting me with a clean install of XP with SP3, 32-bit).

Did you know there’s a backdoor to bypass the Welcome screen and use the Classic logon dialog instead?

Just press Ctrl+Alt+Delete twice, and you’re in business:

How to Check that Windows XP is Activated

noreply@blogger.com (Adam Cooper) — Sat, 29 Jan 2011 11:29:00 +0000

In the process of installing a bunch of VMs for our test lab, I couldn’t remember if I’d activated the XP machines or not. Normally you go to Start… All Programs… Accessories… System Tools… Activate Windows, but Activate Windows wasn’t there--which I now know means that activation has (likely) already happened.

But if a missing Activate Windows program icon isn’t enough to convince you that, indeed, your copy of XP is activated, here’s how you can really check:

There is an executable that lives in C:\Windows\system32\oobe called msoobe.exe (I believe OOBE is for “out-of-box experience”). You need to run that with the /a option (I’m guessing for “activate”). When you do, the activation program will start let you know if you’re already activated.

The easiest way to do this is via Start… Run…, typing this into the box:

oobe/msoobe /a

If activated, you should see this:

Create a Hotkey to Enable or Disable Your Second Monitor

noreply@blogger.com (Adam Cooper) — Wed, 19 Jan 2011 22:05:00 +0000

I’ve been doing some multi-touch testing with MultiTouchVista, a poor man’s multi-touch simulator. It lets you use multiple mice to simulate multiple touch points. Unfortunately, it doesn’t play well with multiple monitors (Whatever coordinate data exists for the touch points gets “squished” into the space of a single, primary monitor. So if you have 2 screens side by side and you “tap” at the midpoint of your desktop that falls on the edge of each screen, the actual tap will be applied to the midpoint of the first monitor.)

No problem. I’ll disable my second monitor.

Which is fine.

Until I need to do some real work.

No problem. I’ll just enable my second monitor.

Let’s see… one click, two clicks, three clicks… no, wrong drop down, grr… four clicks, five clicks…

This is ridiculous! I need a hotkey!

Toggle Your Second Monitor with AutoHotKey

This information is already out on the internet, but I couldn’t find it all in once place. So here goes.

If you use autohotkey, there’s an easy way to define hotkeys to turn any of your monitors on and off.

UPDATE: This has only worked for me with the original, non-unicode, “basic” version of AutoHotKey. If you’re using the new AutoHotKey_L, chances are this script won’t do anything for you.

First, you’ll need a couple of monitor management functions (which are separately buried in a old 2006 forum post, and provided courtesey of Lexikos). Don’t be intimidated by how long these are. Just shove them into a separate file, like MonitorManagement.ahk:

; EnumDisplayDevices(Index [, ByRef Name, ByRef StateFlags ] )
;
; Index:        One-based index of device to get info for.
; DeviceName:   [out] The name of the device.
; StateFlags:   [out] Any reasonable combination of the following flags:
;   0x00000001      DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
;   0x00000004      DISPLAY_DEVICE_PRIMARY_DEVICE
;   0x00000008      DISPLAY_DEVICE_MIRRORING_DRIVER
; DeviceKey:    [out] Path to the device's registry key relative to HKEY_LOCAL_MACHINE.
;
; Returns true if the display device exists, otherwise false.
;
/* Example 1 (requires EnableDisplayDevice()):
    SecondaryDevice =
    count = 0
    Loop {
        if ! EnumDisplayDevices(A_Index, DeviceName, StateFlags)
            break
        if !(StateFlags & 8) ; not a pseudo-device
            if (++count = 2) ; second device
                break
    }
    if DeviceName
        EnableDisplayDevice(DeviceName, -1) ; toggle
*/
/* Example 2:
    Loop {
        if ! EnumDisplayDevices(A_Index, DeviceName, StateFlags)
            break
        if (StateFlags & 4)
            text .= DeviceName " is the primary display device.`n"
        else if (StateFlags & 1)
            text .= "The desktop extends onto " DeviceName ".`n"
        if (StateFlags & 8)
            text .= DeviceName " is a pseudo-device.`n"
    }
    MsgBox %text%
*/
EnumDisplayDevices(Index, ByRef DeviceName, ByRef StateFlags="", ByRef DeviceKey="")
{
    ; DISPLAY_DEVICE DisplayDevice
    VarSetCapacity(DisplayDevice, 424)
    ; lpDisplayDevice.cb := sizeof(DISPLAY_DEVICE)
    NumPut(424, DisplayDevice, 0)

    VarSetCapacity(DeviceName, 32, 0)
    VarSetCapacity(DeviceKey, 128, 0)
    ; For consistency, clear StateFlags in case of failure.
    StateFlags = 0

    if ! DllCall("EnumDisplayDevices"
        , "UInt", 0
        , "UInt", Index-1
        , "UInt", &DisplayDevice
        , "UInt", 0)
        return false

    StateFlags := NumGet(DisplayDevice, 164)
    DllCall("lstrcpynA", "Str", DeviceName, "UInt", &DisplayDevice+4,   "int", 32)
    DllCall("lstrcpynA", "Str", DeviceKey, "UInt", &DisplayDevice+296, "int", 128)
    if (SubStr(DeviceKey,1,18)="\Registry\Machine\")
        DeviceKey := SubStr(DeviceKey,19)
    return true
}

; Enables, disables or toggles a display device.
;
; DeviceName:   The name of the device, e.g. \\.\DISPLAY1
; Action:       The action to take.
;                    0   Disable
;                    1   Enable
;                   -1   Toggle (may not be reliable if NoReset=true)
; NoReset:      If true, settings will be saved to the registry, but not applied.
;
; The following can be used to apply settings saved in the registry:
;   DllCall("ChangeDisplaySettings", "uint", 0, "uint", 1)
;
; Return values:
;    DISP_CHANGE_SUCCESSFUL       0
;    DISP_CHANGE_RESTART          1
;    DISP_CHANGE_FAILED          -1
;    DISP_CHANGE_BADMODE         -2
;    DISP_CHANGE_NOTUPDATED      -3
;    DISP_CHANGE_BADFLAGS        -4
;    DISP_CHANGE_BADPARAM        -5
;
; Examples:
;   ; disable display 2
;     EnableDisplayDevice("\\.\DISPLAY2", 0)
;     Sleep, 10000
;
;   ; simultaneously enable display 2 and disable display 1
;     EnableDisplayDevice("\\.\DISPLAY2", 1, true)
;     EnableDisplayDevice("\\.\DISPLAY1", 0)
;     Sleep, 10000
;
;   ; ensure both are enabled
;     EnableDisplayDevice("\\.\DISPLAY2", 1, true)
;     EnableDisplayDevice("\\.\DISPLAY1")
;
; Note: DeviceNames may vary. Rather than hard-coding the device name,
;       EnumDisplayDevices() should be used to enumerate the devices.
;
EnableDisplayDevice(DeviceName, Action=1, NoReset=false)
{
    if (Action = -1)
    {   ; Determine if the display should be enabled or disabled.
        Loop {
            if ! EnumDisplayDevices(A_Index, this_name, this_state)
                break
            if (this_name = DeviceName) {
                Action := !(this_state & 1) ; DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
                break
            }
        }
        ; If Action is still -1, an invalid DeviceName was specified.
        ; The script will attempt to enable the display device, but
        ; ChangeDisplaySettingsEx() will most likely return error -5.
    }

VarSetCapacity(devmode, 156, 0)
NumPut(156, devmode, 36, "UShort")

    ; Set DEVMODE.dmFields to indicate which fields are valid.
    if (Action) ; Enable
        NumPut(0x000020, devmode, 40)   ; position={0,0}
    else        ; Disable
        NumPut(0x180020, devmode, 40)   ; width=0, height=0, position={0,0}

    ; Since CDS_NORESET is specified here, if NoReset=true, the user must
    ; manually call ChangeDisplaySettings(NULL,1) or restart the computer.
    err := DllCall("ChangeDisplaySettingsEx", "str", DeviceName
        , "uint", &devmode, "uint", 0, "uint", 0x10000001, "uint", 0)

    ; ChangeDisplaySettings() is called here for two reasons:
    ;   - A restart is otherwise required to enable a secondary display device.
    ;       See: http://support.microsoft.com/kb/308216
    ;   - Disabling display devices with just ChangeDisplaySettingsEx()
    ;     tends to leave them turned on.
    if (!err && !NoReset)
        err := DllCall("ChangeDisplaySettings", "uint", 0, "uint", 1)

    return err
}

Now that you have that in a separate file, you can include it in your main ahk script and easily create a hotkey to toggle your second monitor (or your first or third or fourth). I’m currently using Ctrl–Backtick to toggle my second monitor. Here’s how:

#Include MonitorManagement.ahk
^`::EnableDisplayDevice("\\.\DISPLAY2", -1) ;toggle second monitor

Modify to your liking.

White button Click() not working? Set your build to x86.

noreply@blogger.com (Adam Cooper) — Fri, 03 Dec 2010 22:37:00 +0000

After about an hour of not being able to figure out why white wasn’t clicking on my buttons correctly, I finally stumbled across this discussion that answered my question.

If you’re on an x64 based system and you can’t get white to click, set your project to build for x86.

NonComVisibleBaseClass Exception When Debugging

noreply@blogger.com (Adam Cooper) — Fri, 03 Dec 2010 21:25:00 +0000

I was using white to automate an installer UI today and I hit an unexpected NonComVisibleBaseClass exception while debugging. And, as I’m sure I’ll hit this again when I start on a new machine, I’m making a note to myself on how to get around this.

Apparently this is a debug-only exception and all you need to do is tell Visual Studio that you aren’t interested in it:

Go to Debug menu and choose Exceptions…
Find the NonComVisibleBaseClass exception
Uncheck the Thrown option
Click OK

Only a Programmer Can QA Your Programming Components

noreply@blogger.com (Adam Cooper) — Wed, 28 Jul 2010 14:07:00 +0000

It seems self-evident, but if you’re developing software components for use by other programmers—APIs, SDKs, reusable controls, whatever—if your QA is being done by non-programmers, you’re just pretending to do QA.

I once worked for a company where the QA process for some of our software components went like this: a developer is told to create a new software component for use by other developers. However, since the QA team can’t test the component directly, the developer should also create a “tester application” that gives the QA team a nice, graphical way of exercising the module. Well, you can imagine what happened.

The “tester application” the developer created only exposed a minimal, even partial, set of functionality supported by the component; enough for the QA team to do a sanity check and make sure the thing isn’t completely broken, but by no means a robust tool for ensuring quality. The reason for this isn’t necessarily because the developer was lazy or didn’t care (though that certainly doesn’t help). Rather, there is a more fundamental issue.

When you ask a developer to create a UI for a non-programmer to test a component that is intended for use within a full-fledged programming environment, you’re essentially asking them to create a programming-language-to-user-interface mapper, a daunting task that will never be able to retain the full fidelity and power of the original programming environment. The dream of easy, graphical programming for the masses has been around for a long time, but it has yet to be attained and arguably never will be. There’s a reason professional development is still done using text-based grammars. Asking your developer to adorn the software component with a UI so the QA department can test it is like asking them to convert a diesel engine to use gasoline. It’s a lot of work that results in something very different than the original.

Graphical testing tools a great for a quick sanity check that your QA team can run. But if you want real, comprehensive QA of your software components, you need a programmer to build an automated test suite that will exercise the component as it will actually be used.

string.KeepOnly

noreply@blogger.com (Adam Cooper) — Thu, 29 Apr 2010 04:33:00 +0000

Often when working with string data you need to strip away certain characters, filtering out some kernel that you’re interested in. For example, you may want to compare two phone numbers to see if they contain the same digits but you don’t care if the formatting is different. Or you may need to strip punctuation, or keep only letters, etc.

Normally when you encounter a situation like this, we pull out a for loop and get the job done. But if you solve any one of the above scenarios directly with an off-the-cuff for loop, you’ve just missed your chance to solve the more generic problem of keeping only certain types of characters in a string. And in C#, this is a solution we can easily package into an extension method:

public static string KeepOnly(this string text, Func<char, bool> filter)
 {
     if (text == null)
         return null;
 
     var sb = new StringBuilder();
 
     foreach (var c in text)
     {
         if (filter(c))
             sb.Append(c);
     }
 
     return sb.ToString();
 }

Armed with this simple method, we can now strip a string of anything but digits like this:

var digits = "(123) 456-7890".KeepOnly(c => char.IsDigit(c));

Which can be packaged into an even more easy-to-read extension:

public static string KeepOnlyDigits(this string text)
 {
     return text.KeepOnly(c => char.IsDigit(c));
 }

Which can be used like this:

var digits = "(123) 456-7890".KeepOnlyDigits();

Which, I guarantee you, is a thousand times more readable and reusable than an inline for loop.

In my .NET utility library I’ve defined a bunch of methods like this for common string filtering. Here’s the entire class:

using System;
 using System.Text;
 using System.Linq;
 
 namespace Cooper.Extensions
 {
     public static class StringKeepOnlyExtensions
     {
         public static string KeepOnly(this string text, Func<char, bool> filter)
         {
             if (text.IsNull())
                 return null;
 
             var sb = new StringBuilder();
 
             foreach (var c in text)
             {
                 if (filter(c))
                     sb.Append(c);
             }
 
             return sb.ToString();
         }
 
         public static string KeepOnly(this string text, char characterToKeep)
         {
             return text.KeepOnly(c => c == characterToKeep);
         }
 
         public static string KeepOnly(this string text, char[] charactersToKeep)
         {
             return text.KeepOnly(c => charactersToKeep.Contains(c));
         }
 
         public static string KeepOnlyDigits(this string text)
         {
             return text.KeepOnly(c => c.IsDigit());
         }
 
         public static string KeepOnlyDigitsAnd(this string text, char additionalCharacterToKeep)
         {
             return text.KeepOnly(c => (char.IsDigit(c) || c == additionalCharacterToKeep));
         }
 
         public static string KeepOnlyDigitsAnd(this string text, char[] additionalCharactersToKeep)
         {
             return text.KeepOnly(c => (char.IsDigit(c) || additionalCharactersToKeep.Contains(c)));
         }
 
         public static string KeepOnlyLetters(this string text)
         {
             return text.KeepOnly(c => char.IsLetter(c));
         }
 
         public static string KeepOnlyLettersAnd(this string text, char additionalCharacterToKeep)
         {
             return text.KeepOnly(c => (char.IsLetter(c) || c == additionalCharacterToKeep));
         }
 
         public static string KeepOnlyLettersAnd(this string text, char[] additionalCharactersToKeep)
         {
             return text.KeepOnly(c => (char.IsLetter(c) || additionalCharactersToKeep.Contains(c)));
         }
 
         public static string KeepOnlyLettersAndDigits(this string text)
         {
             return text.KeepOnly(c => char.IsLetterOrDigit(c));
         }
 
         public static string KeepOnlyLettersAndDigitsAnd(this string text, char additionalCharacterToKeep)
         {
             return text.KeepOnly(c => (char.IsLetterOrDigit(c) || c == additionalCharacterToKeep));
         }
 
         public static string KeepOnlyLettersAndDigitsAnd(this string text, char[] additionalCharactersToKeep)
         {
             return text.KeepOnly(c => (char.IsLetterOrDigit(c) || additionalCharactersToKeep.Contains(c)));
         }
 
         public static string KeepOnlySpaces(this string text)
         {
             return text.KeepOnly(c => (c == ' '));
         }
 
         public static string KeepOnlyWhitespace(this string text)
         {
             return text.KeepOnly(c => (c.IsWhitespaceCharacter()));
         }
     }
 }

Your Mindset is More Important

noreply@blogger.com (Adam Cooper) — Wed, 28 Apr 2010 04:20:00 +0000

It’s amazing how prone we can be to superficial measures of maturity. Sometimes we get it in our head—though we wouldn’t ever say it out loud—that using things like TDD, BDD, IoC, ORM, etc. will automatically lead us to software quality nirvana. It doesn’t.

Kyle Baley has a great article reminding me that, ultimately, what makes a software team great is not the tools or practices that they use, but their mindset. It is only when developers care deeply about keeping the codebase clean and maintainable and producing quality results that these tools and practices show their merit. In order to build truly great software we need to do more than use great tools and say we follow great practices; we need to cultivate and encourage a culture of quality.

Learning F# via Project Euler

noreply@blogger.com (Adam Cooper) — Tue, 19 Jan 2010 05:19:00 +0000

I’m convinced F# is a far more advanced and productive language than the C# I’ve been using for the past 7 years. And having tasted the beauty and power of functional programming with LINQ, lambdas, and extension methods in C# 3.5, I’m anxious to move to a paradigm that’s functional by default.

And yet every time I try to start a personal project in F#, I seem to freeze with questions. Is this really the way I should be building this? Should I be using a class or a record? What was the name of that module again? You know, basic stuff.

So I’ve decided that a good way to learn F# would be to go through (at least some of) the Project Euler problems. Already I’ve worked through the first two and have found the experience to be very worthwhile in general and a nice way to get comfortable with F#. Time permitting I may blog about some of my experiences.

Are ORMs Solving Anything? Yes.

noreply@blogger.com (Adam Cooper) — Tue, 19 Jan 2010 04:46:00 +0000

This was meant to appear as a comment on Shawn Wildermuth's post "Are ORMs Solving Anything?". But it turned out to be too long to be accepted as a comment, so I've posted it here.

This is certainly thought provoking, though I'm surprised that the small consensus here is that ORMs are better suited for small projects. Because, in my experience, it is in the enterprise space that a good ORM (like NHibernate) can really shine.

I think we often assume that using an ORM means generating code or schema. With some ORMs, this is definitely the case. Why, LINQ-to-SQL generates reams of C# code to give you a type safe version of your data schema. And, as you pointed out, you can use tools like NHibernate to go the other direction as well, generating your data schema from your class mappings. If code/schema generation was what made ORMs great, then yeah, I think they'd only be good for newer, smaller projects. But there's a lot more to ORM than code generation that's worth keeping in mind.

In my mind, using a robust ORM (like NHibernate) really makes the most sense in an enterprise context. Here are some of the advantages of using NHibernate on a project of substantial size:

Database agnosticism. If being able to provide a choice in database technology is an advantage to your business, NHibernate can certainly deliver.

Testing. As a consequence of being database agnostic, you can replace your heavy SQL Server with a nimble SqlLite instance at test time, allowing you to write blazing fast tests.

Caching. NHibernate offers a tremendous amount of options and control when it comes to caching. First-level caching is built in, and there are a variety of second-level caching providers you can chose from. Need to add distributed memory caching to your app? Plug into the NHibernate memcached second-level cache provider.

Higher level of query abstraction. Most ORMs allow programmers to query in ways that are more consise (and type safe) than raw SQL. Of course, this can be a performance liability if you don't know what you're doing (or if you neglect to use a good profiler), but overall the productivity gain seems like a win to me.

Dealing with legacy data schemas. A framework like NHibernate offers significant advantages when working with a large, legacy codebase and database that need to be maintained. With it, I can start modeling my own view of the world in code (in a DDD style) and then use NHibernate to map my objects down to the way they are actually represented in the database. Having done that, we can then start querying our domain model directly, allowing the development team to think in terms of the way we think of the business rather than having to constantly translate our intent to a data schema that hasn't grown with the business. And, once we've abstracted away direct access to the database, we can more safely modify the database schema knowing that it is only our mappings which will need updating.

I'm sure someone with more ORM experience than me could add a lot more to the list. But notice that none of the points above are particularly suited for small projects. In fact, quite the opposite. All of these gains are relevant when developing larger projects for the enterprise.

So I suppose what I'm suggesting is that code and schema generation is only a small part of what ORMs offer. Of course there are enterprise situations where performance is so important that an ORM tool is simply not appropriate, but few of us are Amazon or Google, and I would argue that the advantages listed above make long-term maintenance, changes, and refactoring significantly easier rather than more difficult.

I hope this reply doesn't come off as defensive, because, like you, I'm not trying to chose a pro- or anti-ORM side. But I did want to point out some ways in which ORMs can be very helpful in managing large projects.

I do wonder what the future holds for ORMs though, particularly with the rise of functional programming. A language like F# can deal with relational data in a much more natural way than most of the OO languages we've been using for so long, and I wonder how that might change the ORM landscape.

Your chart on the right side of the page illustrates something that astounds me--look at how much stuff we have to do above and below the business objects, which are the real heart of the software! It's amazing how much effort and energy we expend on all of the infrastructural pieces that we need to put in place in order to get real work done. Then again, perhaps the better way to look at it is that we're trying to extract that sweet core of business knowledge out of and away from all of the infrastructure concerns (both front end and back) so that we can swap out the pieces that change without destroying the code that models our business. And that is, I think, the real reason I find value in an ORM.

Hope that helps,

Adam

My Lord, My Truth, My Way

noreply@blogger.com (Adam Cooper) — Fri, 18 Sep 2009 07:51:00 +0000

Shortly before he was arrested and crucified, Jesus told his disciples “you know the way to where I am going” (John 14:4). Where he was going was heaven, to be with the Father. The way there was through the cross he was about to suffer.

But Thomas, bewildered and confused, responded “Lord, we do not [even] know where you are going. How can we know the way?” (John 14:5) To which Jesus said: “I am the way, and the truth, and the life. No one comes to the Father except through me.”

This answer is startling—Jesus has already told his disciples there is a “way” which he must go to the Father (an obvious reference to the coming cross), but now he says that this “way” is himself.
It seems to me this is Jesus’ way of saying that there’s more to his cross than just the wood and the nails and the fact that he died. There is something about Jesus himself in the way he went to the cross that we need to pay close attention to.

Jesus’ death was not a tragedy that could have been avoided, something that just “happened” to him. No, it was a deliberate choice, a choice to sacrifice himself for the good of others, a deliberate decision to lay aside his greatness and stoop low, as low as anyone has, to rescue a sinful humanity. It was this particular aspect of his death, this willingness to humble himself out of love for other people, that Jesus seems to refer to when he says “I am the way.” It is as if Jesus was saying “Look at me Thomas. Watch what I am about to do. Learn from my humble submission to the Father and my sacrificial love for you, and then make my example the pattern for all of your life.” Indeed, he had just told them “just as I have loved you, you also are to love one another.” (John 13:34)

But after an unjust arrest, a brutal execution, and three days of loneliness as Jesus’ body lay lifeless in a tomb, Thomas seems to have lost all hope. How could this be the “way” to the Father? When the disciples come to him claiming that Jesus was alive, he would not hear it. “Unless I see in his hands the mark of the nails, and place my finger into the mark of the nails, and place my hand into his side, I will never believe.” (John 20:25)

Eight days later, Thomas found himself face-to-face with the man he thought he would never see again. “Put your finger here,” Jesus said, “and see my hands; and put out your hand, and place it in my side. Do not disbelieve, but believe.” (John 20:27 ) In that moment Thomas suddenly realized that Jesus’ dying example was not a failure, but a pathway to victory, to which he exclaimed “My Lord and my God!” (John 20:28)

One of my favorite hymns, My Lord, My Truth, My Way, begins with a line that is really a combination of Jesus’ words to Thomas before his death (“I am the way, the truth, and the life”) and Thomas’ words to Jesus’ after his resurrection (“My Lord and my God!”). It is the song of a Thomas-like disciple who has seen the risen Lord and longs to follow in his steps. Here are three verses:

My Lord, my Truth, my Way,
My sure, unerring light,
On Thee my feeble steps I stay,
Which Thou wilt guide aright.

My Wisdom and my Guide,
My Counsellor Thou art;
O never let me leave Thy side,
Or from Thy paths depart!

Teach me the happy art
In all things to depend
On Thee; O never, Lord, depart,
But love me to the end!

You can find the entire hymn at CyberHymnal.