Disclaimer: A long time ago, in a galaxy far away, I helped coordinate the Indy Code Camp. We gave away a few donated copies of NDepend as prizes, and while setting that up, Patrick Smacchia offered me a license if I’d be willing to write about my NDepend experiences on my blog. Having heard about NDepend in the past, I happily took him up on it – making sure it was clear that I would write about my experience regardless of whether they were positive or negative. So this is a “sponsored” post, in that I received an NDepend license, but the license donation did not purchase any of the content of this post.

An astute reader will probably look at the date that I helped with the Indy Code Camp and compare it to the date of this post, and figure out that it was about two years ago that Patrick asked me to evaluate NDepend. And I’m not so happy to say that in those two years, I really didn’t use it. But recently I have more time available to me for doing specifically this sort of thing.

I think Scott Hanselman summed up the initial NDepend experience quite well.

Like PowerShell, the first 10 minutes of NDepend is the hardest. It has to click first. There’s the whole "what the hell am I looking at" process, often followed by the "screw this" declaration, followed by a quick uninstallation and a sense of "what happened."

I’m not going to do a comprehensive overview like Scott or others have done – at this point I just can’t do that as I’m still in kind of the “what the hell is this” phase. But it’s slowly beginning to click. For me, two things that click and help me continue on and work to understand this application.

One, I know I need the information NDepend can give me. I may not understand it all immediately, but I’ve been deep in the code of some applications long enough to see (and write) the good, the bad, and the ugly. I need ways to root out the bad and ugly, without having to dive into all the code in-depth. I also need metrics to help show that the good really is good. Especially when you’re working on a team of several people, each with varying opinions and each who writes their own flavor of code. Just because I don’t like someone else’s code doesn’t mean it’s bad code. Metrics can help me separate my aesthetic or organizational concerns from real problems or smells. And then I can make them write it my way anyway.

Two, and more fun than the first is NDepend’s Code Query Language or CQL. In my opinion, this is an easy “hook” to get someone to look closer at NDepend and get past that 10-minute hump. I have seen a developer’s face literally light up when they hear what CQL can do, especially if they’ve done any work with a database and SQL in the past.

NDepend’s website has the best documentation of CQL, even if the docs feel overwhelming at first. There’s also some information about embedding CQL into your code as in-line constraints that NDepend can enforce during your build, though as others have mentioned it’s not a practical solution.

Of immediate interest to me, due to something I’m doing at work, is catching breaking API changes that might accidentally happen during a maintenance release. Patrick covers how to do this here. But as an example, let’s analyze the breaking API changes in StructureMap between version 2.5.4 and 2.6.1.

Note: I got confused at first, because I put both versions of StructureMap into the same directory and renamed the files to include the version number. NDepend didn’t like this and flagged every single method as removed and added. I’m not sure what I did wrong, but it took a bit to figure out, and it sucks for situations where a version number (or a name change) might cause an assembly name not to match, even though it’s functionally the same.

The first thing to do is select the two assemblies to compare – here I’m choosing StructureMap 2.5.4 on the left, and 2.6.1 on the right.

After the NDepend project has been created, I can press ALT+Q to bring up the CQL editor, and enter the following query:

WARN IF Count > 0 IN SELECT METHODS WHERE
IsInOlderBuild AND IsPublic AND (VisibilityWasChanged OR WasRemoved)

It reads pretty well, especially if you’re familiar with SQL. Literally it’s “warn me if methods exist that were in the older build, were public, and the visibility has changed or the method was removed.”

You can see below, 5 methods were “removed” from StructureMap’s public API – in this case, they are literally removed (and not just made internal or private). That means that upgrading from 2.5.4 to 2.6.1 could mean you have to change or recompile your code.

Likewise you can see that no public types were removed, thus no breaking change exists and the CQL query isn’t flagged as a warning.

This is some powerful stuff, and as I begin to incorporate it more and more into my daily workflow I’ll post about how I’m using it.

