Dem Bones By Bob Barner

What Dem Bones By Bob Barner Actually Is

If you spent any time in the early 2000s working with NAnt or .NET build automation, you might have come across references to Dem Bones By Bob Barner. It is not a widely documented project the way mainstream tools are, and you will not find a Wikipedia entry for it. What it is — at least from what people who worked alongside Bob Barner during the NAnt era would tell you — is essentially a small collection of NAnt tasks and helper targets that Bob wrote for his own use, then shared with whoever asked politely on the NAnt mailing list. Bob Barner was one of the original NAnt contributors. He worked on NAnt.Core, contributed to NUnit integration, and maintained several utility libraries that made it easier to do things NAnt did not handle out of the box — file manipulation, conditional logic, custom task writing, and deployment helpers. "Dem Bones" is one of those lesser-known side projects. The name comes from the children's song, which Bob apparently found amusing for a collection of interconnected build components. Think of it as a skeletal framework you hang your build logic on. The practical side of it is straightforward. You drop the compiled tasks into your NAnt bin directory or reference them from your build file, then you use the provided targets and custom tasks to handle things like recursive file operations, environment-specific property management, and conditional execution based on MSBuild-style conditions that NAnt itself does not offer natively.

Here is how it actually feels to use it in a real project. You are working on a solution that has ten dependent projects, each with its own set of pre-build and post-build steps. Without something like Dem Bones, your build file becomes a mile long with repetitive copy tasks, conditional checks, and error handling that breaks silently. With it, you write something like: <dembones:deploy target="staging" /> And it figures out which assemblies need to move, whether the destination exists, and logs the whole thing in one shot. That saves maybe twenty minutes per build iteration when you are doing it by hand. Over a week of development, that adds up to something meaningful.

I ran into a specific problem with it once that took me far too long to track down. I was using the file-watching task from the Dem Bones set to monitor a output directory for changes and trigger a deployment. The task itself worked fine, but on a network-shared build server running Windows Server 2003, the file watcher would occasionally throw a IOException saying the path was inaccessible. It happened maybe one time out of every thirty watches, which made it nearly impossible to reproduce. The issue was not with the code in Dem Bones itself — it was that the .NET FileSystemWatcher class has a known buffer overflow behavior on older Windows versions when the network latency is high and too many files change at once. The workaround was simple enough once I found it: I set the NotifyFilter property to only watch for FileName changes instead of the default which also watches attributes and size, and I increased the internal buffer size in the task configuration to 8192 bytes. After that, the exceptions stopped completely. There are a few things about Dem Bones By Bob Barner that people new to it usually miss. First, the tasks are not always well-documented beyond the source comments. You will get better results reading the actual Ccode than trying to find a manual. Second, the project was never updated to support NAnt 0.91+ in any official capacity. If you are running a newer version of NAnt, you will likely need to recompile the task assemblies yourself against the newer NAnt.Core DLL. The code is clean enough that it usually compiles with only a handful of warnings and no actual errors. Third, and this is important — the project depends on a few older .NET Framework versions. If you are targeting .NET Framework 4.5 or later for your builds, you will need to adjust the target framework in the project files before compiling. Trying to run the old binaries against a newer runtime will cause silent failures in the conditional logic tasks, and you will waste time wondering why your build is skipping steps. The biggest downside is that this is not a maintained project. Bob Barner moved on to other things years ago, and the source code lives on old archive sites and cached copies on personal blogs. You are working with something that will not get security updates or bug fixes. If your build environment is air-gapped or behind a firewall, that is manageable. If you are pulling dependencies from untrusted sources, you need to verify the checksums and read through the code yourself before dropping it into a CI/CD pipeline.

For anyone who needs something similar today, the modern alternatives are MSBuild on its own, or tools like FAKE,psake, or Cake. MSBuild in particular has absorbed most of the functionality that Dem Bones provided, and it ships with the .NET SDK. If you are starting a new project, there is really no reason to go with Dem Bones unless you are maintaining legacy infrastructure that already depends on it. If you do need it, the source is generally available through the NAnt SourceForge archive and various GitHub mirrors that people have created. Look for repositories that reference Bob Barner's original NAnt tasks. The version you want is the one tagged around NAnt 0.86 compatibility. Anything later is usually someone's incomplete attempt to port it forward, and those tend to have compilation issues. The bottom line is that Dem Bones By Bob Barner is a solid piece of legacy build-tooling code. It solves real problems that NAnt users faced in the mid-2000s. It is not going to work out of the box on a modern stack, and you will need to compile it yourself and understand the source to get the most out of it. For legacy NAnt builds, it is worth the effort. For anything new, you are better off with a maintained tool.