I've come across a small number of AJAX animation progress generators and a few pages with a fixed listing of generators, but Ajaxload is by far the best one I've found so far:

Very well designed (and useful) little utility.

The best devtool ever? Or the best devtool ever?  You decide; I present the fantabulous Terminals.

Once you've lived with it, you can't live without it.

It addresses several shortcomings with the default RDP/Terminal Services client in Windows, namely:

• Lack of support for tabbed viewing of connections (who likes to have 5 different Remote Desktop windows open?).  Terminals supports tabbed browsing of Remote Desktop connections.
• The need to save one .rdp file for each connection...what a pain in the butt!  Terminals supports saving of the client connection information for you automatically.  Not only that, it can add configured connections to a toolbar for easy access (instead of hunting down saved files).
• Lack of tools for connectivity testing.  With the default MSTSC, it requires you to jump to the command line to run ping and other utilities when testing for connectivity.  Terminals has it built in!  Awesome.
• No support for connection groups.  Quite often, when working with VMs or remote machines during development, you have to access the same group of machines at the same time (for example, a server and a client).  With the default MSTSC, you have to manually start the two connections or write a batch file to open them at the same time.  Terminals has a grouping feature which allows you to initiate grouped connections automatically.

During development, even with VMWare running locally, I prefer to use a terminal services connection instead since it's way more responsive to user input.

Terminals is definitely awesome.  There are still a few issues like auto-scaling and auto-resizing which don't work quite right yet, but otherwise, it is fantastic.  Note that it also doesn't support connecting disks and printers and what not (maybe next release).

Okay, so this isn't strictly a development tool, but Gantt Project has a pretty nifty, free, project management application.

With GanttProject you can break down your project into a tree of tasks and assign human resources that have to work on each task. You can also establish dependencies between tasks, like "this task can't start until this one is finished". GanttProject renders your project using two charts: Gantt chart for tasks and resource load chart for resources. You may print your charts, generate PDF and HTML reports, exchange data with Microsoft(R) Project(TM) and spreadsheet applications.

The site also mentions a good point with regards to Project:

• Good (and growing!) set of basic features. This set is enough for most people (remember that 80% of MSProject customers use 20% of it's numerous features)
• Easy learning. You don't need thick manuals to start working with GanttProject. If you are familiar with the notion of tasks, assignments and dependencies, you'll become an expert in GanttProject in a couple of hours.

Check it out if you're in the market for a free, simple, task based project management.

Wow, it's been a looong time since I've added one of these.  I have a whole backlog of tools that I could add, but let's get to one of the important ones:

One of the really annoying things about Visual Studio is that renaming a project in the IDE doesn't change the name of the directory in the file system (or your source control).  Of course, updating the string in the code files is not so bad, but then you also have to go through all of the project and solution files to change all of those occurrences.

That's where the _REPLACE.EXE utility comes in.  Using a series of commands like the following:

_replace.exe "<old-string>" "<new-string>" /i /s /ext=.csproj
_replace.exe "<old-string>" "<new-string>" /i /s /ext=.sln
_replace.exe "<old-string>" "<new-string>" /i /s /ext=.cs
_replace.exe "<old-string>" "<new-string>" /i /s /ext=.resx
_replace.exe "<old-string>" "<new-string>" /i /s /ext=.config
_replace.exe "<old-string>" "<new-string>" /i /s /ext=.xml

You can pretty much replace most of the string names in your project by using that set of commands (and additional ones for any other file extensions).  What's cool is that you can also use the /t command line switch to do a dry run.

Very handy indeed.  Do keep in mind that you still have to go in and manually change the directory names but it's far more efficient than twiddling around with a text editor to replace the string in each of the project/solution files.

So my interest in NHibernate is picking back up again.  The 1.2 beta release that's circulating now (the candidate release has been out since February of this year) addresses various issues with NHibernate in my previous time with it.

Specifically, the biggest issue was native support for generic types.  In addition, it seems like there are various other goodies in the 1.2 release such as stored procedure support.

And to think, I just got the team to standardize on Microsoft Enterprise Library 3.0.  I'm wondering how to break this to the team.

I guess in a sense, they are not completely incompatible.  Roll your own queries and data access routines are still the way to go for more complex queries (does NHibernate handle FOR XML EXPLICIT?) and anywhere high performance is critical.

The beauty of this whole thing is that as NHibernate has gained traction since the first time I used it like 2 years ago, the tool support has evolved tremendously.  Combined with MyGeneration and user templates, I was up and running (although the generated output had some minor errors in the XML mapping file) in minutes.  Not only has the tool support improved, the documentation has improved as well.

There is still some conflict, internally, as I was just ragging on LINQ last week with another group of developers for the simple fact that it creates a tight coupling between code and the raw data.  Whereas with stored procedures, you can have dedicated DBAs write highly performant code and you can modify the underlying data retrieval and layout so long as you maintain the same resultset, with dynamic queries, you lose a lot of that flexibility.  In addition, you lose a bit of testability as well since many times, it's just really helpful to be able to test the SPROC independently of any code (or perhaps breakdown subqueries in the SPROC to test small subsets of data).

In actuality, I think that having the mappings as XML is probably better than using LINQ since the XML mapping files can be loaded at runtime, meaning that the deployed mappings can still be manually updated whereas LINQ would necessitate a recompile of the source (my understanding of it).

So if you haven't checked out NHibernate for a while, now's a good time to get a refresher and re-evaluate the library.  I think it will still stick around even after LINQ is released.

Anyone who has used the .Net XmlSerializers have surely encountered the dreaded namespace bloat which makes the serialized objects grow to ridiculous sizes.

There's a nice little article over at TopXML on how to deal with this bloat.

If you're using WSCF, on the client stub, I've gotten into the habit of writing custom serialization overrides in partial classes which ensure that if the client needs to serialize objects into XML, I'm doing so in an efficient manner.  It'd be nice to see it added to the server side class constructors as well.  Add your vote for this feature over at the WSCF dicussion boards.

Spring.Net is an application framework which has its roots in the Spring Framework for Java.

Now first of all, I know many developers have an averse reaction to the use of the phrase "application framework" and immediately reject such things without second consideration.  I always hear tales that begin like so: "Well, on this one project, we used an application framework and it ended up not doing anything exactly the way we wanted and we had to modify it anyways..."

Four thoughts on this:

1. No two applications are exactly alike.  If that were so, we'd all be out of jobs as software engineers because it'd probably have already been done before.  As well, no two application frameworks are alike (although on some level, Spring is interchangeable with Castle).
2. Spring, I have found, does not restrict me in anyway in terms of my solution design.  If anything, it frees me to use more flexible designs and allows me to create much cleaner and better designs.  Inversion of Control is your friend.
3. Spring includes the source.  Dude, if it doesn't do exactly what you want it to, you are 100% free to modify and reuse it (and maybe even resubmit it to the project if it's well written and useful).
4. The documentation and development team on Spring (and Castle to a lesser degree) are great.  The documentation is very thorough and well organized and the developers are constantly monitoring the discussion forums and reaching out to users.  Many times, with any sort of large library, you may be under the impression that it doesn't do something (thus leading you to believe that you have to write it anyways and believing that it was pointless to use the framework), but it may actually be the case that you simply haven't found the facilities in the library to accomplish your task.

On top of this, the support forums and developers working on the framework are great resources for hashing out design ideas (outside of one's normal circle of peers).

Yes, it's true, Spring requires the use of what can become massive XML configuration file(s).  Yes, it can be difficult for first timers to grasp inversion of control, understand what exactly it is that Spring offers, and in general, find anything in Spring that would significantly make one's life easier as a developer without a learning curve.  Yes, Spring is huge; it encapsulates a lot of "stuff" that can be confusing and seem like bloat one's first time encountering it (I myself only ever use a small subset of the features of Spring).

However, in the end, I think Spring brings so much to the table (too much for me to list here), it's hard to discount it without at least giving it a real evaluation.  For any sort of non-trivial application, Spring allows the designer to add much more flexibility and decrease the complexity of the codebase by encapsulating a lot of the dirty work.  (I would agree that there is a complexity cutoff where if your application sits below this cutoff, it's simply not worth it to include Spring in the discussion, as the time it takes to understand and find its usages in your scenario would not be worth it).

I've been using Spring for almost a year now and I simply can't imagine writing an application without it.  With the latest release, the introduction of the data access library, Spring becomes even more compelling by removing a lot of the boilerplate code that one would write when performing data access.  Admittedly, in a sense, it is a replacement of one set of boilderplate code for another, but it is a much more elegant design than using raw ADO or even Enterprise Library for that matter.  Spring introduces the usage of a delegate/callback pattern for "rendering" the returned data rows and sets into domain objects and sets.

