Confessions of a Developer Tool Hound

As anyone who knows me is well-aware, I am a confirmed tool-addict.  If there is a utility, framework, add-in, add-on, or plug-in I want to have read about it, tried it, evaluated it, and decided for myself whether its worth keeping in my developer’s tool belt.  As a professional software developer, I’m unashamedly  and unrepentantly lazy:if there is a tool I can use that saves me time, effort, and energy then I want to be using it.

Visual Studio Professional is certainly the gold-standard of IDEs today as well it should be (at least for .NET development) but let’s face it: Visual Studio 2008 offers what is significantly the same developer experience as Visual Studio .NET (2002) provided.  Sure, there are a  bunch more features, the graphics now sport more curves and gentler lines smile_thinking, the debugger is certainly much-improved and (is this good?) there is now an integrated designer for Windows Workflow — but fundamentally there has been an evolutionary rather than revolutionary set of changes made to the primary developer toolset offered to .NET developers over time.

Of course, if you’re like me and consider the introduction of the Office 2007 ribbon UI to be an abominable layer of indirection further separating me from the tools I need to apply formatting to my MS Word document quickly (why, oh why does printing the current document take 5+ clicks now?…and how is that progress??), then perhaps the consistency of the overall Visual Studio development experience is actually a positive rather than a hindrance.  For example, just try to imagine what the debugger ribbon would look like and how hard that could have been to use productively if the ribbon UI metaphor had found its way into Visual Studio 2008! smile_embaressed

So the bottom line is, if you want revolutionary change in your development experience in .NET, you’re going to have to look outside the Redmond-shaped box.  Fortunately, to give Microsoft credit where its due, Visual Studio is quite extensible (though hard in earlier versions, its gotten much easier in later versions) and they have done an effective job spawning and shepherding the creation of a pretty comprehensive ecosystem of third-party Visual Studio add-ins including many commercial and many open source.

With the (heartening) wide-spread interest in the Summer of NHibernate screencast series that I have been making available, there has been some interest expressed in understanding more about some of the tools that are being used in my IDE in the series.  In response, this post is a catalog of those tools (both OSS and commercial, and in no particular order) upon which I presently depend to get my work done and some reasons why I chose them over other options that may provide similar capabilities.

Since I don’t want to get into fights with people about what’s "open source", what’s "commercial", what’s "non-commercial", etc. I have identified each tool by the only thing that truly matters in all this: "no fee" or "payment required" smile_wink

Source Code Outliner

Source Code Outliner (no fee)

First up is the Source Code Outliner Powertoy on CodePlex and provided by Microsoft.  Like the built-in Visual Studio "Class View" window without most of the overhead (Class View Lite?) and only displaying what’s in your currently-active file in the editor, The Source Code Outliner offers the same kind of experience the "Document Outline" window provides for HTML, the WinForms editor, and other types of documents.

Why Microsoft didn’t just fold the Source Code Outliner’s capability into the "Document Outline" window to make that window work when a source code file was active is beyond me.  Instead, the "Document Outline" window just goes blank when you’re in a source code file and you have to resort to this little add-in to get something to look at that’s less-visually busy than Class View.

Light-weight, quick, and painless, makes me never have to look @ Class View (for just navigation) again.

New DXCore Project

DXCore Visual Studio API Abstraction Framework (no fee)

When the great team at Developer Express created CodeRush and RefactorPro! (see later listings for each) they realized (correctly) that the VS API was a god-awful mess to navigate and develop against.  To make their own work on their own products more of a RAD experience for their own staff than the hack-and-slash typically needed to wrestle with the VS API, they developed an abstraction library atop the VS API and named it DXCore.

To foster a larger community of add-ins for Visual Studio, they released this library of utilities to the community at-large and invited people to build DXCore-based add-ins for Visual Studio (of which there are many available on the Internet at-large and several are in this same tool list here).

Even though Microsoft has made great strides in making the process of developing against the VS API much simpler than it used to be, there is still tremendous value in the DXCore library as it makes it trivially simple to build a VS add-in…in fact, when you install it into VS, it actually adds a New Project template for a DXCore project that makes even getting started building your own a dirt-simple process (see figure @ left).

If you want to get a jump-start on producing your own DXCore plug-in, a great primer is the DotNetRocks TV episode from a while ago called
Mark Miller works the DXCore (epispode 5, if you can believe it from way back in 2006).

CR_ClassCleaner Configuration

CR_ClassCleaner DXCore Plug-In (no fee, DXCore required)