The newest version supports a console runner, a stand-alone GUI, and full integration into Visual Studio 2005, 2008, and 2010. For small projects that can exist within a single Visual Studio solution, it’s perfect. For larger projects that span multiple solutions, NDepend still allows you to analyze a set of assemblies, the UI is just embedded inside Visual Studio – and the integration is pretty usable for me so far.

Like Tim, I’ve been using S3 to host my images for the blog, and I wholeheartedly agree with him – the workflow for writing a post sucked big time. This plug-in had been on my //TODO list for a long while now. Somehow I mentioned that fact to Tim on Twitter and he sent me a link to a screenshot of his initial version. My response? Sign me up!

He uploaded his source to CodePlex and I immediately started implementing the remaining features. The result is the 0.9 beta release of the S3 Browser Windows Live Writer plug-in. Give it a download and try it out! Please submit any feature ideas or bugs on the codeplex site, or you can leave a comment here as well.

Lately I’ve been delving into the ASP.NET MVC framework, the timing of which has been interesting as I am about to finish reading RESTful Web Services by Leonard Richardson and Sam Ruby. It’s an excellent book that I’d highly recommend to anybody designing and creating services for the web, or just interested in it.

This quote from the book description on Amazon.com succinctly describes what’s been floating around in my head for a while:

You’ve built web sites that can be used by humans. But can you also build web sites that are usable by machines? That’s where the future lies, and that’s what RESTful Web Services shows you how to do.
[Emphasis mine]

Why do we have to build web "sites" for humans and different web services for machines? I can create an ASP.NET site, a SOAP-based ASMX web service, or a SOAP or REST (with .NET 3.5) WCF service and while they can share business logic, there’s still a lot of "endpoint code" (for lack of a better term) that has to be implemented, and if I want a human friendly front end + a web API, I have to build a site that essentially wraps another service, since the site itself really is a service.

With the ASP.NET MVC Framework, though, I see the opportunity to unify services and "sites" (human-readable services). Imagine visiting http://www.example.com/books/ and being able to receive back HTML, POX, or JSON, depending on what you asked for–with no additional code required outside of following a convention or two. Web browsers ask for HTML, returning a human consumable page that gets rendered. AJAX or custom clients can request JSON or XML, whatever they know how to interpret best.

The separation of concerns and extensibility that the ASP.NET MVC framework exposes lets us accomplish this with surprisingly little code. At least for read-only services (which is as far as I took it for now.) If you’re not familiar with how the ASP.NET MVC framework works, check out Eilon’s excellent ASP.NET MVC design philosophy post (he also includes many good reference links).

Approach

Outside of the ASP.NET MVC framework itself, from an HTTP perspective I simply want to alter my response format depending on what the incoming request asked for. I decided to keep it simple and only support the "text/html", "application/xml", and "application/json" media types.

I started off trying to use the "Accept" HTTP header as an indicator for what response format the client preferred. After all, that’s what the Accept header is for: "The Accept request-header field can be used to specify certain media types which are acceptable for the response." But I quickly ran into a snafu when I found that Firefox prefers XML over HTML.

That means that every request Firefox makes would result in the uber-friendly XML view.

And because of that snafu, I read up some more on the Accept header – namely what they had to say about it in an appendix of RESTful Web Services:

Hiding this information inside the HTTP headers is a good idea for web browsers, but it shouldn’t be the only solution for web service clients. I recommend exposing different representations using different URIs. … If you want to support Accept on top of this, that’s great (Rails does this too).

There was also some pragmatic advice in the chapter on Representations.

It’s RESTful to keep this information [file format types] in the HTTP headers, and it’s RESTful to put it in the URI. I recommend keeping as much of this information as possible in the URI, and as little as possible in request metadata. I think URIs are more useful than metadata. URIs get passed around from person to person, and from program to program. The request metadata almost always gets lost in translation.

I tend to agree with that. To make it easy and somewhat intuitive, I chose to base the response format on the existence of a querystring parameter named "format". It can specify "xml" or "json", for example http://www.example.com/books/?format=json. But really, you can use any method you want to allow format specification.

Implementation