I use the term rendering because this is the same exact pattern that I've been using with regards to the JavaScript that I've been writing for my AJAX enabled applications.  It's an elegant pattern that, in JavaScript, allows for decoupling of the code to retrieve that data from a web service and the code that renders the data.  In a sense, Spring does the same, except, instead of rendering a UI, it renders a domain object (or set) using the delegate, which decouples the data access plumbing from the building of the domain object.

Having used NHibernate previously, I have to say that in many cases, I still prefer performing my own data access code and domain object rendering as it allows me much more flexibility and control.  There is less processing overhead and not to mention (when I last checked) NHibernate still does not natively support generic types.

I've mostly been sticking with Enterprise Library, which is basically just a step above raw ADO, but I'm gonna give this a shot since it's yet another step or two above Enterprise Library.

On another note, it seems like Microsoft's Patterns and Practices Group is finally releasing the next version of Enterprise Library.  In a sense, EL is a "necessary evil".  As far as 2.0 goes, I cannot say that it does anything particularly better than other libraries that fill the same purpose as any given block, but what it does do is it encapsulates multiple functional spaces (logging, data access, exception handling, configuration) into one.  In addition, having the Microsoft Seal of Approval also helps with acceptance.  As an example, the rolling flat file trace listener has had a counter part in log4net since I've been using it (over 1.5 years now).  The data access application block, while it does clean up data access code, is still pretty close to raw ADO.Net usage patterns; in other words, it brings almost nothing to the table (almost; I still endorse it over raw ADO.Net to be sure).

It'll be interesting to see what this Object Policy Application Block actually does.  It seems like it's conceptually similar to Spring's IApplicationContext or Castle's Windsor Container.  I'm not one to latch onto a product simply because it's from Microsoft's P&PG, so I'm hoping they can actually bring something new to the table to make their library more compelling than Spring or Castle (both of which are much more mature by now and encapsulate a far greater set of features).

As for the any concern over the longevity of Spring and Castle, I feel pretty confident that what happened to NDoc, will not be happening to Spring or Castle.

Welcome to another entry of Random DevTools!  It's been quite a while since the last post, but the wait is worth it!

Well, what we have today is a general tool that's sure to help anyone out.

As a developer, I spend so much time launching a variety of applications.  Visual Studio, web browers, digging through my project directories, Query Analyzer, and so on.  It can be quite tedious to have to trod through the Windows Start menu.

Fortunately, there are a variety of application taskbars out there like ObjectDock, for example.  But I've found ObjectDock to be a little too fancy for my simple needs and a little too resource intensive on my laptop.  In addition, I recently had a weird error with it on my wife's laptop where it would cause the task bar to disappear (even though I did not set the option in ObjectDock)...took quite a while to figure out that it was ObjectDock causing it.

Enter Kana Launcher.  This is exactly what I've been looking for in terms of application task bars.  It's small, simple, lightweight, easy to use, and performant.  What I like best about it is that the little floating task bar shows up where your mouse is, so getting to the application you want to launch only requires the minimal amount of mouse movement.

Kana Launcher also has a full size listing (like a context menu) with folders where you can organize all of your applications and what not (the floating task bar is a subset of the full list).

Best of all, it's free (and we always like free on the Random DevTools list)!

Note that you can add all sorts of launchers to it.  You can open up to a specific folder.  You can open up FireFox or Internet Explorer to a specific URL.  You can
launch command line applications with arguments in it.  All you have to do is create an application shortcut on your desktop and then drag it over to the Kana Launcher.

Web development in IE just got a whole lot better (well, at least for me).

Enter Microsoft's Internet Explorer Developer Toolbar (link).

This is one area where IE has been just left behind in the dust by FireFox.  But this is definitely a nifty add-on!

Just a short outline of the features:

• Built in validation from a dropdown.  Nifty and convenient.
• Built in onscreen ruler!  This is awesome.
• Ability to quickly resize the window.
• DOM browser like FireFox.

And a ton of other stuff.

If you make webpages for a living, then all I can say is: Must. Download. Now!