If you’re like me and you like to both have your class source code well-organized and at the same time are annoyed at having to remember to scroll back up to the top of your class just to define a new field in the ‘right’ place, then the DXCore CR_ClassCleaner plug-in is for you.

ClassCleaner allows you to add code to your class (methods, fields, properties, enums, constants, whatever) and have ClassCleaner properly reorganize your class for you with a single keystroke (the keybinding of which you control when you configure it).  This gives you the freedom to just add a new method, etc. anywhere in your class and have ClassCleaner properly relocate it within the class’ source file when you invoke it — no more jumping around in your source file before you add a method or a field to ensure adherence to some (arbitrary!) code-organization standard (preference smile_teeth).

ClassCleaner provides a completely configurable order of the elements that you want it to relocate in your class source file, offers options to either ‘organize-with-regions’ if you’re like me and prefer #region tags in your files or ‘organize-without-regions’ if you think that code-folding is evil.  So that your whole team can use the same ClassCleaner settings, ClassCleaner supports importing and exporting its settings so that all of your team’s classes can be organized the same way (and so that running ClassCleaner on existing code doesn’t cause all kinds of trouble when you DIFF your code against your buddy’s before merging/committing it smile_omg). 

A note (WARNING) about ClassCleaner:

Even though the download page says it has been ‘updated for DXCore 2.5.1’ (which is quite outdated) it works fine under the 3.0.x DXCore release required for VS 2008.  However, to get this to work you must download the CR_ClassCleaner source code rather than the compiled binaries, remove the references in the project to the outdated DXCore 2.5.x libraries, add references to the newer 3.0.x DXCore libraries (available on your computer after you install DXCore 3.0.x), and then recompile the plug-in against the 3.0.x DXCore libraries.  After all that, CR_ClassCleaner works wonderfully against DXCore 3.0.x in both VS 2005 and VS 2008.  I have absolutely no idea why the author hasn’t bothered to recompile the thing against a newer DXCore version, but since the source is available, you can follow this process to easily do it yourself.


CodeRush and Refactor! Pro (payment required)

Mentioned earlier and featured pretty prominently in the screencasts are a pair of tools without which I really feel I would be doing software development with one hand tied behind my back: CodeRush and Refactor! Pro by Developer Express.

CodeRush is a hyper-powerful and intensely flexible code templating engine that is perhaps best described as ‘code snippets on steroids’.  Offering templates and keybindings to do eveything from stubbing out a new unit test method to wrapping an entire code block in a try-catch-finally construct with the press of just a single key, CodeRush is a completely new way to author code that is a godsend to anyone who is as inaccurate a typist as myself smile_embaressed.  And if you are somebody who routinely switches back and forth between projects in C# and projects in VB.NET, CodeRush is almost a necessity since the same keystrokes work in BOTH languages allowing you to become familiar with just the keystrokes and let CodeRush abstract away the language differences (people like me who do this often are fond of saying "I don’t code in VB.NET or C# — I code in CodeRush!".

CodeRush also offers a huge range of much less-hyped features including built-in (and completely customizable) code metrics including CC, SLOC, and others as well as a tremendously more-powerful replacement for code navigation from search results (including a ‘semantic search’ that finds matches not based on text (e.g., variable names) but instead based on actual variable instances that has to be seen to be believed).

Even though the hot refactoring tool du-jour mentioned in all the posts these days seems to be JetBrains Resharper, I personally feel that Refactor Pro! is at least as good in most areas and a lot better in many others.  Where Resharper insists on showing me a hyper-annoying 1990’s style dialog-box every time it wants me to interact with it, Refactor Pro! has its UI completely integrated into the actual code editor window itself, offering me a visual preview of the effects of the refactoring that I’m about to apply to my code.  This provides a completely different style of interacting with the tool than the step-1, step-2, step-3 wizard approach of something like Resharper…and Resharper cannot even begin to touch the CodeRush functionality at all.  Even though Resharper has a relatively weak templating engine, its nowhere near as powerful or flexible as what CodeRush provides.

Admittedly some of this is personal preference, but the combination of CodeRush and Refactor Pro! is pretty much unbeatable for the US$250 they are asking for the pair when Resharper wants that for what is basically only a refactoring tool.

Developer Express offers trial downloads (CodeRush, Refactor! Pro) that usually last about 30-45 days which is plenty long enough for you to get hooked smile_embaressed.  At the time of this writing, it looks like the present eval versioons expire September 1, 2008 (which is about the official end of summer).