Formatting the response is the responsibility of the View in the MVC architecture. Since processing requests for HTML content didn’t need to change from the default ASP.NET MVC behavior, all I need to do is override the default WebFormViewFactory functionality and return my own "SerializedView" if the URI indicated xml or json formatting. SerializedView is an abstract base class that encapsulates common functionality and allows sub-classes to perform the serialization, or handle custom error reporting.

When a Controller passes control to a View, it calls the "RenderView" method on the Controller base class, passing in the view name and some optional data – including something called "ViewData" – an object that represents the content the view should render.

Here’s the best part: creating an ASP.NET MVC site+service using my approach means passing a serializable object as ViewData. It’s as simple as that, nothing else needs to change (ok, you need one additional line of code in your Application_Start handler – more on that later). In your ASPX view, you can access the object via ViewData and use all the HTML helpers, UserControls, etc. that you want to build out your HTML, javascript, and who-knows-what.

Unfortunately, the current CTP of the ASP.NET MVC framework does not expose a way to "inject" a different IViewFactory (my subclassed version) into the default Controller created by the ControllerBuilder class. So, that means implementing the IControllerFactory interface and duplicating (ouch!) the code that ControllerBuilder executes, with one somewhat nasty addition.

Yuck! The ViewFactory property is specific to the Controller class, not the IController interface, hence the specific processing — and that also means my approach won’t work for other IController implementations. Not without some extra work, anyway.

This is where the only change you need to make comes in. My IControllerFact
ory implementation needs to be registered as the default controller factory, which is done in the Application_Start handler – the same place your routes are configured.

Serializable Types

For various reasons, you should use the WCF [DataContract] and [DataMember] attributes to tag your objects as serializable. For one, you gain all the serialization benefits these attributes offer, plus you can use the same contract types across multiple endpoints if you need to. And for another, serializing to JSON via the System.Runtime.Serialization.Json.DataContractJsonSerializer requires the DataContract attribute. If you use the older [Serializable] attribute, you get some interesting results.

The deprecated System.Web.Script.Serialization.JavaScriptSerializer works correctly for objects tagged with [Serializable] but it’s, well, deprecated.

Example

Using the default ASP.NET MVC Application templates, I registered the default ControllerFactory in my Application_Start handler, defined a Books controller with a default action, and a "List" view that prints out some Author and Title information. I also created the following definition of a book.

My controller implementation is no different than it normally would be. I get a list of books and render the "List" view, explicitly specifying the book list as the ViewData. You might notice that I pass the ControllerContext into the GetBooks method. I am experimenting with returning URIs to related resources as part of the data. I’m still playing around, but for now you get my latest attempt.

Requesting the appropriate URI in Firefox yields the expected result from my List view:

And altering the URI returns the appropriate response types, xml or json.

Summary

This ended up being a longer post than I intended, but I hope it was worth it. I’ve put the full source for the "MvcServiceLibrary" and an example up on my Tools page – but here’s the direct download link. I’ll also be checking if this is worth putting into the MvcContrib open source project.

I think that the ASP.NET MVC framework is a huge step forward in creating RESTful web sites, and hopefully now also RESTful web services! Let me know what you think, I love getting feedback.

I found myself wanting to add a “kick it” counter on some of my posts to enable people to easily kick them (via their blog reader, for example), but not on every post. I mean, who wants to kick a post about contacting me? Not even I do!

Here would be the process with what I’ve currently got:

1. Write a kick-worthy post.
2. Publish the post.
3. Get the permalink for the post in question.
4. Submit the post on DotNetKicks.com, and copy the HTML for the “kick it” counter.
5. Add the HTML to my just-posted post, and re-publish the updated version.

Way too manual. So after a little research and a little coding today, here’s my new process:

1. Write a kick-worthy post.
2. Click from Windows Live Writer.
3. Publish.

The Problem