Note that after installing it, you have to enable it by selecting it from the View->Toolbars menu item (it's instinctive to look in the Tools menu and get baffled by the lack of new menu items).

Update: there's also a non-Microsoft, FireFox analogue.

Today's entry is Windows Installer XML (WiX for short), an open source project (the first?) from Microsoft that is used internally by Microsoft development teams for building installers for many of their products.

I first used it more than a year ago when I was at Merrill Lynch.  I had to build an installer for a Windows Serivce and I wanted the service to auto-start after installation.  I was totally baffled by how to do this in the VS installer projects (is it even possible?) and somehow ended up stumbling across WiX.  It worked great It was a little rough going because there was so little documentation and Net knowledge regarding usage.

Since then, I haven't really had a reason to look beyond the built in VS installer projects, but I'm working on another complex installer scenario now and decided to check in on WiX again.  To my surprise, there still doesn't seem to exist a UI to design WiX installation packages (at least none that I came across via googling).

However, I did find a very well done tutorial.

Of course, Rob Mensching's blog is full of news and developments on WiX.

Rob mentions in his first post on the subject of WiX that:

Internally, teams such as Office, SQL Server, BizTalk, Virtual PC, Instant Messenger, several msn.com properties, and many others use WiX to build their MSI and MSM files today.  When someone encounters a bug, the community tracks the issue down and fixes it.  Now, via SourceForge.net, you have an opportunity to be a part of the community as well.

I guess it's also good to note that WiX just celebrated it's 2-year OSS status recently.

Oh yeah, we're kicking it up with the DevTool entries.

That's typically what happens as I ramp up on a project; I'll end up coming across a whole slew of awesome tools that I end up aggregating in my C:\Program Files directory (my application menu is about to go past the second page...I had to uninstall a lot of stuff previously to get it back down to two pages).

Today's entries are tools to help you think "contract first".  I hadn't really thought of XsdObjectGen.exe as a tool that helped you work in a contract first fashion, but Peter Bromberg seems to think so and so does David Truxall.

Unfortunately, XsdObjectGen.exe, as great as it was, is ill suited for .Net 2.0 and the introduction of generic types and lists.  I briefly contemplated using it for my .Net 2.0 project that I'm on now, but couldn't bring myself to it; there must be a better way, right?  Well, up until now, the only other .Net solution that I had come across was Matias Wozloski's GAT implementation (with slight modification?) of Daniel Cazzulino's (kzu) version of XsdObjectGen.  Having looked at that and the new xsd.exe that ships with VS2005, I have to say that I'm sorely disappointed in both since they rely on the XmlSchemaImporter and XmlCodeExporter classes to do their dirty work.  The resultant markup is not nearly as nice as the output from XsdObjectGen.exe.  As I've mentioned in the past (see the end of my workshop on XsdObjectGen.exe), while kzu's implementation is obviously much more flexibile since you can create new extensions and what not, it is ultimately somewhat clunky and not as easy to work with.

I briefly contemplated extracting the source from XsdObjectGen.exe and rewriting the codebase (it uses sort of an "intelligent templating" approach) to utilize some of the .Net 2.0 code features and generate better code, but after digging through it with Reflector, I realized I didn't have enough time (and I probably didn't have the rights) to extract and rewrite the codebase.

Enter dingo and thinktecture's WSCF.  While dingo is still strictly a .Net 1.1 tool, the project leader has a recent news item that claims forward development will continue this summer after some more work on a rules engine (anyone know of .Net APIs for working with RuleML?).  WSCF, on the other hand, looks like it's good to go with respect to .Net 2.0.

So have a look at WSCF.  I'll be downloading and evaluating it today and keep this updated with my take on it.

Update: See comments.

I installed an updated version of the NUnit VS add-in (aka: TestDriven.Net) today and discovered this little tool called NCoverExplorer.  Curious, I started to dig into it and that lead me to NCover.  NCoverExplorer is a GUI interface to NCover output files. 

What is NCover?  It generates code coverage information when it runs your NUnit tests so that you can see how much of your code base your tests are really touching (I perfer the output from Cenqua's Clover.Net, but I guess that's just a matter of using a better XSL transform?).

Both are great tools and should work their way into your development cycle!

It helps to have a simple batch file to run it:

"C:\Program Files\NCover\NCover.Console" "C:\Program Files\NUnit-Net-2.0 2.2.7\bin\nunit-console.exe" "..\bin\debug\SomeProject.Tests.dll"

PAUSE

In an automated environment, you'll want to take out the PAUSE.  It's only there so that if you're running it manually, you can watch the result of the run.

Every developer/graphic artist hybrid like me eventually comes across the need for some spiffy icons to go with our badass applications.

Good icons are hard to find.