Some points:
Use the CodeRush dynamic interactive keystroke ‘coaching’ window — its worth its weight in gold when learning the product.  Also, ensure you check out some (or all!) of
the training videos Developer Express offers as they provide some really good overviews of the products too (though some of them are demo-ing older iterations of the products, they are still valuable as a learning tool).


GhostDoc Automated XML Comment-Authoring (no fee)

If you always wanted to write XML code comments (for use in post-compile code-documenting authoring) but could never bring yourself to take the time to actually write them (or maintain them!), then GhostDoc is for you.

With a right-click and select of ‘Document this’, GhostDoc will reverse-engineer an entire collection of syntactically-correct XML code comments for you (which you can then refine if you are dissatisfied with the results of the tool).

You will be pleasantly surprised by how often GhostDoc is perfectly able to deduce the right comments to add from nothing but the method name and its signature — for example, its more than capable of determining that a method called GetCustomerById(…) should have the comment "Gets the Customer By Id" added as a comment.


CR_Documentor DXCore Plug-In (no fee, DXCore required)

After using GhostDoc to create your XML code comments and then refining them a bit by hand, you might want to know what they are going to look like when eventually compiled to HELP content.  Before CR_Documentor, your only choice would be to actually build your app, fire up SandCastle, compile your help content, open it up, navigate to the topic, and take a look.

But with the CR_Documentor plug-in for DXCore, you can preview your XML code comments immediately right from within the VS IDE without any of those steps required.  Recently updated for VS 2008 and moved to Google Code, this plug-in is a must-have for anyone serious about maintaining the XML code comments in their codebase.


DocProject SandCastle Help File Processor (no fee)

If you have ever tried to wrap your head around the 150 or so parameters and 80-90 steps required to use SandCastle to convert your extracted XML code comments into a usable HELP repository, then you should stop all that craziness right now and go download DocProject for SandCastle immediately.

Although a brief glance at the DocProject site might lead you to believe that its own documentation is worse than that of SandCasltle itself smile_sad, don’t despair — the site and related documentation is more complex than it needs to be because there are just so damned many choices this thing offers!

if all you want to do is compile your XML code comments into the default DocProject website output, a simple compiled HTML help file (.chm) or another of the more common output formats, just download it, install it, and create a DocProject project in your VS solution and hit F6 (that’s BUILD in case you changed your default VS key mappings smile_teeth ) — this thing (despite its apparent complexity) just works — and well.  Trust me.


TestDriven.NET Unit Test Runner (payment required)

After all this time still one of the best VS unit test runners on the planet, TestDriven.NET can probably be credited with being one of the primary reasons that Unit Testing has managed the penetration into the .NET developer world that it has.

Its hard to remember back this far with all the VS-integrated unit test runners out there today — even Microsoft’s own integrated runner in VS2008 — but before there was TestDriven.NET, running a unit test meant launching a separate unit test runner outside Visual Studio, loading your compiled assemblies into it, and clicking ‘run tests’.  Running tests again meant doing all that again…and god help you try to attach the VS debugger to the test-run process to troubleshoot a failing test!

TestDriven.NET’s ability to reduce (if not eliminate!) most of the friction that used to be involved in running unit tests with any frequency at all has been often mimicked, copied, duplicated, and imitated but the good old stand-by still remains as a glorious example of a neat little tool that does one thing and still does it tremendously well.


MbUnit Unit Test Framework (no fee)

Originally started by a developer who now works for Microsoft on the PEX project, MbUnit (originally ‘Much Better Unit" — no, I’m not kidding about that) is essentially everything you have come to know and love about NUnit with a bunch more stuff to make the harder stuff easier.

While MbUnit 3.0 is in alpha right now, the 2.4.x latest RTM release is dead-stable and highly reliable for use in production projects (I have a firm non-beta policy about anything that I use in my real-world work and this obviously precludes using any alpha software either smile_zipit ).  MbUnit 3.0 looks like it will be an awesome toolset and I look forward to its release, but I’m going to stay right where I am with 2.4 until 3.0 is ready for me.


Rhino Mocks Mock Object Framework (no fee)

A product of what I consider to be one of the most prolific .NET developers on earth (when does Oren actually sleep?), Rhino Mocks is one of the most useful mocking frameworks I have come across and I consider it essential to being able to effectively unit test anything but the most trivial of software development projects.

If you’re serious about unit testing, the you need a mocking framework and if your serious about your mocking framework then you need Rhino Mocks.

I hope this post helps provide some insight into both what my tools choices are and why I selected them.

Happy coding~!