It’s simple, really: adding the “kick it” counter requires knowing the permalink of a particular post. That prevents me from inserting it for real at creation time, because the permalink isn’t known until the post is published. I could just add the “kick it” code to my wordpress template, but as I originally mentioned, I don’t want it on every post – just some. (Yes, I realize I’m overcomplicating things – it’s my blog though. )

The Solution

Unfortunately any solution, including mine, will require some cooperation between Windows Live Writer and the blogging platform. Mine includes a Windows Live Writer plugin and a WordPress plugin. The Windows Live Writer plugin adds a placeholder (“<!–dotnetkickit–>”) to the post, and the WordPress plugin transforms the placeholder into the “kick it” image/link HTML at render time.

Windows Live Writer Plugin

The Windows Live Writer plugin adds an “Insert Kick It Counter…” link in the list of “insertable items.

Click it and, like any other inserted item, a default “kick it” image is added.

This image is static, and is just for layout purposes only – Windows Live Writer allows plugins to insert different “editor” versus “published” HTML. When editing, I insert a static image so you can get the look-and-feel, and when published, only the “<!–dotnetkickit–>” placeholder gets inserted. Pretty nice on the part of Windows Live Writer to expose that functionality.

When you select the image, you’ll see the “Kick It Counter” properties on the right, of which there are none:

That’s really all there is to the plugin, it’s pretty basic. It doesn’t (currently) allow you to change any of the colors, but that’s something you could manually update in the WordPress plugin itself, if you want.

To install the plugin, download and run the MSI available on my garage sale code page listed under “DotNetKicks Windows Live Writer Plugin”.

WordPress Plugin

The WordPress plugin is beyond simple, partly thanks to the extensibility support the WordPress developers have built in. The plugin adds a filter that modifies the post content before it gets displayed in the browser. Note that I don’t actually modify the stored post content itself – I want to be able to turn this off and have the “kick it” counters go away.

To install, download and unzip the dotnetkicks.php file from my garage sale code page (listed under “DotNetKicks WordPress Plugin”). Just upload it to your wp-content\plugins subfolder, and activate it from your admin page:

After activating, you’ll see the “kick it” image on the appropriate posts.

If anybody wants to create plugins or whatever for other blogging platforms that will interpret this placeholder, post a comment here with a link to your implementation!

Finally

The moment we’ve all been waiting for – I’m going to make use of the barely useful tools I created! Feel free to kick this post.

It’s easy to upload your builds to the symbol server using the command line. You execute a command like:

symstore add /r /f d:\builds\*.* /s \\symbol\ProductSymbols /t "Product Name" /v "Version string" /c "Comment"

(For full usage information run “symstore” with no arguments.)

The not-so-easy part of this process comes when managing previously uploaded versions of your symbols. John Robbins suggested (and who am I to resist a challenge) that it would be great if somebody wrote a tool with some sort of UI that allowed users to select previous “transactions” and delete them. The only way to do that right now is by manually scanning the “history.txt” file located on the server’s share (in an “000admin” subdirectory) and pulling out the transaction id to delete by using in a “symstore del” command.

Way, way too manual.

So, dear reader, I give you my response to John’s challenge: Symbol Server Transaction Manager!

UPDATE 1/4/2008: I’ve done a huge overhaul of the app, and released it as open source on CodePlex as the PSSymbolStore project. Download the latest release there.

It makes the process much easier, I hope. Simply start the app, and press CTRL+O to open a symbol store. Note that in all my examples I’m using a local symbol store, “C:\symbols” — but in most cases you’ll be specifying a network path such as “\\symbols\ProductSymbols”.

Once you’ve opened a symbol store, you’ll see a list of existing transactions. Any transactions that have previously been deleted will not be shown. You can sort by any of the columns to help find the transactions you are looking for, such as all transactions older than 2 weeks.

At this point, it’s as easy as highlighting the transactions you want and pressing “Delete”. Or you can right-click one or more items and use the context menu. If you haven’t refreshed your view (I didn’t code it to auto-refresh because of how long the operation might take), and try to re-delete a transaction, you’ll see an error message in red. In fact, any error will be shown in red. If you come across an error condition that shows up in blue (which indicates success), let me know.