Good free icons are harder still.

So it's a rare moment when I come across good, free icons.  So I must share

http://www.famfamfam.com/lab/icons/

Excellent icons.  Enjoy.

While browsing the Dojo Toolkit site today, I noticed their bug tracker.

Hey now, this looks sharp!

Turns out it's this product called Trac by Edgewall Software.  Best of all, it's open source!  Looks good.  I'll have to see if I can convince anyone to use it.

I have to say, I've taken a long look at Bugzilla and the thing that turned me off (I know, it's rather shallow of me) is the sub-par interface.  I guess it was designed to be highly portable across browsers and platforms.  But damn, it looks like they didn't even bother making it a bit more attractive.

The TracBrowser feature is great too!  Code browser, HTML diff viewer, and all hooked into Subversion.  Incredibly awesome.

Maybe it's a good time and incentive to learn some Python? 

Random link: some Python IDEs reviewed.

(Random) Update: I spent some time whipping together a nifty little Subversion _svn directory cleanup script It's great.  Simply download the file or copy the contents into a new .vbs file.

I've been meaning to do this for quite a while.  It's written in VBScript and based off of another script (which, for the life of me, I cannot remember where the original source is from).  You will need to have Windows Script Host installed (I believe) to be able to run this script.  Simply place it in the root directory of your project and it will remove all "_svn" directories in the context directory (directory you placed it in) and recursively into the sub-directories as well.

There is one confirmation dialog that allows you to change your mind and cancel the deletion if you double click it by accident.

Just the thing you need when zipping up and sending a project to someone without a Subversion client installed.

Enjoy!

I'm feeling a mighty JavaScript kick lately.

What's interesting is that the more C# evolves, the more it starts to resemble JavaScript.  What with anonymous methods, type inference (it even uses var), and the LINQ syntax, my JavaScript juices are flowing.

There are a few things that I never wrapped up with my JavaScript development experience.  I think the most glaring one is JavaScript inheritance.  Some would argue that JavaScript inheritance is purely fluff (see second comment); it's not needed and JavaScript is probably more powerful for not adhering to OOP principles.

I dunno...it seems like one of those things that would be useful for building certain structures and UI elements.

I've been aware of Douglas Crockford's implementations for quite a while now.  I came across it when I first picked up on JSON about a year and a half ago, but I never particularly liked it since it "looked weird".  So today, as I was looking around to see if any alternatives have risen due to the recently revived JavaScript development, I came across a posting on SitePoint.  I rather like the simplicity of it all and it looks like it works, so I'll have to keep that in mind if I need to use it.

As I'm also thinking about writing a major web based rich UI application in the next few months, I've also been looking at some of the JavaScript libraries, toolkits, and frameworks that are out there.  I came across the Dojo Toolkit today and it looks fairly interesting.  I especially like the bind() syntax.  However, the toolkit does seem somewhat incomplete at the moment...I'll have to take a look at it in more detail and see if it has the features I need.  It's currently lacking any demos, which makes it hard to evaluate without a deep dive.

This brings up another interesting issue that has annoyed me with the proliferation of all of these JavaScript and AJAX libraries: instead of pooling talent and building The Best Possible Solution, we have teams going off left and right building 15 different impelementations of the same thing with 15 different design principles and 15 different philosophies.  Now this isn't necessarily a bad thing, as there are times when you would prefer a lighter implementation to a heavier one, for example, but it would make a hell of a lot of sense to have at least a common convention in terms of naming, package layout, and what not.  Ideally, what I'd like to see is some of these development tracks merge so that we may have more complete frameworks/libraries/toolkits.  Have one mega package that comes in mega-lite flavor, you know? 

With so many libraries/frameworks floating around, it makes it difficult to find the exact set that does what you need and if you do, you need to start worrying about whether they'll play nice.

I'll stop, because I'm just ranting now

I've been doing some WinForms work lately (I'm primarily a WebForms developer) and had a lot of trouble working with the WinForms DataGrid.  Primarily, the DG just seemed very difficult to customize in terms of behavior and look & feel.  Whereas with the WebForms version of the DG, the declarative model and the power of CSS makes it a snap to do these things, the WinForms version just took way too much work.

So after looking around and trying a few open source controls, I finally stumbled on DevAge's SourceGrid3.  I really like it.  It allowed me to do things with a grid that simply were waaaaay too time consuming/difficult with the out of the box WinForms DG, which is just too tied into the DataSet model and doesn't work very well with custom business objects and typed collections.

It does take some time to pick it up, but the MVC design of the library makes the code very clean and extremely flexible.

The Source Pack also comes with a variety of other controls for WinForms development.  Definitely worth a look for any WinForms developers looking for more flexibility in grids.

DHTML Edition.

Came across an awesome listing of DHTML resources today via weblogs.asp.net.

Just a short snippet:

• 3 Column Holy Grail.  For good reason, clean, search engine optimized CSS layouts have been hot in the web design space for quite a while.  I really got into it when I was working at Factiva.  Up until that point, I didn't even know that such techniques existed.  Well it seems like someone has finally pulled it all together into one super clear layout.  I marvel in the simplicity...
• Qooxdoo.  Wow.  I am blown away by what's capable with this library.  Definitely worth a look, particularly the windowing capabilities.  The last two web based projects I've built have used custom windowing libraries which are definitely not as well developed as these libraries are.  Now I'm salivating to build something cool with it
• dp.SyntaxHighlighter.  I've actually been thinking of writing just this!  Amazing stuff, really.  At the moment, I'm mostly using an external tool to colorize my code and pasting it as HTML...this looks like a much better solution.
• DOM-Drag.  Looks good.  Last DHTML front end project I was on, I spent way too much time making drag-drop work.  However, the performance does seem a tiny bit laggy on some of the demos.
• Nifty Corners.  Looks interesting...people seem to like the rounded corners look...I've always been too damn lazy to make rounded corners
• moo.fx.  This library looks great...very performant and easy to use.
• script.aculo.us.  A more heavyweight and full featured effects library.
• Behavior.  I'm really digging this one...check out how clean the demo pages are.  Very nice.
  

And there's also a boatload of AJAX libraries listed as well...way too many, I'd say.

But I digress.  Some of these libraries just make me giddy.  But I'm weird like that.

Just one entry for today.

I was looking around for a free XPath expression tester online.  Surprisingly, it took me at least 20 minutes to find a free one.  Altova XMLSpy Home Edition, while free, does not include an XPath evaluator (it's an add-on in the professional edition).

However, I did find Dimitre Novatchev's excellent (though ugly as hell) XPath Visualizer.

Great tool (although the UI is ugly)!  And you just can't argue with free

From time to time, as I'm working on projects, I invariably come across great sets of tools that make my life just a bit easier.  My plan is to list the tools, test them out, and rate them somehow after I get some usage.  I guess this is my way of sharing with the world

So for the inaugural entry, we have two tools and one library:

• FaceID Browser.  When creating custom add-ins for Office applications, you can create a command bar button (CommandBarButton) and apply an existing Office icon using the FaceID property.  This tool allows you to visually map the integer values to the icons.  I've tested it to work with Office 2003.
  
• Xsd Generator with GAT.  For some reason or another, I like the idea of working with XML schemas when building an object model; schemas seem much more natural to me than working with classes in code.  In addition, you get nice XML serialization markup for free Matias Woloski has written a custom generator for .Net 2.0.  I'm gonna give it a look-see. [Update:1] The binaries that are currently on the GDN website are not compatible with the RTM versions of VS2005. [Update:2] Holy crap.  After several hours of fiddling, I finally got it to install.  Damn, the December CTP of GAT extensions is still buggy as hell.  For some reason or another, uninstalling the Xsd Generator after installing it would also remove all traces of the Microsoft.Practices.RecipeFramework dlls. WTF? So this would necessitate reinstalling the GAT extensions.  On top of that, the December CTP changed the default namespace on the configuration file from http://schemas.microsoft.com/pag/ipg-core to http://schemas.microsoft.com/pag/gax-core took me at least a half an hour of digging to find this info.  The other really stupid thing is that you can't change the config file after install without reinstalling...another big WTF; I mean, isn't that the whole point of having an XML config file?  I also had to rebuild the references in two of the projects and add a missing reference to Microsoft.RecipeFramework.Common.Library.  But in the end, it's worth the effort!  I dig the fact that it generates generic lists instead of typed collections (typed collections are soo last gen. ).
  
• Microsoft Updater Application Block.  Looks useful for anyone currently building lots of application add-ins for any of the Office applications as it will allow you to keep clients up-to-date without having to redeploy with each update.  There's an article over at TheServerSide.Net on usage and details.
  

That's it for now.  Look for more installments in the future.