Here’s an example of successfully deleting two transactions:

And here’s an example of trying to immediately re-delete those same transactions (bad):

You can press the “Refresh” button to update the view to match the server:

That’s about it, pretty simple stuff, eh? There is one thing worthy of a special note. Because deleting transactions can be a fairly long-running operation, you can cancel it. The “Delete” button changes to “Cancel” if an operation is running. If you click “Cancel”, it will kill the currently executing instance of SYMSTORE, orphaning any remaining files in the transaction, and it won’t process any more transactions, if you had selected more than one. That’s just something to be aware of. Eventually maybe I’ll be smarter about cleaning up the files, but for now, cancel at your own risk.

I welcome any feedback, if you find this tool useful, let me know! I’m happy to add any enhancements you can think of, too.

If you read Scott’s blog via Google Reader, like I do, you’ll notice his feed is broken. In his recent Hanselminutes podcast he talks about his list, and how it broke Feedburner last year due to the size of his feed. Apparently Feedburner handles it now (you can see that his feed is up to date if you view the raw feed) but no matter what you do, Google Reader won’t show any updates to it. So check it out on his site.

With me having nothing but good things to say, you’re probably wondering why I’m asking if he’s Jumped the Shark? I’ll tell you why: somehow this year I ended up on his list. (More specifically, my garage sale code page.) Now, I have nothing but respect for Mr. Hanselman, but when I saw my name on the list I had to step back and seriously question his sanity… and the only thing I can come up with is that he’s losing his mind. Did you know he recently just up and quit his job? Yep, it’s true! Does a sane person quit a job they enjoy? No, they don’t. He’s also “taking a month off” between jobs… can you say “mental institution” or “rehab”? I can!

I rest my case.

Okay, I’m obviously joking, I actually consider it quite an honor to be on that list. Cheers, Scott, keep up the great work!

It claims to support practically any version of Windows (from 95 to XP, and I’m personally running it on Vista), as well as Mac OS X 10.2+ and *nix (primarily tested on Linux).

When I posted about my office setup, I included a picture of my 3 monitor setup, plus my MacBook Pro. Thanks to Synergy, I essentially have four monitors. Moving my mouse off the left edge of my Windows desktop instantly transfers it to the right edge of my Mac’s desktop, along with my keyboard focus and clipboard. It only supports plain-text clipboard contents for Windows <-> Mac, but 9 times out of 10 that’s sufficient. (Submit a patch with the fix, if you feel brave!)

One thing is that configuring Synergy sucks. On the Mac (and *nix) you have to know how to edit a .conf text file. In Windows, it’s hardly better. You have to reference your computers by hostname, which causes me grief when I connect my Mac via VPN and sometimes get an arbitrary hostname assigned to me. Also, in Vista, you must always run the application as an administrator, or else no dice.

Here’s a handy guide to configuring Synergy 1.3.1–focused on my particular setup, and assuming you keep most of the defaults. We won’t get too “fancy” here. If you want more advanced information, check out the links under the Documentation section on the SourceForge page.

Windows (Running Synergy as a server)

Start Synergy, and select “Share this computer’s keyboard and mouse (server)”, then click “Configure”

The first step is to define your “screens”. A screen is really just “a computer”. In my case, a single PC has 3 monitors – that’s one “screen”. Click the super-fancy-awesome plus sign button (“+”) under the “Screens:” list box to add a new screen. Synergy recommends you use the computer name as the screen name, unless you’ve got a good reason not to, I agree with them–but for the server setup it doesn’t really matter. As far as I can tell, though, it’s purely cosmetic since you can use the “aliases” to map hostnames to a friendly name. Enter the screen name (your computer’s hostname) and optionally any aliases. It’s important to reiterate that both “screen name” and “aliases” are used to identify remote computers via the incoming/outgoing network connection.

I left all the other options as default (just to get something going). But essentially you can control which modifier keys are also sent over the network (or not), as well as “dead zones” on the screen that shouldn’t swap the mouse out.

Each computer needs to know about every other computer, so you’ll have to add a new “screen” for every box you want to hook up. Go ahead and do that, I’ll wait. Ready? Wishing they had some sort of “auto-discovery”? Me too. The next step is to “link up” your screens. You basically have to tell Synergy how they are positioned/connected. In my case, my laptop is directly to the left (and a little below) my main PC “screen” (remember, all 3 count as one to Synergy–it’s about “desktops” really).

Click “[New Link]” in the “Links” listbox and enter your information (explained in a sec) — then click the “+” button (genius!) to add it. Wash, rinse, and repeat until you’ve got it all set up.

The reason this is so complex is that you can configure portions of screens that link to portions of other screens. In the above example, I’m configuring the entire left side of my work PC (0-100%) to map to the entire edge of my Mac (0-100%) — on the Mac I configure which edge (left/right/etc) lines up with my work PC. Why would I want anything different? Consider the following extreme configuration:

In this “screen” layout, I would map:

• 0-50% of the left of Screen 3 to 0-100% of Screen 1
• 50-100% of the left of Screen 3 to 0-100% of Screen 2
• 0-100% of the bottom of Screen 2 to 0-60% of Screen 4
• etc.

Make sense? I hope so, because it’s a real pain to configure. And each “screen” has to be configured to match — so on Screen 1′s configuration, 0-100% of the left side goes to 0-50% of Screen 3. So much can be done here in terms of auto-config, it’s not even funny.

The good news is that you’re basically done. You can test your configuration by clicking “Test” in the main dialog, which simply starts the server allowing you to cancel it. I recommend using the “Test” mode until you’ve got it all set up, because otherwise it runs in the background and there’s no way to change the configuration without restarting the application. (Fun.) You can also configure some advanced options (like network port numbers, and auto-start options).

Mac (Running Synergy as a client)

This is the fun part. The UI on Windows at least abstracts out the configuration file describing the screens–no such luck on a Mac. And on a Mac, of all places! Synergy on the Mac includes a sample .conf file, which really helps. Here’s an example .conf file – it gets more advanced than this, but for basic stuff you don’t need anything more. Notice that I’m not specifying any percentages because they’re all 0-100%. If you want to get more complicated, I recommend reading the documentation.

section: screens
LERCHWORKPC:
maclerch.local:
end

section: links
# lerchworkpc is to the right of maclerch.local
maclerch.local:
right = LERCHWORKPC
LERCHWORKPC:
left = maclerch.local
end

Basically I’m identifying all the screens involved: LERCHWORKPC and maclerch.local. Then I’m associating them: to the right of maclerch.local is LERCHWORKPC, and to the left of LERCHWORKPC is maclerch.local. Nuff said.

To run Synergy in client mode, bring up Terminal (the Mac’s saving grace: a command-prompt), and drag-and-drop “synergyc” from the install location (by install I mean “where you unpackaged the files”) onto Terminal. Add “-f” and the name of the computer running the Synergy server, and press Return.

Drag “synergyc” from here… (assuming you installed it here)

… to here. So your command looks something like this:

The -f option tells Synergy not to run as a daemon. I prefer it because I can minimize Terminal and forget about it – but bring it back up to view the output or kill the app with CTRL+C easily if I want to. You can leave off “-f” to run it as a daemon and stop the process later, if you like.

That’s it, run the synergy client app and you’re all set up. Well I should rephrase. I’m all set up. Everybody has different configurations, so hopefully this will be a good stepping stone for you to get yours working.

What is Hawkeye? From the website:

“Hawkeye is the only .Net tool that allows you to view, edit, analyze and invoke (almost) any object from a .Net application. Whenever you try to debug, test, change or understand an application, Hawkeye can help.”

I haven’t put it through any sort of paces yet, but I was blown away that I was able to attach to my .NET Outlook add-in and change properties in real-time. I think this will quickly become a valued debugging tool. Download it and give it a whirl!

(via Mike Gunderloy’s Daily Grind)

I’ll be using this in the (near) future to post source code!
Thanks for putting this out there!