Richard Banks - Agile and .NET

Parameters: You’re Doing It Wrong!

2011-11-24T10:39:00.001+11:00

Having parameters for a method is perfectly fine however like anything, they can be used for evil. So let me give you a tip: If your code looks anything like this method signature (and I kid you not, this is a real method) then YOU”RE DOING IT WRONG!

SaveContentSetItem(ContentSetItem,String,String,Int32,Int32,Int32,Int32,DateTime,DateTime,DateTime,DateTime,
    DateTime,DateTime,DateTime ,DateTime,Boolean,Boolean,Boolean,Int32,Int32,Int32,Int32,Int32,Int32 ,Boolean,
    Boolean,Boolean,Boolean,Boolean,Single,Boolean,Boolean ,Boolean,Boolean,Boolean,Boolean,Boolean,Boolean,
    Boolean,Boolean ,Boolean,Boolean,Boolean,Boolean,Boolean,Boolean,Boolean,Boolean,
    FileLocation,String,Stream,String,FileDisplayFormat,Boolean,Stream)

Please, for the love of all things good, turn off your computer right now. Pack it in a box. Put the box in a locked safe. Put the safe in a bunker under a mountain. Seal the bunker using 40 foot thick concrete and collapse the entrance. Place a minefield and barbed wire around the bunker, and never EVER WRITE A LINE OF CODE AGAIN!

Ready Player One

2011-11-23T11:01:00.001+11:00

I wouldn’t normally mention a fiction book here as your taste for books is likely to be different to mine, however in this case I’ll make an exception. I’ve just finished reading “Ready Player One” and enjoyed it so much I read it in just 2 days whilst catching planes and trains and by skipping on sleep. It was such a good read I simply couldn’t put it down! I loved it!

Why so? Because it’s a near future, sci-fi book with a big virtual reality/gaming element that I think most geeks will love, especially those who know what an easter-egg is and those with a good knowledge of 80’s geek-, gaming- and/or pop-culture. Plus it’s got some seriously fun puzzles to try and solve before the reveal happens.

This book was also Amazon’s book of the month for August 2011, and deservedly so. Here’s the Amazon review quoted verbatim:

Amazon Best Books of the Month, August 2011: Ready Player One takes place in the not-so-distant future--the world has turned into a very bleak place, but luckily there is OASIS, a virtual reality world that is a vast online utopia. People can plug into OASIS to play, go to school, earn money, and even meet other people (or at least they can meet their avatars), and for protagonist Wade Watts it certainly beats passing the time in his grim, poverty-stricken real life. Along with millions of other world-wide citizens, Wade dreams of finding three keys left behind by James Halliday, the now-deceased creator of OASIS and the richest man to have ever lived. The keys are rumored to be hidden inside OASIS, and whoever finds them will inherit Halliday’s fortune. But Halliday has not made it easy. And there are real dangers in this virtual world. Stuffed to the gills with action, puzzles, nerdy romance, and 80s nostalgia, this high energy cyber-quest will make geeks everywhere feel like they were separated at birth from author Ernest Cline.--Chris Schluep

That review made it sound a little formulaic and it could easily have fallen into that trap, but blissfully it doesn’t. It’s a fast paced, highly entertaining, well written book and my inner geek loved each and every bit of it, especially the retro 80’s references; from Devo to AC/DC, Dungeons and Dragons to Car Wars (awesome!) and from Ferris Bueller to Family Ties.

As a bonus, this is Ernest Cline’s debut novel. If he keeps up this level of writing or, even better, improves then I can’t wait to see what he comes up with next!

P.S. In the interests of full disclosure I’ve got no affiliations with the book or author and I get no kickbacks for mentioning this book, though I wouldn’t mind if there were some, hint, hint!

If you haven’t read it, go grab it (just a suggestion) and if you have, did you enjoy as much as I did?

Underscores in Test Names are a Pain to Type, Right? Not Anymore!

2011-11-11T08:49:00.001+11:00

It might be a large assumption given some of the customers I deal with, but I’m going to assume you write unit tests. I’m also going to assume that when you write tests your test names have underscores separating all the words and making your test names human readable. Something like This_is_a_really_long_test_name_but_thats_ok_because_its_easy_to_read_when_I_use_underscores.

The only (minor) problem I have with this approach is that underscore isn’t the easiest key to type. I’d rather just hit the space bar and have Visual Studio change that space to an underscore for me – after all, that’s exactly what computers are good for :-)

Here’s the good news, there’s a great little ReSharper macro that has been developed that does just that – it’s available from https://github.com/joaroyen/ReSharperExtensions and all you need to do is create an R# live template that wires the macro up to your test name field in a live template. For example:

Now when you use the live template to create a test you can simply type the test name with spaces and they’ll be converted into underscores for you automagically. Fanstastic!

Kudos to Joar Oyen for his great work, and feel free to check out his blog post for how this works under the hood.

Scrum is Open for Extension and Modification

2011-10-10T14:52:00.001+11:00

The title says it all really.

Modifications to the framework need to be approved by Ken Schwaber and Jeff Sutherland (co-creators of Scrum), and to be honest there are likely to be very few, given it’s such a simple framework.

The more interesting thing to keep an eye on will be the Extensions. As a Scrum Coach and Trainer, I’m often asked what teams should do in a specific scenarios. Scrum is silent on those situations because they aren’t generic enough, and yet there are generally accepted, healthy behaviours teams should have in those situations. That’s the essence of an extension. The healthy, beneficial practices team can use to complement Scrum to help teams in Situation X.

This a is great move by Scrum.org and a very welcome one!

Scrum Extension Library and Submission Guide

Scrum Modification Submission Guide

Australian Alt.NET Open Spaces – Tickets Available

2011-10-10T09:46:00.001+11:00

The inaugural Australian Alt.NET Opens Spaces unconference is happening on Sat Dec 3 in Melbourne, directly after the Melbourne YOW! event.

(Free!) Tickets are now available.

And for the curious amongst you, the famous Seattle Alt.Net conference is run in exactly this style, and has the motto of “practice don’t preach” to indicate that it’s all about participation. Have a search for people’s thoughts on the conference and you’ll invariably find people who found the conference much more enjoyable that traditional lecture style conferences.

So what are you waiting for? Go and book a ticket! I’ve got mine, you should get your hands on one too.

And don’t forget to spread the word! The more we have there, the better! Rewteet this post, write your own tweets, put a post on Facebook or LinkedIn, blog about it, tell your colleagues; whatever works.

TFS11 and Source Control Improvements

2011-09-19T08:58:00.001+10:00

Now that build is over and we have a Visual Studio 11 we can finally play with I’ve had a brief look at how local workspaces work.

For those who aren’t aware, local workspaces finally removes the number 1, most annoying “feature” in TFS and that is the server-side source control model.

This is the approach where the server keeps track of what it thinks you have on your local development machine and where all checkin/checkout operations require communication with the server making offline work very difficult, and where you can’t make local changes to checked out files because the server wouldn’t be aware of them so all files under source control have the read only bit set. It’s a major pain.

Now there are valid reasons for this approach related to managing VERY large source repositories (think multi-GB of source) and it’s still possible to use server-managed work spaces if desired, but for the 99% of us that just don’t deal with that sort of volume this is a feature we just don’t need. TFS 11 sees the introduction of a subversion style approach to source control with the introduction of local workspaces. Before you get too excited, remember that a local workspace is not a DVCS and TFS doesn’t feature one yet. That said, Brian Harry in a recent post about source control improvements in TFS11 said the following (emphasis mine):

I’m certain that about this time, I bunch of people are asking “but, did you implement DVCS”. The answer is no, not yet. You still can’t checkin while you are offline. And you can’t do history or branch merges, etc. Certain operations do still require you to be online. You won’t get big long hangs – but rather nice error messages that tell you you need to be online. DVCS is definitely in our future and this is a step in that direction but there’s another step yet to take.

There’s also a number of suggestions about source control on the Visual Studio User Voice site that you may want to vote on so that the team makes this a priority, for example Allow the version control system to be pluggable, or you can create one specifically for a TFS DVCS feature.

Anyway, let’s have a look at a few things in the new developer preview.

What’s on our disk after doing a Get Latest?

Firstly, we see we now have a hidden folder in our workspace root

The folder itself contains a bunch of child folders, which are oddly reminiscent of sourcesafe. Thankfully it’s not!

These folders course contain GUID based file names:

And each of those files are simply GZipped copies of your individual source files. Opening them with 7Zip reveals the source files just as you would expect. Obviously you should leave all this alone and not touch it but it’s interesting nonetheless (or at least it is for me!)

Local Source Control Operations

So leaving that aside, what happens when we make file system changes outside of Visual Studio?

To find out I did a simple copy/paste of a few files and renamed a view in an MVC3 project. This is what pending changes shows (the other changes are from the VS11 project upgrade)

So the changes are detected but are currently marked as ignored for now. I get why the copied files are excluded, because they aren’t part of the solution, but I wasn’t sure why the rename was ignored until I realised it had happened because the files I’d chosen were from an MVC3 project and I hadn’t updated VS11 to support MVC3 apps as yet. This mean Visual Studio hadn’t actually loaded the project so wasn’t actively tracking the file that was renamed.

If I click the “Detected changes (5)” link, we see this:

You’ll note that the rename detection isn’t happening in the developer preview though I expect a way to mark add/delete pairs as renames will be provided before RTM. We also have a “promote” button to turn the excluded changes into included ones. Pretty simple. You can also right click files to ignore them (such as upgrade reports, backup folders, etc) so that they don’t constantly sit in the “excluded files” list.

Once we include the files we want, we see this:

Nice. Now, when we’re offline we can’t check in with a local workspace. We have to be connected. When we are, we can click the Check In button and we’ll get a notification message with a link to the Changeset we just added

Local Exclusions

In git, mercurial and other source control systems there are usually configuration files to control the files that source control will ignore (i.e .gitignore and .hgignore) and they are located in the same folder as the source itself so that they can be checked in and shared across all team members.

In TFS there is only one global exclusion file, and it contains all your local exclusions. It lives in C:\Users\Me\AppData\Local\Microsoft\Team Foundation\4.0\Configuration\VersionControl\LocalItemExclusions.config and looks something like this:

    <UserExclusions>
      <Exclusion>c:\temp\tfspreview\scrum project\Trunk\DemoAppSolution\UpgradeLog.XML</Exclusion>
      <Exclusion>c:\temp\tfspreview\scrum project\Trunk\DemoAppSolution\_UpgradeReport_Files</Exclusion>
      <Exclusion>c:\temp\tfspreview\scrum project\Trunk\DemoAppSolution\Backup</Exclusion>
    </UserExclusions>

I’d prefer a local exclusion file (e.g. a .$tfsignore) to live at the solution or workspace root and I’d also prefer it to be glob or regex syntax instead of and XML document, but at least we have something. It’s a start.

Finally, if you want to play with local workspaces you’ll need access to a TFS11 server. The hosted TFS preview service works well for this and if you try doing source control operations over a 3g connection you really feel the difference between local operations and server calls. Alternatively you can download the TFS11 developer preview from MSDN subscriber downloads and install your own TFS server to have a play with.

All up, this is a well overdue improvement in source control and should alleviate some of the pain we all feel when dealing with TFS.

Learning from a FAIL

2011-09-07T14:32:00.001+10:00

Last year at TechEd Australia I delivered a session on Unit Testing that was rated top 10 overall. This year I delivered a group session that has ended up in the bottom 20. Ouch!

So what went wrong? Let me run through a few things and explain.

For those who weren’t there, the session was a group session presented by myself and 3 others and what we wanted to show was how you can use the full Microsoft stack do deliver on the “three screens and a cloud” promise, how the ALM tooling that Microsoft provides (i.e. Visual Studio and TFS) helps with that, and some of the things to watch out for when doing this kind of development. Our vehicle for this was going to be a multiplayer game that runs on both Windows Phone 7 devices and Windows desktops. We also wanted to show how you could extend the experience beyond the game itself and use a single page web application to extend the gaming experience, so we threw that into the mix as well. That’s a lot for an audience to process in a short space of time. Probably too much as it turns out.

Adding to this, re-reading our session abstract I can see how it is easily misinterpreted. It can be read as if we were going to actually build the application on stage. We never even considered that as an option because we though for sure that the audience would be lost, but it appears a number of people thought we would try anyway. I appreciate that you think we can condense 170 hours of development effort into a a 1 cohesive presentation, but we’re not superhuman! :-) This is a failure to manage expectations on my part. If you turn up expecting to see pure, unadulterated, glowing awesomeness on stage and then we present something that makes them seem merely human then you’re going to be disappointed no matter what. Not meeting expectations is a common cause of discontent and I missed the mark here.

Now when we started our session planning we had nothing; no application and only the vaguest of idea on what it might be that we’re going to build, yet we needed something to show so we could have the bones of our session. This meant we needed to build the whole thing in our spare time and this is where the main problem arose – for various reasons the team only finished the application right before TechEd. Further, because of the last minute finish of the application, the remoteness of each of the presenters, and the presenter’s individual TechEd sessions on top of this one, we never managed to get a proper dry run through the presentation with all of us there. We knew the basic idea of what we needed to talk about but we never managed a full practice first.

This in particular was bad! When I’m doing a solo presentation I usually do at least 3 or 4 dry runs first just to make sure the timing is right, that the flow works and that I hit all the points as I want, etc. Preparation is key! I know this, yet did we do it for this particular session? Not really, no. And the results, sadly, showed this.

Because of the lack of preparation, we also had a few “off script” moments that really, really didn’t help. Compounding this is that as presenters we all know each other and are quite ready to joke around and have fun while still getting stuff done. This unfortunately doesn’t translate on stage. Humour in a session is great on the proviso it doesn’t detract from the message, that it keeps audience interest up and reinforces the learning for them. You’ve also got to ensure it’s delivered well and in-jokes or overdoing it certainly doesn’t count in any of these cases. Again, we let the audience down a little by doing this.

Lessons Learned

So, what do I learn? How do I improve for next time?

Content may be king but don’t overload the audience or be too shallow and too broad. We would have been better scaling back on what we did, limiting our content to only a few areas and going deeper in those areas instead of skimming.

Preparation is paramount. Our lack of preparation hurt. Not the preparation in the building of the game (that was fine) but lack of preparation in the delivery of the session. No matter how good (or bad) the software was, if the delivery was good we would have been fine and people would have enjoyed it more. The lack of preparation also contributed to overload of humour on stage.

Set realistic expectations. There’s a trick when writing session abstracts. If you make your session sound too boring you probably won’t get asked to speak, but if you over-hype it then people get their expectations raised too far and you set yourself up to disappoint. More care and attention to the wording of the session abstract would have helped a great deal in this case. It’s much better to under-commit and over-deliver than to do the opposite.

Working in a group is hard. The larger the group, the harder it gets. If I do another group session in the future, the way we work and the amount of time we’ll commit to up front will be clear from the outset. Coordinating 4 speakers when they each had their own individual sessions and limited availability was asking too much from everyone, so when something had to give it was, unsurprisingly, the group session that suffered.

Evaluation Comments

To round out this lengthy post, let’s have a look at some of the comments from the evaluations, both the positive and the negative. I’ll provide my own feedback in italics:

Although I gained a number of tips regarding potential issues there was little here that I can action directly when I get back to work on Monday. The speakers were all fun and had an easy rapport which made this an enjoyable session
Cut the attempts at comedy and get on with presenting what would have been worth seeing at a more even pace. If you hadn't have jerked around with your piss weak in jokes at the start you could have maybe finished up properly. This doesn't apply to Steve. He looked embarrassed to be with you other gooses.
- Whoa! OK, ignoring the bile, your point is taken.
Funny presentation, sometimes a bit over the top, but great stuff nonetheless
- Point taken on the over the top. It shouldn’t have happened. Sorry.
good fun talk, relaxed
Good stuff Ricahrd!!
great presentation - thanks!
- Not our best effort but also not a complete waste of time. Good to know.
I think the material was good but the comedy act they tried to tack on was just distracting and made their presentation look amateurish which is not what I expect for this type of event.
- Agreed. Comedy should have been used sparingly. Mea culpa.
I was looking forward to more on the fly coding, rather than flipping past a pre built project. It would be better for my understanding if the demo was for a simpler project, but setup and built in front of us.
- Expectation management. We probably should have been clearer in the session description about this. Lesson learnt.
Its teched not the comedy festival ;)
- I assume the smiley meant they enjoyed it. Still, backs up the point that we overdid things.
Less talks and more information and code demo was desired
Loved the idea of the talk but the reality wasn't what I was expecting. I was expecting (yes my expectations were probably too high) a simple MMO built from scratch during the presentation, demonstrating the key technologies for each platform. In reality the app had already been built but even then too much time was spent monkeying around instead of showing source code or talking about lessons learnt. Once again like most presentations at teched it would have been great to have a link at the end of the talk to any downloads/links etc. Talk had potential but didn't deliver.
- That last sentence nicely sums up my feelings as well
OK demo, but a bit too simple for business app.
- I thought a title including “MMO” would indicate it wasn’t a business app. Expectation management again.
Session should have had more code examples going through the actual development process.
The 4 speakers probably know the technology, but the whole session came across as a jumbled mess of in-jokes and non-seriousness. Not sure how anyone can manage to "learn" anything from these guys. Please plan the session better or if you really didn't have anything to say, just cancel it.
- Preparation failure on our part. I’m sorry.
The humor and relavence of this session made it very worth while.
- Humour works sometimes, but it didn’t work for everyone.
The session was informative but I think that there the naming of it should have been better as the current title made the room uncomfortably crowded. The presenters were knowledgable in there fields but to me Steve Nagy was the best presenter, properly explaining the process he took in the development of that project. Though I don't mind some joking it really did distract too much from the amount of material that they needed to cover.
the speakers did not realise the audience invested time to see this demo. They enjoyed each other company, but wasted my time.
- Apologies for that. It definitely wasn’t the intention.
There was a little bit too much shenanigans on stage, and too many in jokes, so I think a lot in the audience lost interest. I think people were expecting to see more actual code and implementation (as the session title implied).
This was a very ambitious session and unfortunately, the presenters did not quite pull it off. There was a lot of really cool stuff that these guts were trying to present - but the presentation was low on details, and the attempts at comedy took away from technology being presented
Too busy trying to get a laugh from the crowd, that time could've been spent explaining some of the pitfalls they faced.
too much focus on the "gaming concepts" (XNA/Latency&Prediction), but overall very good session.
- A dry run would have helped balance a lot of the issues raised in the 3 comments above.
Too much time was spent playing about on Stage and not enough on the content. A little bit is good but they went way too far. Points focused on seemed to be very specific to the problems they found with an MMO example, not necessarially translating to what someone else would experience building an app with a cloud backend for the three screen types. The third presenter was more straight up and he actually pulled the about scores up a bit. If I was rating him individually he would get far higher scores for the above, but I would have liked some deeper content, particularly from a 300 session. The one thing that would save this is if we could get a look at the code to actually see how much crossover there is between each of the clients in detail and pull it apart ourselves a bit.
- I’m tossing up wether to put the code up on github to look at, but some of it was very rushed and not our best work. Is that still useful? Blog posts that go into detail may be better.
Very good and informative session. Also the speakers' lightheart approach makes this sessions very interesting. Bravo
Weirdos! Made the session fun
- Erm, thanks for that summary… I think :-)

And there you have it. A very public retrospective from my part on what went wrong, what could have been done better and the lessons to learn.

Publicly talk about your failings is hard, yet there’s nothing that teaches you more than a big, public failure. This is my attempt to do some tough learning in an open way so that hopefully you learn something from it as well.

Finally, if you attended the session at and you thought it sucked, then I apologise and hope that you enjoyed the rest of the conference.

Using Parallel Task Library to Unit Test Threading Issues

2011-09-02T12:04:00.001+10:00

I was doing some work recently on a demo application where data was being pulled in from multiple locations and being added to a collection that was also being iterated over in the same method. Because this data was arriving on multiple threads (i.e. async network call backs for example) I’d occasionally see the usual “collection was modified” error messages indicating that another thread had altered the collection while the first was iterating over it. Obvious threading bug, #FacePlam applied.

While it can be complex at times to find these kinds of errors, in this case it was fairly easy to diagnose and fix, so following good bug fix practices I took the standard approach of writing a test to prove the bug exists, fixing the code and then running the test again to prove it’s fixed.

Now, it should be noted that testing threading issues in a deterministic way is nigh on impossible, and there is no guarantee that a unit test for threading issues will genuinely prove the code bug free, however the approach taken here was good enough to throw the threading exception each and every time I ran the test and also the throw the exception on the build server.

Here’s the code:

[TestMethod]
public void ThreadingFun()
{
    InitializeControllerAndGroup();

    Task[] tasks = new Task[10]
                            {
                                Task.Factory.StartNew(() => MakeMove(1)),
                                Task.Factory.StartNew(() => MakeMove(2)),
                                Task.Factory.StartNew(() => MakeMove(1)),
                                Task.Factory.StartNew(() => MakeMove(2)),
                                Task.Factory.StartNew(() => MakeMove(1)),
                                Task.Factory.StartNew(() => MakeMove(2)),
                                Task.Factory.StartNew(() => MakeMove(1)),
                                Task.Factory.StartNew(() => MakeMove(2)),
                                Task.Factory.StartNew(() => MakeMove(1)),
                                Task.Factory.StartNew(() => MakeMove(2)),
                            };
    Task.WaitAll(tasks);
}

Ignore the first line, that’s just where the collection is being initialised. Also ignore the fact that there’s no Assert statements in this code. The test passes if we have no threading exceptions thrown and fails if we have one.

The important thing here is to see how easy it is to fire off a lot of threads in a single, easy to read unit test without all the usual threading plumbing code that would litter something like this.

The way it works is that we define a set of tasks via the Task Parallel Library (part of .NET 4.0) each of which calls the code where we have our threading problem. When Task.Factory.StartNew() is called the Task Parallel Library (TPL) immediately creates a new thread and calls the method returning control to our code along with a Task object so would can check the state of the task or cancel it if so desired. In this case we don’t care and immediately start another thread as soon as possible.

We then use the Task.WaitAll statement to wait until all the Tasks we defined are completed so that the test doesn’t complete prematurely. Too easy.

Note that we could also just as easily have used Parallel.Invoke for this. The same test using Parallel Invoke would be something like this:

[TestMethod]
public void ParallelInvoke()
{
    InitializeControllerAndGroup();

    Parallel.Invoke(
        () => MakeMove(1),
        () => MakeMove(2),
        () => MakeMove(1),
        () => MakeMove(2),
        () => MakeMove(1),
        () => MakeMove(2),
        () => MakeMove(1),
        () => MakeMove(2),
        () => MakeMove(1),
        () => MakeMove(2)
    );
}

I personally prefer the first approach because I like the more explicit control over the thread creation, though it’s obviously noisier than the Parallel.Invoke version. Note that with Parallel.Invoke you hand over control to the TPL and it figures out how many threads it will use to run the actions you define based on the number of cores available on the machine.

Regardless of the method you choose you can take advantage of the TPL to help you unit test your multithreaded code and make your application more resilient.

How To Run Multiple WP7 Emulators

2011-08-31T16:22:00.003+10:00

The Windows Phone 7 Tools, including the latest Mango update, provide no supported way for running two emulators at the same time. This can be a problem when trying to see how a multiuser application works across multiple devices. Fortunately there’s a way to workaround this limitation using some unsupported edits to your WP7 emulator settings.
NOTE: This is not a supported change and if something breaks on your machine, well… you’ve been warned :-)

Step 1: Open explorer in Administrator mode and go to C:\ProgramData\Microsoft\Phone Tools\CoreCon\10.0\addons

Step 2: Copy “ImageConfig.en-US.xsl” and name it “ImageConfig.en-US 2.xsl”

Step 3: Open this new file in your text editor of choice and locate the DEVICE element and change the device name to something of your choice and the device GUID to a new GUID as shown. Use the Online GUID Generator to make generating new GUIDs easy.

Step 4: Given the WP7 is a virtual machine, we also need to supply a new Virtual Machine ID, so locate the VMID section and provide a new GUID in there as well. Again the Online GUID Generator can be used for this purpose.

Ensure that the GUID you insert is in the same format (i.e. with the braces)

Step 5: Save the file and start the Application Deployment Tool. You should now see your new emulator available to deploy your applications to:

If you close and restart Visual Studio 2010 you should also seen the second phone emulator available as a deployment target:

Note that of you run a phone application in debug mode there seems to be no way to launch a second instance on the other emulator whilst the phone is running. It’s not a major problem though since you can simply take the debug .xap file and deploy it to the second emulator using the deployment tool.

I hope this helps you out. Enjoy!

Getting Out of Sync With IIS and Riding A Comet

2011-08-19T11:39:00.002+10:00

It’s taken a little while but my slide deck from DDD Sydney, 2011 is now up on the web.
Unfortunately I don’t have the code or load test details embedded in the presentation but even so this should still have a number of useful things for you to look at, especially the resources section at the end
Oh, as an experiment, I’ve put both a Slideshare player and a Powerpoint Web App player in this post. I’d like to know which one you think is better (send me a tweet to @rbanks54 or leave a comment)

DDD Sydney 2011 - Getting out of Sync with IIS and Riding a Comet

View more presentations from Richard Banks.

Outsourcing, Unit Testing and Costs

2011-08-12T15:49:00.001+10:00

Let’s say you work in an internal IT department, largely doing maintenance work on software solutions. Solutions that are by and large built by external vendors through an outsourcing arrangement and then brought in house once they’ve gone live and the initial warranty period has elapsed.

Let’s say every time you look at one of these solutions that you now have to maintain you find the grand sum of zero unit tests. Without exception. Every single application has nary a unit test to be seen. Not even a hint that one might have existed and been removed at a later date.

“Why?!” you cry to yourself. In frustration you cry “Why!!?” to management as well. Their answer: The vendors tell us “it will cost more and take longer to do unit testing” and of course, they reason with you, if that’s the case then why would we pay for it? You know this is a bad argument and the logic is built on sand, so what’s your comeback? How do you get it across to management that a vendor that ignores unit testing is a bad vendor and is actually more expensive overall?

So my initial response to their claims would be along the lines of “So do I assume they’re not actually testing the software they write for us then.” and then explain how manual testing takes (much) longer than developing automated tests, assuming of course that the code being written is in any way testable. If they develop poorly and have a lot of tight coupling between concrete classes or make a lot of static calls to HttpContext or develop in SharePoint for instance then the application might not be easily testable, but hey! That’s their problem not ours. The good news is that anyone with a business brain can understand the benefits of automation for tedious repetitive time consuming processes – heck, we worked that out during the industrial revolution.

Let’s try a different angle in case the first, most obvious one doesn’t work. If you consider a lack of automated testing to be merely another form of technical debt then it’s just like poor design and architecture, horribly complex methods, N+1 ORM queries, poor UI’s, high bug counts, etc. It’s something that will cost you. So, if a vendor delivers you software with a high level of technical debt and you’ll be maintaining it, then you’re going to have a lower long term ROI and higher TCO from those vendors versus what you might have from a vendor who keeps their debt levels low. So while the cheap guys may argue that it will cost more and takes longer to write code with unit tests then what they’re really saying is this

“It costs US more and takes US longer to do unit testing because the developers we hire are the cheapest and suckiest we could find. They don’t understand good development practices and we’re not about to teach them because they’ll leave in the next 3 to 6 months. Also manual testers here are cheap-as-chips and lose staff too quickly, so it’s easier for US if we just get the software to ‘it kind of works’ and then give it to you so we can get our money and hope you won’t notice”.

Also, don’t forget that post delivery, all those bugs and problems that snuck through from the vendor will end up becoming your bugs and problems to fix as part of your maintenance work. So the company is either paying for it with internal staff costs (often seen as a hidden/sunk cost) or, if the vendor is also charging for maintenance, paying for it once a development project is concluded. Development takes longer, it’s harder to find and fix bugs, it takes longer and longer to test the application manually, etc. These all add up to time, and in software development time is money!

With that, good luck convincing management to change their vendors, and if you’ve got a better reason to present yours case I’d love to hear it.

Note: I’m not implying manual testing is bad. In fact I think you should be doing manual testing; but only manual exploratory testing where testers are trying to break your code. It’s rote, repetitive manual testing that is neither cost efficient or effective.

Going to TechEd Australia? Lock in DEV305

2011-08-08T10:30:00.001+10:00

Why? Because that’s the session you want to go to of course!

Here’s the link with all the details: http://australia.msteched.com/topic/details/DEV305

Aaron Powell, Luke Drumm, Steve Nagy and myself are going to show you how to build applications for the cloud using multiple clients (i.e. PC and Windows Phone 7 in this case) and some of the things to watch out for. Don’t worry it won’t be one of those sessions where people try and prove how awesome they are by writing the whole thing on stage. Instead we’ll be showing you the highlights and what you should think about if you want to try something similar.

I’ll also have my recording equipment with me and will be recording a number of podcasts for Talking Shop Down Under with people while I’m up there, so if you want to hear from someone in particular, let me know so I can line up a time with them!

True Community is What YOU Make it

2011-07-05T11:35:00.001+10:00

Roy Osherove’s post on "True Community”™ has been making the rounds on the twitterz in the last 24 hours (or as some people have called it “Yet Another Leaving .NET Post”). I feel like I should respond with some thoughts.

First up, let me say I applaud Roy for making his views clear and talking about the differences in the communities and the speed at which the Ruby/Rails community is driving forward. I thinks it great that someone showed enough courage to switch from one technology to another and begin the learning process all over again. What I have a problem with is the deriding of the technology/community you leave. It’s a pretty simple reason too.

The Ruby/Rails community and the .NET community are different communities! There’s no such thing as “True Community”, just community. Calling your community anything else is simply hyperbole, elitism and idealism.

Of course the two communities won’t be the same! They’re made up of different people. Neither will one community be inherently better than another. They are just made up of different people. An apple is not inherently better than an orange or a banana, just because it’s a different fruit. And just because you’ve decided that you like your new community because it’s more akin to your personal tastes, doesn’t mean that those in the other community are ignoramuses, fools, ill-treated and misguided or troglodytes. These sort of attitudes won’t and don’t help anyone.

We’re all developers and we all want to make the best software we can using whatever our chosen technology is. If you don’t like the way your technology or community is progressing or you like the look of other groups more and you leave, that’s fine. Go for it. Be awesome no matter where you go. However if you do leave, don’t then berate those who stay or point out only the negatives as you see them. Constructive criticism is welcome. Criticism that exists just to validate your decision to move is not.

The Ruby/Rails community is still quite small and young and thus is able to change rapidly and innovate quickly. It won’t last forever, it never does, but there’s a lot to like about a community like that, and a lot that everyone can learn from it. I get that. Truly I do. I wish there was more of that going on in the .NET space. Look at the Java and .NET communities on the other hand. They’re much larger and more prone to innovation impedance, making it harder to change things and for .NET in particular when management places more focus on what Microsoft produces to the exclusion of better solutions there can be some real problems.

On the flip side, while Roy makes some strong points about Microsoft not valuing the community, I think they only apply to certain parts of the business. It’s not like that everywhere, and it’s changing. I was on an open source panel on the weekend at the DDD Sydney conference and stated that we’re seeing a gradual change of Microsoft’s attitude towards their open source developers and the developer community in general. The move from closed source to grudging acceptance of open source to a willing approval and active contribution to open source in the community at large has been a slow transition, but it is happening. Why? Because of the very community that Roy complains about is driving change! Groups like Alt.NET that are looking for ways to push things forward regardless of what Redmond says do have an influence. We see the change because of outspoken and community focused people like Roy himself, and others like Ayende Rahien, Sebastian Lambla, Jeremy Miller, the Herding Code guys, the Microsoft MVC team (who have strong community roots) and many, many more.

People that realise that community is what you make it!

So, you don’t like something in a community you’re in? Then what are you doing to improve it. If the answer is “nothing”, then either stop complaining or get off your butt and get active. It’s pretty simple really. Change your community or change your community.

On a side note, the keen eyed amongst you will notice that Roy’s post didn’t mention the JavaScript community? Why? There’s just as much innovation and excitement happening in that space, if not more. What makes them different? Why don’t we see “I’m leaving .NET for JavaScript” posts? Is it because their community is inclusive by nature and the Rails community is elitist? Is it because the technology is server side agnostic? Is it something else? You know what. Who cares! It’s just another community. One from which everyone can learn.

Nothing says you need to be exclusive. You like .NET, Visual Studio & IntelliSense? Wonderful. Go contribute to your local .NET community. You like Ruby and the Rails framework and enjoy the innovation in that space? Fantastic. Go contribute to your local Rails community. You like Java and think there’s still a lot of improving that can be done there? Brilliant. Go contribute to your local Java community. You like JavaScript and think modern browsers have the power you finally need to make some kick ass software? Excellent. Go contribute to your local JavaScript community.

You get the point. The community is made of you so go influence your community.

Fin.

My Geek Origin Story, what’s yours?

2011-07-04T21:13:00.001+10:00

Yay! It’s Meme time, people. This one started by @delic8genius (Michael Kordahi) who wants to learn your Geek Origin Story and see how we all got in touch with our inner geek. So here’s mine…

For me I remember it all starting with the Atari 2600 and a little game called Asteroids, though looking back at photos from my earlier years I can see that the Atari was merely the trigger that brought the latent geek in me to the surface. I mean seriously, look at this photo of me as a little tacker and just ask yourself if that’s not a geek waiting to happen! And no, that’s not a laptop backpack I’m wearing, though it could be! :-)

I spent days and weeks blowing up asteroids in space and leaping through jungles, swinging on vines and jumping over pits (Pitfall anyone?!), but that all faded to backstory when I went to a selective school and my parents decided it was good for my education if they splashed out on a Commodore 64. The day that thing came home, my fate was sealed. As a kid in primary school I remember the unboxing, plugging it into the TV along with the tape drive and an external floppy drive, turning it on and then seeing the blue screen, the blinking cursor and the READY prompt. What now?! We could LOAD something from tape or disk, or we could crack out the programming books that it came with and explore the possibilities! The games were great, but being able to type things into that C64 and watch them run was a revelation! Not only could I play games, and oh! how I played games, but I could write them as well! I remember writing my own text based adventure games (they were crap of course) and building programs that would show animated running man sprites moving across the screen based on how the joystick was pushed. It was a marvel, pure and simple. Being able to make the computer do what I wanted based on my decisions and actions and see the results on screen. Mwahahaha! The power! The unlimited, unfettered POWER!!! *Cough* *Ahem* Yes, what was I saying? I think I got carried away with myself there…

So I’m sure my parents wished I would go play sport with the other kids on the street more often than I did, but I knew I’d never be great at that. Computers however? Different story. I controlled the universe there. They made sense to me. I could figure out how it all fit together. I could PEEK and POKE with the best of them. I got so much joy, fun, fulfilment and square eyes from playing games and writing software that I knew what I wanted to do for the rest of my life. You see, I’m a gamer, through and through. I love playing games and programming is just another form of game. A different form of accomplishment, but still the same sensation that you get from finishing a level or beating a boss fight. Tell me you haven’t got some code working at times and fist pumped, or put your arms in the air in a victory pose! I’m sure this is how half of the world’s programmers started their coding careers – wishing they could spend all their time playing and writing games as cool and puzzling as Boulder Dash or Impossible Mission or Paradroid. I’m no different.

So there you have it. My geek origin story, what’s yours?

Agile Australia: A Retrospective

2011-06-20T16:31:00.002+10:00

Last week I was a panellist at the Agile Australia conference, talking about hiring people for agile teams, and whilst that was fun the conference overall left me feeling cold, frustrated and disappointed. Anyone who saw my tweet stream during the conference would have probably felt some of that and now that I’ve calmed down a little and thought about things some more, I think it’s time to get to the heart of what really annoyed me and offer some suggestions as to what to do next time. Consider this constructive criticism.

Firstly, it felt like conference sponsors were given slots based on the amount of sponsorship they paid. The title sponsor had the largest number of slots and each of the gold sponsors also appeared to have the option to take slots. The problem I have with this is that a staff member from the title sponsor was also part of the advisory panel, as were staff from their major customers. Conflict of interest anyone? What we saw in the conference were “case study” sessions presented by large corporates who just happened to be customers of the sponsor or sessions from colleagues of other advisory board members. It meant that the event became largely a marketing exercise targeting other large corporates wrapped in conference clothing with very little to offer for anyone working in small organisations or who is already practicing agile and looking for ways to improve through learning from others. The worst session was one where the presenter decided to slowly read a carefully prepared, PR laden, speech. No slides, no audience engagement, just fluff. That sort of thing is simply unforgivable, and even now still gets by blood boiling!

Given one of the key principles of being agile is having the courage to be open and visible with the process I can safely say that this was not an approach followed by the conference. What I would like to see? Community voting on topics, with all submitted sessions available and open for the public/attendees to vote on. If sponsors are getting a number of slots then indicate how many by blanking out their sessions on the schedule, that way we can also see just how much non-sponsor content we may get.

Next on my gripe list. Most sessions were targeted at beginners with content rarely reaching the ‘200-level’ let along going beyond that into more advanced and deeper topics. I’m fine with a number of sessions being beginners based, but to have most of the conference aimed at that level? Urgh! At least mark the sessions with some sort of required knowledge levelling system. It’s important to have sessions marked as “best for beginners”, but please, not the whole conference!

Moving on from that, there was also very little opportunity for ad-hoc discussion with other attendees. The “Individuals and Interactions” aspect of agile should apply to conferences too. Now there were a number of panel sessions, but a panel is nowhere near as interactive as an open space, and asking questions in a room of 200 is much harder for most people than in a group of 20-30. The only open space time in the conference was a 45 minute session at the back end of day 2. This, for me, was far and away the best part of the conference as it meant I could finally sit down and discuss problems and issues with other people and bounce some ideas around, but because of time limitations we really only had 15 minutes per topic. This is just enough time to really get started in on a topic but not enough to get far beyond the shallows. Frustrating! I’d like to see an entire day put aside for open space topics. Make day 1 a “fixed content” day and day 2 an open spaces and workshop day so that we can really dig into things and learn from each other.

Finally, let’s talk about the keynotes. 2 of the 4 were keynotes were good, though the content was unfortunately recycled. The other 2 sessions were terrible. One featured 40 minutes of name dropping, self promotion, marketing and trite stories without any real content at all, and the other was a cliché-ridden, pandering, hippy themed “lets all love each other because we’re all geniuses!” farce. Why a 2 day conference needs 3 keynotes and 2 lock notes is beyond me. I want less of that nonsense and more content next time, just not more toddlers level content!

And if you’re wondering if I would recommend you attend next years Agile Australia conference, and things don’t improve dramatically, then here’s my answer: If you work in a large corporate, are new to agile and you’re still trying to figure out how to make it work for you then yes, but take your marketing proof earmuffs with you. If that’s not you, then stay well away. It’s a complete and utter waste of time.

DDD Sydney, 2011 – Saturday, July 2nd

2011-06-06T20:59:00.001+10:00

Are you an Aussie dev? Based in Sydney or somewhere within driving/flying distance?

Well, why don’t you get yourself along to DDD Sydney this year? Not only will you have a chance to hear me wax lyrical about Comet with IIS and how async coding can help improve performance, but you’ll also get to partake of a slew, nay a plethora!, of topics from other great speakers.

Apart from my talk, I’ll also be a panellist for the Open Source panel, and I’m facilitating the Web Panel later in the day, so at least you now know which sessions to avoid, right? :-)

Jokes aside, last years DDD Sydney was a lot of fun and this year will be even bigger – the agenda and registration are now available. Go check out the details, book yourself a ticket, and I’ll see you there!

Anaesthetic for your #region-itis

2011-06-06T10:57:00.001+10:00

If your code (or the rest of your team) suffers from a bad case of #region-itis then help is at hand.

There’s a lovely little Visual Studio extension over at http://teamsearchapp.com/region-tool that will automatically expand #regions, and also make those #region lines much smaller and harder to read than your normal code. No more pressing shortcuts to expand all those blocks, less visual clutter and optionally, the ability to prevent collapsing of #regions. What’s not to like?

Borrowing a few pictures from their site, it takes the #region afflicted code (on the left) and reveals it’s ugly inner truth (on the right):

Ahh! That’s much better.

What’s Coming with TFS vNext

2011-05-17T11:55:00.001+10:00

Today at Tech.Ed US, Jason Zander and co. went through some of what’s coming in the next versions of TFS and Visual Studio and then blogged about it shortly after.

I saw some of this in action at the MVP summit earlier this year and I liked what I saw, so I’m very glad to see this being publicly talked about now. Now I could recap everything said already, but instead of regurgitating what’s on Jason’s blog, let me quickly call out some of the highlight that I’m interested in, and then you can go to the post, check out all the screenshots, and look at the whitepaper to read more, and see even more screen shots.

This upcoming release aims to close the loop between the business and the developers by building requirements management and end user feedback into the tooling. For most software development projects, timely interaction with the customer is a critical element for success and having software that supports this is fantastic. It also extends the communication loop from developers through to the ops team so that performance problems, bugs with stack traces and other issues that IT Pros find in production can be pushed back directly to the team to fix. With my agile coaching hat on, I’m really looking forward to getting teams and organisations using these features to remove waste and improve what they do.

PowerPoint will be enabled for use as a lightweight requirements and wire framing tool. This is sooo much more approachable than Sketchflow and given it follows what a lot of people already do, this is a very welcome addition. Customers, BA’s, and others that want to quickly use PowerPoint to knock out a wireframe of how an application might work can now do so and incorporate it into TFS and make it part of the requirements management process. Excellent!

TFS will also feature an agile task board and provide tools to make backlog management and prioritisation easier. No more going to excel, unless you want to, just drag and drop items to rearrange priorities. In fact the next version of TFS recognizes that most teams are now using agile approaches and explicitly targets features that will make supporting these processes easier.

Visual Studio will support test frameworks other than MSTest. Yes, you read that right. It means means the all new VS test runner will now handle nUnit and XUnit, including code coverage, and provides extension points other test frameworks can use to plug themselves into visual studio.

Visual Studio will also sport a Crucible/CodeCollab style code review tool, enabling inline commenting and tracking of code review notes, without having to switch out to another tool. For those teams that use code reviews as part of their process having this directly built into Visual Studio is fantastic news.

Further to this, Visual Studio will also be able to detect Code Clones. Microsoft providing tools to help make your code DRY is only going to help improve the overall state of .NET development and I for one think this is a great addition.

Team Explorer is becoming more task and context oriented, so instead of it being a simple tree view of various nodes with a data focused UI, it will now be more aligned with developer work practices and with the usability improvements should make the learning of the tool much simpler and remove the “I hate doing administrivia” feeling you can sometimes get when keeping work items up to date.

All in all, these are great improvements in the product and very, very welcome additions.

Of course, there will be those of you who say that you can already do all or most of this with other tools, and you can, but the integration is often problematic and the benefits of these tools are lost in islands of data. TFS brings all these pieces together in one place to make things visible across the whole team, provide a view as to what’s happening in the project overall end to end and help improve the collaboration in the software development effort. Further, many .NET development teams are sadly stymied by management that dictates an “only from Microsoft” attitude, so having these in the base tooling removes some of the impediments that prevent teams from collaborating and communicating well, and hopefully we’ll see the overall state of .NET development improve as a result.

And in case you were wondering nothing was announced around source control, not that I’m aware of anyway. If you wish, you can go back to a post in Jan 2010 by Brian Harry and read into that what you will.

For now, go read Jason’s post, have a peek at the whitepaper to see what else is coming. Bring on the beta!

This is How Support Messages Should Be Done!

2011-05-05T21:25:00.001+10:00

Taken verbatim from an internal Readify announcement:

Some weeks ago, a company in Redmond, California released a major update to their current generation of Windows called "SP1". That's a boring name for a product that essentially improves and cleans up windows, so we'll refer to this product as "Windex" from now on. Windex is a great thing. IT took the time to put it on our own computers and tried it out. Sure enough, all our windows are cleaner and just better. There have been no bad effects to using Windex as yet.

Emboldened, we set upon a course of putting Windex everywhere we could. We gave it to our friends. We gave it to our colleagues. Everyone loves Windex! This week, we've been busily applying Windex to all the Readify servers. It's been a very positive experience and all Readify's servers have taken to Windex without complaint. In fact, they love Windex!

All our servers for the most part however all rely on three very powerful master machines that are the unsung heroes of our network. These magnificent machines are the quiet achievers of the Cloud network - they manage, control and look after all the servers you know and love; as well as all the servers you don't know and love yet (be assured you'd love them if you knew them). We'll call these three servers the "Hosts" of the network. These three hosts don't yet have Windex. They've seen Windex be put onto all the servers they look after, and have been patiently waiting for someone to come and apply some Windex to them.

That time has come!

... but there's a catch. As a part of applying Windex to any machine, you need to close and reopen the windows on it. I'll call this process "Rebooting". The rest of the network can't do anything if the hosts that look after them are rebooting. So, while the network isn't doing anything, neither will any of our staff. As a result, putting Windex on the hosts during the week would be bad™.

So, starting from about 2am on Sunday morning, while everyone is either in bed or out partying and not caring; These quiet achievers of the Readify family will finally get their Windex. If all goes well, they will be back up and running (and much better and cleaner) by the time you start trying using the network on Sunday. If all doesn’t go well, it’s ok we can still email you and tell you it didn’t go well – and trust us: We’ll know about it before you do. We’ll have all day Sunday to fix any snafu that may happen and still have the whole network ready to run by Monday morning. You may need to consider not doing any work on Sunday.

Kudos to the fantastic Nathan Thomas for always keeping us in the loop as to what’s happening. I love it!

What’s the best downtime message you’ve ever seen?

Windows Media Player and “In Use” External USB Hard Drives

2011-05-04T09:51:00.001+10:00

I have a lovely new 1TB external hard drive and moved all my music onto it a short while ago. Now even though I have iPods and iPhones, for playing that music from my laptop, ITunes on Windows is pretty poor so I’ve tended to use Media Player and, more recently, Zune for that task.

Now, as you would expect I wanted my music into these programs automatically I included the music folder in my library as shown:

Now given I’m on a laptop and I usually want to leave work at the end of the day I’ll Safely Remove the drive from my laptop before packing up, but now when I do I get either the infamous “Windows can't stop your 'Generic Volume' device because it is in use” message or the “Problem Ejecting USB Mass Storage Device” message as shown:

But I closed Media Player (and everything else) so it can’t be locking files can it?

Now, as it happens, in the past I’ve seen Windows Search Indexing locking external drives, but I’d already made sure that the drive isn’t indexed by turning off the flag in the properties window:

and if I look at the Indexing Options in Control Panel I see this:

You can see that the G: drive (the external) isn’t indexed, yet if you look at the location summary in the bottom pane there’s a folder called Music there. What gives?

So I expand the G: drive settings and what do I see? That the folder is, in fact, indexed by Windows Search and it is very likely locking the drive. What the…?! Why isn’t the G:\ drive showing with a greyed checkbox to indicate that one or more child folders are included. Thanks for the great UI there, Microsoft.

So if I just clear it now, then I’ll be able to safely remove the drive, but this is what happens in Media Player’s settings:

Which of means that new items I add to my Music folder won’t automatically appear. That’s not what I want. In fact it sucks.

Maybe I should just use the Zune player instead? Unfortunately, by default, Zune relies on the Windows Media Player library settings, so to break the dependency I have to go into Zune settings and unlink the Zune folders from the windows libraries.

Now I can add the Music folder from the external USB drive and Zune will automatically index the folder and pick up changes to the contents, just as I wanted. And it does it without keeping the drive locked when I exit the program.

So now when I want to go home, I can just close Zune and then safely remove the drive as I would expect.

Phew! Talk about a major pain in the butt! How is a normal, non technical person ever going to figure this out for themselves. Maybe I should’ve just stuck with iTunes – at least it doesn’t lock your external drives on you.

Oh Dear

2011-05-01T14:01:00.001+10:00

Found via Rob Conery’s blog – A Methodology for Better Website Development

My eyes! They burn!! Make it stop!!!

It’s waterfall being touted as the best way to do web development! Seriously!? Who wrote this article? Wait a second while I look…. Oh, it’s the CEO of Ektron, the makers of Ektron CMS. A product so good that the only times I’ve heard of it has been from companies that bought it, got screwed by poor service, bad documentation, horrible support and the vendor’s inability to supply updates in a timely manner, and that have then written it off as a mistake, and then kicked it out so it can be replaced by other commercial products or solutions from that most waterfall-ish of development environments, the open source world! This explains so much!

It seriously annoys me that people write this sort of article as if it’s the one true way and even more when a publisher like ZDNet doesn’t include a public health warning with it.

This isn’t to say agile is the only way to do web development either, not by a long shot. Agile is a mechanism that has been shown to work well in web development and we’ve seen time and again that short development cycles and rapid, continuous releases are a path to success. The real secret to success though? Find the best people you can, educate them in how to best communicate with you and each other, then tell them what you want and then get the hell out of their way!

Individuals and interactions over process and tools.

I think I need to take an aspirin and go have a lie down. Reading that article gave me a small aneurism.

R.I.P. Dear Desktop

2011-04-06T07:37:00.001+10:00

Back at the start of 2009 I picked up an Alienware desktop (post and pictures here) and at the time it was perfect for my needs, and how I did love it so, but as theses stories go time passed and I found myself neglecting my desktop and spending more and more time with my other love – my laptop. It’s what I use for my day to day work needs and as fate would have it where I ended up running almost everything that I once used my desktop for including my PC gaming since it has a decent enough graphics card and I get to take it with me when I travel. The desktop has slowly been turning into nothing more than the place where I host my iTunes music collection. Sad, I know.

Now recently this machine has been randomly shutting down. Initially I thought it was related to a video card driver update that had just came through shortly after Win 7 SP1, but it was a little too random and a driver rollback didn’t fix anything so I cracked open the case to check the internals, and what do I find? That the heat sink and cooling fan are loose in their mountings! The plastic bracket used to hold the heat sink and CPU together had cracked and broken meaning that the CPU had only minimal contact with the heat sink. This would explain the random shutdowns.

So now I have a decision. Do I replace a few parts and get it running again or bid farewell to the desktop, and treat the laptop as the genuine desktop replacement it is? I’ve decided it’s time to say R.I.P. dear desktop and time to spend all my time with just the laptop. I’ll get an external HDD enclosure so I can still get my music and other files off the desktop drive, but that will be all.

So a question for you. Would you do the same if it was you, have you long said goodbye to your desktop and think I’ve been a luddite for hanging on to mine for so long, or would keep the big box and use simply upgrade the motherboard and CPU, etc? I’m curious.

P.S. If anyone wants to make an offer on a second hand Alienware desktop, needing a new CPU & motherboard with 4GB RAM and a decent graphics card, then let me know either via email or twitter.

WinForms and Silverlight Integration With a Twist

2011-04-05T15:34:00.000+10:00

I’m doing some work with a customer at the moment that has a large and complex application written in Progress, and they are wanting to do some work to add new features to it, but want to do so via Silverlight.

Now the way this application works from a UI perspective is that there is an application host shell with a menu and so forth, and when people request a screen it creates a new tab and hosts the appropriate screen in that tab. That screen could be a Progress GUI screen, a console screen or a web page, and now we need to add Silverlight screens to the mix as well.

Something like this:

Now for this to work we have to jump through a few hoops. We need Silverlight to be hosted in a web page, which means we’ll need to host a web browser control somewhere. We’ll also need to host that browser control in a WinForms user control since in Progress we can add a wrapper around the user control to make the whole thing callable via the Progress shell, as well as being able to receive events. When it’s put together it looks something like this:

What we’re also going to do is make sure we have just one Silverlight application containing all the Silverlight forms we want. We don’t want to create an application per form since that would likely turn into a huge maintenance and deployment problem and make development overly complex.

Now for all of this to work we will use the Silverlight to HTML bridge as well as the ability to have pages in the WebBrowser control talk to a .NET object via COM.

Wrap the WebBrowser Control

Let’s start by wrapping the web browser control. We could simply subclass it to do what we need, but if we do we won’t be able to get information back from the Silverlight UI the way we want, so we’ll instead create a custom user control and host the WebBrowser in that.

We’ll also create a few methods on the control to navigate to the page where the Silverlight application is hosted, and to request the particular Silverlight form we want.

Now this code isn’t quite so straightforward since we have some timing issues to deal with. If the Progress code simply calls “Navigate” and then “Open Form” I could be requesting information from the Silverlight application before either the web page or the Silverlight app has finished loading and if that happens then we’ll have errors thrown in our UI. This isn’t so good. We need to wait until things are ready before commencing.

Here’s the code we need. Note that a variable number of arguments for the Silverlight pages is catered for by passing an Object[] array as a parameter.

public partial class SilverlightHost : UserControl
{
 public SilverlightHost()
 {
  InitializeComponent();
  webBrowser1.AllowNavigation = false;
  webBrowser1.AllowWebBrowserDrop = false;
  webBrowser1.IsWebBrowserContextMenuEnabled = false;
  webBrowser1.WebBrowserShortcutsEnabled = false;
  webBrowser1.DocumentCompleted += (s, e) => documentLoaded = true;
 }

 public void LoadSilverlightFrom(string url)
 {
  NavigateToUrl(url);
 }

 private bool documentLoaded = false;

 private void NavigateToUrl(string url)
 {
  documentLoaded = false;
  webBrowser1.Navigate(url);
 }

 public void ShowForm(string formName, object[] parameters)
 {
  while (!documentLoaded)
   Application.DoEvents();
  var args = new List<object> {formName};
  if (parameters != null)
   args.AddRange(parameters);
  webBrowser1.Document.InvokeScript("ShowForm", args.ToArray());
 }
}

Edit the Web Page For Silverlight Interaction

The keen of sight will have noticed that in the ShowForm method above we call a JavaScript script on the web page called ShowForm. This is not a standard script, we need to go and add it.

We’ll also need to do a little work in our JavaScript to handle the fact that the script can be called before the Silverlight object has actually completed initialisation.

<body>
    <form id="form1" runat="server" style="height:100%">
    <div id="silverlightControlHost">
        <object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%" id="silverlightControl">
   <param name="source" value="ClientBin/HostedSilverlightPOC.xap"/>
   <param name="onError" value="onSilverlightError" />
   <param name="background" value="white" />
   <param name="minRuntimeVersion" value="4.0.50826.0" />
   <param name="onload" value="SilverlightLoaded" />
   <param name="autoUpgrade" value="true" />
   <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=4.0.50826.0" style="text-decoration:none">
   <img src="http://go.microsoft.com/fwlink/?LinkId=161376" alt="Get Microsoft Silverlight" style="border-style:none"/>
   </a>
    </object><iframe id="_sl_historyFrame" style="visibility:hidden;height:0px;width:0px;border:0px"></iframe></div></form>

    <script type="text/javascript">
        var silverlightReady = false;
        var navigateToFunction;
        var formName;
        var args;

        function SilverlightLoaded(sender, args) {
            silverlightReady = true;
            if (typeof(navigateToFunction) == 'function')
                navigateToFunction();
        }

        function ShowForm() {
            args = Array.prototype.slice.call(arguments);  
            formName = args.shift();
            var control = document.getElementById('silverlightControl');
            if (silverlightReady)
                control.Content.Page.NavigateTo(formName, args);
            else
                navigateToFunction = function () {
                    control.Content.Page.NavigateTo(formName, args);
                };
        }
    </script>
</body>

So a few things to note. First we hook the Silverlight onLoad event (highlighted) and use it to set a Boolean indicating wether the control has finished loading or not. Once the loading is complete the SilverlightLoaded function is processed where it toggles the flag and calls the navigateToFunction, if it’s been populated.

In the ShowForm function we check if the Silverlight control has loaded and if it has we call the NavigateTo method (we’ll get to that in a minute) and if not we populate the navigateToFunction which will be called once Silverlight has finished loading.

If you’re wondering the JavaScript call will mash the form name and the Object array for the parameters into a single arguments variable. We strip the form

And yes, for those wondering, this code can be made DRYer and cleaner. I left it like this to (hopefully) aid understanding.

The HTML to Silverlight Bridge

So now we have our WinForms control calling the JavaScript on our web page, but we now need to do a few things in Silverlight to receive that call. This is pretty simple:

public partial class NavigationControl : UserControl
{
 public NavigationControl()
 {
  InitializeComponent();
  HtmlPage.RegisterScriptableObject("Page", this);

  pageLaunchers.Add("Main", (p) =>
  {
   var mp = new MainPage();
   mp.textBox1.Text = (string)p[0];
   return mp;
  });
  pageLaunchers.Add("AnotherOne", p =>
  {
   var page = new AnotherOne();
   return page;
  });
 }

 private readonly Dictionary<string, Func<IList<object>, UserControl>> pageLaunchers = new Dictionary<string, Func<IList<object>, UserControl>>();

 [ScriptableMember]
 public void NavigateTo(string controlName, ScriptObject parameterList)
 {
  var paramList = parameterList.ConvertTo<List<object>>();
  var launcher = pageLaunchers[controlName];
  LayoutRoot.Children.Clear();
  var form = launcher(paramList);
  LayoutRoot.Children.Add(form);
 }
}

The Navigation control here is an empty user control. There is nothing in it by default so we can load other controls up into it as the host. These other controls are the pages that we’re wanting our Progress code to be able to call.

Now to get the Silverlight bridge working we simply register the user control as a scriptable object and then mark the methods we want available to JavaScript with the [ScriptableMember] attribute. What you’ll note is that the Object[] array from JavaScript comes through to our Silverlight method as a ScriptObject. We need to convert it in Silverlight to an object collection before we can do things with it.

You’ll also notice that we’re using a collection of initialiser methods to avoid huge case or if statements that map from the string form name we pass through from the WinForms control to the actual form we’re wishing to display.

When we receive a request to load a form we check the collection for an initialiser, clear the current page and initialise the new one. Once we have a reference to it, we load the form up as a child of the navigation control which will automatically show it to our end users, and we’re done.

Raising Events Back In WinForms

So we can now display any form we want to from Progress. We then want to be able to click a button in Silverlight and have an event with some attached data raised back in WinForms for Progress to listen to. Let’s create an event indicating that the Silverlight app is asking the host app to open another form, such as a console or Progress GUI form.

In Silverlight we can create a simple method as follows:

public static void AskHostForForm(string formName, string p1 = "", string p2 = "", string p3 = "")
{
 var form = (ScriptObject)HtmlPage.Window.GetProperty("external");
 form.Invoke("AskHostToOpenForm", formName, p1, p2, p3);
}

And call this from a button click event. For ease of use by all forms this has been made static and resides in the NavigationControl class.

The HtmlPage.Window.GetProperty(“external”) call will retrieve from the web page hosting the Silverlight control any external reference objects on it. In our case that’s going to be the WinForms control. And we’re going to need to ensure that we create an AskHostToOpenForm method

Back in our WinForms control we need to now expose our control as a ComVisible component and tell the WebBroswer control that it is an ObjectForScripting. Doing so will automatically make all public methods on the control available for calling either from JavaScript or from Silverlight via the HTML Bridge as shown in the code snippet above.

We also need to add some code to our WinForms custom control to raise an event when the method is called (so that Progress can do something with it)

Here’s the code.

[ComVisible(true)]
public partial class SilverlightHost : UserControl
{
 public event OpenFormRequestedHandler OpenFormRequested;

 public SilverlightHost()
 {
  InitializeComponent();
  ...
  webBrowser1.ObjectForScripting = this;
 }

 ...

 public void AskHostToOpenForm(string formName, string p1, string p2, string p3)
 {
  var args = new OpenFormRequestedArgs(formName, new object[] {p1, p2, p3});
  if (OpenFormRequested != null)
  {
   OpenFormRequested(this, args);
  }
 }
}

public delegate void OpenFormRequestedHandler(object sender, OpenFormRequestedArgs args);

You’ll see that the number of parameters is fixed. I tried messing about with a variable number of arguments but when I did so the parameters were simply COM objects and there’s no way I was going to mess around with COM :-) I’m not that crazy!

Wrap Up

So there we have it, we can now have a Progress application (or any other WinForms app) that hosts a Silverlight form within a tab of the application and be able to get events back from that form when required.

The code for this is up on GitHub, so feel free to grab it and have a look at how it all fits together. If you’ve got any improvements to it that you want to suggest then please let me know. I’m always happy to get feedback!

Bravo, Suncorp! Bravo!

2011-03-30T10:27:00.001+11:00

BYO Hardware at SunCorp

To quote:

“In what could prove to be a watershed moment for corporate Australia, financial services firm Suncorp will let thousands of employees use their personal computers, including Apple iPads, at work."

In case it’s not obvious, the approach taken means that the devices people choose to use will just be thin clients accessing Citrix virtualised applications and web based internal apps and I think it’s fair to assume that people will need to ensure anti-virus and firewalls are running on their devices where appropriate.

I for one think this is a great move and I hope more large enterprises follow suit. The more places I can use my own hardware and the fewer places where I have to use horrible desktops, with awful keyboards and crappy screens the better.

How To: In Place Branch Switching with TFS 2010

2011-03-28T12:39:00.001+11:00

One of the nice features of some of the newer version control systems is the ability to do fast in-place branch switching.

This is really useful when you are working on a web application and you have mapped an IIS virtual directory to your source folder and want to switch between branches without having to reconfigure your IIS mappings.

If you’re using TFS then most likely branch switching is a pain because you have branches mapped to separate folders and have to constantly close the solution, remap IIS and open the solution again from the other branch folder. But you don’t have to! You can actually have multiple branches using the same local working folder, just not at the same time.

Here’s how to do in place branch switching with TFS 2010.

Starting Point

Let’s assume we have the following source tree in TFS, with a branch per story arrangement (this is using Source Control Explorer in Visual Studio 2010). We currently have no branches mapped, thus the grey folders.

Let’s now map the integration branch and then get the source locally to our working folder.

When we look at the workspace details we then see this:

Switching Branches In Place

Now let’s say I want to switch to one of my story branches to make some changes. The easiest way is right click the folder in source control and select “Map to Local Folder”

Alternatively, if you have the power tools installed into VS2010, you could click on the path mapping at the top of the source control explorer window:

We then enter the same working folder that we used for the integration branch above. Given we’re wanting to reuse our working folder this should be obvious.

If we now look at source control explorer we’ll see that the integration branch is no longer mapped (it’s greyed out) and that our 2703 story is now the active branch.

We can confirm this by looking at the workspace details, seeing that the integration branch is no longer mapped and that our story branch is set to the working folder.

Note that if you change the source control folder in the working folders section of the workspace dialog you will also trigger the remapping operation.

When the get operation executes to pull down files, TFS will only send you files that are different between the two branches. It’s not a full recursive get, which means this operation is quite fast.

Note that this only works if we are switching between TFS branches. If you try switching between non-branch folders you’ll get an error indicating the folder is already mapped.

Command Line Goodness

OK, so let’s go and switch back to the integration branch but this time we’ll do it via the command line. We need two commands for this:

tf workfold /map <<< to change the workspace folder mapping

tf get /remap <<< to bring the local folder contents up to date

And as you can see TFS 2010 has only given us the files that are different between the branches. Nice.

Now, you may ask, why would I use this method and not do it all via Visual Studio 2010?

Well, firstly it’s faster to do it this way (at least for me it is), plus it’s very easy to create a small batch file to make this even quicker and simpler, but a more pragmatic reason is that if I have a solution open when branch switching occurs then you’ll see this in Visual Studio 2010:

Which means I have to wait for the solution to close, for the get operation to complete and then I have to manually reopen the solution. It’s easier than closing the solution in one folder and reopening the solution from another folder, but it’s still somewhat annoying.

If on the other hand I do the branch remapping from the command line then I simply get this:

Visual Studio just prompts to reload open files that have changed, which makes the switching process much easier since I only can just click yes to all and be done. Note that if project or solution files have changed you’ll be prompted to reload them, but there’s no simple way around this.

Oh, one other reason for the command line usage is that at times Visual Studio gets confused about the workspace mapping changes and can sometimes block the switch by showing the “already mapped” error we saw earlier. The command line has no such problems that I’ve seen.

Hang On! What If We Have Pending Changes?

Fair enough. Let’s see what happens.

Assume we’re currently on the integration branch and that we have edited a file. The pending changes window shows this pending edit.

If we now switch to the story branch we get a conflict:

So at this point we do the obvious and click “Checkout File and AutoMerge”, right? Well, not so fast!

This is because the file hasn’t been downloaded to our workspace yet (remember we’re switching our workspace around). Here’s what we see in source control explorer if we want proof:

I’d much rather the pending changes window didn’t show the unusable option, but that aside, we grudgingly take the only choice available to us and overwrite the local file. Our changes are wiped out and the file is now exactly as it is in the story branch we just switched to.

At this point if we look at the pending changes window we see this…

Huh? What’s up with that? TFS is saying there’s a pending change on our file that we just overwrote, but this is the pending change for our original branch isn’t it? If we check in at this point would we make a mess in our original branch. Urgh!

What if we now didn’t look and we went and edited EngineTest.cs in our story branch? If we do and we refresh the pending changes window we see this:

Ah! So the refresh of pending changes shows that we not only have a change in our current story branch but that we also have a pending change for the integration branch still hanging around, but that the integration branch change isn’t mapped to a local file.

I should probably check that integration change in so things don’t get confusing. If we switch back to the integration branch, what happens? Why, we get a merge conflict of course!

Well, we’d better overwrite the local file since we it currently contains changes for the story branch not our integration branch

Unfortunately if we do so, our local changes will now be gone. The pending changes we had floating about somewhere are toast! In fact if we try and commit a file that is not currently mapped we get a dialog like this:

Hmm. OK. Not great.

Good Practices for In Place Branch Switching with TFS 2010

This means that in order for us to make branch switching as painless as possible with TFS, we should remember a few simple things:

Ensure there are no pending changes before switching. Use shelvesets as needed to preserve changes.
The command line is faster. Don’t be afraid to use it.
Ensure our workspace mappings are to folders marked as branches in TFS 2010

And that’s it. Go make the most of it, and if you bump into any edge cases feel free to post a comment about it.

Whither the User Group?

2011-03-15T15:06:00.001+11:00

I’d love to hear some opinions on this so please leave comment(s) below or send me a tweet.

The Problem and Some Questions

In recent times in the Sydney area there have been a number of user group closures, extended breaks, sabbaticals and hiatuses. The Sydney Mobile User Group has closed, the Sydney Business and Technology User Group is on an extended break, the Sydney Architecture User Group is going on sabbatical, the Sydney .NET Users Group has been on an extended break recently, the Sydney Windows Infrastructure User Group is talking of resurrection after being dead for over a year and both the Sydney Deep .NET User Group and the Sydney BizTalk group have been closed for quite some time now.

Whilst there are still a number of groups in action, it seems that the traditional user group format is losing traction. The question I pose to you is this: Why? And what can we do about it?

Is it because the way we consume information has changed over the last few years? For example I reach a much larger number of people via the Talking Shop Down Under podcast each week than I can via a face to face user group meeting. Larger podcasts like Dot Net Rocks regularly get 60,000+ listeners per show, but a large user group only reaches 100 people once a month.

Is it because our sense of community is now online. Twitter, mailing lists, social coding, Q&A sites like stack overflow and more all help us form online communities and allow people to connect with each other in ways that we’ve not done in the past, and help us avoid the awkward "I have to introduce myself to people in the flesh” moments that a lot of developer types find really difficult and that are needed if people are going to really communicate at user groups.

Is it because face to face meetings can be somewhat hit and miss? There’s a time cost to attending a user group meeting and they occur at specific times. Do people find the value of attending to low to make the time and inconvenience cost of being there in person worthwhile?

Do virtual meetings work? Virtual is great for learning and reflects the changing nature of how we consume information, but they’re not so great for interactive discussions. We’ve run virtual alt.net meetings in the past and it worked for a while, but it was less than what I’d hoped it would be. Can we improve how these are done and make them really valuable for people?

Or is it something as simple as those who were running the group became burnt out or left the community and no one else stepped up to fill the leadership gap?

Some Thoughts

As a scrum person I like to regularly have retrospectives and “inspect and adapt”. Add to that the alt.net approach of wanting to push the boundaries and challenge the status quo then it’s probably no surprise that I think it’s time to reinvent the user group as we know it. The question now is how? What would it look like?

If we go to the source of all truth (Wikipedia!) and look at the online communities topic we see that there are a few stages that people go through to enter and participate in a community. They are:

Peripheral (i.e. Lurker) – An outside, unstructured participation
Inbound (i.e. Novice) – Newcomer is invested in the community and heading towards full participation
Insider (i.e. Regular) – Full committed community participant
Boundary (i.e. Leader) – A leader, sustains membership participation and brokers interactions
Outbound (i.e. Elder) – Process of leaving the community due to new relationships, new positions, new outlooks

A user group generally targets the Insider/Boundary members, but there is often a barrier of entry for the lurkers and novices to overcome. Attending a group when you don’t know anyone is hard. Attending a group in a location you’ve not been to before is hard. Attending a group at night when family beckons is hard. People who have been attending for some time often forget about this and whilst they are more than welcoming of newcomers, most groups fall into behavioural patterns where the regular attenders talking to each other and the newbies sit quietly on the outer feeling semi-ostracized until someone drags them into a conversation.

A virtual group on the other hand encourages the peripheral and inbound people by making the barrier to entry low, but without the “stickiness” of face to face communication few people transition to insiders and help build a true community.

Another thing to consider is what motivates people to join a community, to remain in it and to participate in it. Looking at the online participation topic you see a few key ideas. Ideas that are simply reflections of real world communities.

Reciprocity – there’s got to be something worthwhile in return for the time cost of participating
Recognition – obvious enough
Influence – people want to have some effect on others in the community through high value contributions
Sense of community – it’s all about connections with other people. We’re social beings, even if we’re introverts.

User group meetings provide the opportunity for all of these ideas to be borne out, though online communities do so as well. Facebook being the poster child for this. That said, the connections made via facebook, twitter and other online communities are far looser that those made face to face. There’s nothing like meeting people in person that you’ve only talked with online – it turns “friends” into friends, for example:

A Proposal

So what can we do to reinvent user groups? I don’t like talking about a problem without at least throwing some ideas for a solution out there to prompt conversation, so here’s a few tweets from some discussions this morning after I asked a few open ended questions about user groups…

So what do you think?

Is it time to move the traditional monthly user group meeting to become a more social event with regular online presentations around the topics the group is interested in? It’s how the Perth Alt.Net group operates and I know of a number of other groups that are starting to do the same.

If your user group did become a mixed virtual/physical group, how would you want to see the things run? Social meetings at a bar, restaurant, someone’s house with a barbeque? Would you like the virtual meetings via Livemeeting? Livestream or Kyte.TV, etc? Or something else.

Click the comments link below and let me know (or send a tweet or start a thread on the Australian Alt.Net mailing list). I’m really curious to hear what you think.

Git-TFS Recent Improvements

2011-03-03T12:24:00.002+11:00

If you like using Git for local development work but work in a team environment where TFS in use then you’ll be glad to know that the git-tfs project has been progressing well since I last posted about it.

The best new feature is that now you can do a checkin direct from git-tfs instead of needing to shelve, and then check in via team explorer, making the whole process much, much smoother.

Here’s an example of how things now work (assuming you have already cloned the TFS repository)

When you run the git tfs ct (aka checkintool) command, you will see the check in dialog so you can commit the changes. Note that this is only supported with TFS2010.

I’ve got a small change in my fork which will hopefully be pulled in to the main project shortly that pulls the commit messages from git and populates the comment field of the check in. UPDATE: This is now included in the main project so use spraint's version.

Once the check in completes git-tfs then automatically pulls the changeset from the remote TFS server and merges the change locally to save you having to remember doing that yourself.

Finished! Now we can get back to our normal development flow. This is so much easier.

The advantage of having the checkin tool is that we can also associate our commit with work items in TFS as well as dealing with check in policies. This is excellent!

If you don’t want to use the check in tool UI, then you can use the git tfs checkin command and supply the –w option to associate to a work item. Policy failures should result in the checkin failing.

Note that for now, you will have to build git-tfs from source to get this functionality, but that shouldn’t be a problem for anyone wanting to use this tool :-)

Running Neo4j on Azure

2011-02-22T13:57:00.000+11:00

For those of you who don’t know what I’m talking about, Neo4j is a graph DB, which is great for dealing with certain types of data such as relationships between people (I find it ironic that relational databases aren’t great for this) and it’s perfect for the project I’m working on at the moment.

However this project also needs to be deployable on Azure, which means if I want a graph DB for storing data, I need something running on Azure. I’d originally looked at Sones for doing this since it was the only one around that I knew could run on Azure, but my preference was to run Neo4j instead, because I know it a little better, and because I know that the community around it is quite helpful.

The great news is that as of just recently (a week ago at time of writing) Neo4j can now run on Azure! Happy days!! and “Perfect Timing”™ for my project. I just had to try it out. P.S. Feel free to go ahead and read the Neo4j blog post because it has a basic explanation of how to set it up, has some interesting notes on the implementation and also talks about the roadmap ahead.

Here’s a simple step-by-step on how to get Neo4j running on you local Azure development environment:

1. Download the Neo4j software from http://neo4j.org/download/. I grabbed the 1.3.M02 (windows) version.

2. You’ll also need to download the Neo4j Azure project, which is linked to from the Neo4j blog post.

3. I’m assuming you have an up to date Java runtime locally, so go to your program files folder and zip up the jre6 folder. Call it something creative like jre6.zip :-)

4. If you haven’t already done so I’d also suggest you get yourself a utility for managing Azure blob storage. I’m using the Azure Blob Studio 2011 Visual Studio Extension.

5. Spin up Visual Studio and load the Neo4j Azure solution. Make sure the Azure project is the startup project

6. Next, upload both the Ne04j and JRE zip files you have to Azure blob storage. Note that by default the Azure project looks for a neo4j container, so it’s best to create that container first:

7. Now it’s time to spin this thing up! Press the infamous F5 and wait for a while as Azure gets it act in order, deploys the app and starts everything up for you. You’ll know things are up and running when a neo4j console app appears on your desktop. You may also get asked about allowing a windows firewall exception, depending on your machine configuration.

Behind the scenes, the Neo4j Azure app will pull both the java runtime and neo4j zip files down from blob storage, unzip them and then call java to start things up. As you can imagine, this can take some time.

If you have the local Compute Emulator running, then you should be able to see logging information indicating what’s happening, for example:

8. Once everything is up and running you should be able to start a browser up and point it to the administration interface. On my machine that was http://localhost:5100. You can check the port number to use by having a look at the top of the log for this:

You should then see something like this:

That chart is showing data being added to the database. Just what we want to see!

So that’s it. The server is up and running and it wasn’t too hard at all! The Neo team is looking to make the whole process much simpler, but I think this is a great start and it is very welcome indeed!

If you do have problems, check the locations in the settings of the Neo4jServerHost in the Azure project to make sure they match your local values. You might just need to adjust them to get it working.

P.S. If you have questions, then ask in the Neo4j forums. I’m not an expert in any of this ;-) I’m just really pleased to be able to see it running on Azure.

The Anti-Region Campaign

2011-02-14T14:39:00.000+11:00

For the benefit of my twitter followers who know I have an ongoing issue with the abuse of #regions in the code I have to work with, let me take some time to explain why I dislike them so much. In fact, let this be considered yet another step in my ongoing anti-#region campaign! (similar to the anti-if campaign)

This is not to say #regions aren’t useful, but that they are far too over used, and until people can consume #regions responsibly, prohibition laws should be enacted.

Got an Opinion? O‘course You Do!

Even without reading this post in full I’m sure you already have an opinion and like most people on internet time you’re likely to skim the first paragraph or two and then skip the rest, so to save you time here’s how to leave feedback:

If You Agree with Richard: If you too dislike the abuse of #regions then leave a comment on this post. If there’s enough support I might think about starting a proper anti-region campaign.

If You Think Richard is a Raving Lunatic: If you think I’m over-reacting, slightly unhinged, don’t understand your special needs and why #regions make the world around you glow, or if you count yourself as a #region lover then I would ask that you leave your comments and feedback on this post here instead.

Why Do #Regions Even Exist?

So why in the name of all things good and holy, do #regions exist in the first place? Don’t they kill kittens? Aren’t they pure evil?

Let’s have a look at what the MSDN documentation says, shall we?

#region lets you specify a block of code that you can expand or collapse when using the outlining feature of the Visual Studio Code Editor. In longer code files, it is convenient to be able to collapse or hide one or more regions so that you can focus on the part of the file that you are currently working on.

OK. That seems nice on the surface, but isn’t the code I’m working on a class file? Don’t I need to see it in context? Hmm. Let’s have a look at the reasons I don’t like #regions shall we:

Reason 1 – It Hides Code

So, according the the spec, it’s to hide chunks of code to help us focus more on the bits we’re changing. Do you see the problem with that? Why would I, as a developer, want to actually see code? Are you out of your mind! Code is the last thing I want to see! I want to write code, not read it!

I should be able to look at a piece of class and get an understanding of it straight away and how it fits in with the rest of the class. #regions can prevent that from happening.

How can I actually tell what this code is doing? And apologies for the Hungarian notation VB code – I hope it doesn’t burn your eyes too badly!

I know there’s something going on in there (the line numbers give me a hint), but can I know at first glance what it is? No chance! This is a bad thing.

P.S. One valid reason to allow #regions to exist is designer/code generated code. However the availability of partial classes since Visual Studio 2005 means that a we’ve been able to pull all that designer generated crap out and keep it in a separate file for a long time now. There’s no need to have that junk cluttering up my own hand crafted junk! #regions are redundant in this case.

Reason 2 – It Hides What You Think Might Be Code

I just love seeing this sort of thing:

There’s gotta be something in that code there right? Something important!

So let’s open the region and have a look?

Say what!? There’s nothing useful there at all?! It’s just commented out code?

So the #region is “helping” us by hiding commented out code! Surely I don’t need a region to help hide that from me, do I? NO! Just delete the code! Don’t comment it out and wrap it in a #region! What a great way to waste my time!

Reason 3 – It Hides Nothing At All

I don’t know wether to blame horrible coding standard that mandate the presence of specially names regions for segment class files or not but I’m sure you’ve never seen this little gem:

Only to open the #region to see what’s inside and realise there’s nothing there!

It’s like being given an empty box for your birthday. All nicely wrapped up and making you wonder what special surprise is hiding inside only to open it and find that your kid brother has been playing a horrible, cruel joke on you.

What’s even better is when you see a class with all the mandatory regions in it (like the code we saw in Reason 1) and yet when you open all the regions up, there’s just a single static method in there and the rest is blank. Or even better, the whole class is empty!

Regions like this fail completely in their mission to help you focus on just the code you need to see, and instead add only noise and confusion to the understanding-what-the-class-does process, and make you doubt any other #regions you see elsewhere in the codebase.

Reason 4 – It Hides Just One Thing

What about this #region:

There’s going to be some really complex code in there, right? Why else would I have a region there, especially since regions are meant to hide code that might distract me!

Open it up and what do I see?

Oh wow! Just as well we used a region to hide a single property!

Again, we’ve added noise to our code base for no reason.

Reason 5 – It Hides Butt-Ugly Code

So what about this situation? You’re looking through a code base and see the method from hell and it’s associated demonic friends. We don’t want to see that code do we? No way! We want to hide that complexity, so let’s wrap it up in a region! Great thinking!

This is what we are really doing with our code: We’re sweeping all that ugly under the carpet.

As a general principle, classes should have a single responsibility and methods should be 20 lines of code or less so they stay readable. If methods are longer than that then you’re likely working at multiple levels of abstraction in the one method or trying to do too much, and you should consider refactoring your code to improve it’s design and readability.

It’s better to keep the ugly visible so that you can deal with it. Hiding bad code behind regions only serves to make bad code acceptable and it discourages efforts for improving it.

Reason 6 – It Hides Copy/Paste Efforts

The DRY principle means logic should exist in one place and one place only, not be repeated all over the place, because a change to the logic means finding all the spots that logic exists and fixing them all. It’s much easier to make a fix once than it is to fix it in multiple places.

If I have a code base covered in regions I can’t tell if one section of code is similar to any other code I’ve seen before, because in all likelihood I’ve not seen it! It’s probably been hidden away behind #region statements that mask all of the complexity and character of the code, instead making it a big block of beige.

Here’s what code looks like when #regions have been liberally applied to it:

It all looks the same. And you’re not sure if it’s laughing at you or about to turn on you!

What About Grouping Your Code?

Let’s say you think #regions are great because they allow you to group your code and hide all those messy internal field and property declarations. If you’ve only got a handful of them, do you really need the #region? Probably not. There’s not much to hide.

If you’ve got hundreds of the suckers do you need a #region? Maybe – though at that point you should be considering the design of your system. Do you really need a class with that many properties or fields? Can you alter the design to improve things? Is your class doing too much? That’s a judgment call you’ll have to make.

My gripe is with #regions is not with the directive in and of itself, but with it’s abuse. If a #region is being used as I’ve outlined in the reasons above, then it’s time to stop, think about your code and why you’re using a #region and to then do yourself a favour. Remove the #region and start writing better code instead.

That will be all.

Presenting at CodeProject’s Agile Virtual Tech Summit

2011-02-10T23:10:00.001+11:00

The title does give it away a little I suppose… I’ll be presenting two sessions at the Agile Virtual Tech Summit run by the Code Project. I’m quite honoured to be asked to present and for reference in my 2 sessions I’ll be keynoting the Agile track with a talk on Agile from a Developers Perspective, with the other session being about Lessons Learned from Agile Implementations.

You can register for the free event on the site and the summit will get underway on Feb 23rd, 2011 at 12pm ET (for those in Australia that’s a 4AM start on the 24th so don’t forget the coffee!)

Branch per Story Pattern and TFS

2011-02-05T00:10:00.000+11:00

The TFS branching guide is a very detailed run through of the various situations and scenarios under which branching can be performed and the different strategies that exist, however because the guide covers so many scenarios it’s difficult for some people to know what approach they should follow, and when they look at some of the advanced diagrams they freak out at the complexity.

For this post I’m going to keep it simple and just show one approach, the one that I feel is best for agile teams implementing using user stories. It’s effectively the feature branch approach, and I’ve been tempted not to write this post, however I find that that feature-branch approach can be a little confusing for some people. “What is a feature?” “Is it multiple stories?” “Is it an epic?” “Is it a bug fix?” “Should a feature live across multiple sprints?” These are all questions I hear and it’s probably because the terminology is a little too generic and becomes open to interpretation and thus misunderstanding. So, let’s make it easy and use Agile terminology.

Why Story Branches

So before we get into it, what exactly is wrong with working in trunk or using a branch per sprint approach? If you can make it work then there is nothing wrong with that approach, but it does come with some with hidden dangers.

Consider the following situation. A team accepts 3 product backlog items for a sprint and only completes 2 of those items. The third story was in progress when the sprint concluded but was far from complete and the team now has a section of unfinished code in their code base.

What should the team do with that unfinished code? Should they go back and comment it out or delete it? Maybe, but how will they be sure they got it all? What if some of the changes they were making affected the system architecture and those changes had been used in the implementation of the other two stories? What if the code was also merged to another branch in preparation for a release?

What if they take a different approach and try wrapping all changes in if-blocks during development to try and isolate the changes? Sure, this can work. But again it has challenges. The team needs to maintain a set of variables or pre-processor tokens related to each item that are used to decide if a feature is available or not. There’s also going to be a large number of if statements that will add noise to the code and in a complex system you can easily imagine how out of control this could get.

What if they just ignore these challenges (or forget the code) and leave the unfinished code as is? At best they have code that is unused and simply adds bloat to the system, at worst it results in the system being released with broken functionality and open security attack vectors that have never been checked or tested.

If we also remind ourselves that sprints should produce production ready, potentially releasable increments of the system, then we really, really don’t want to have work in progress code in the system at sprint conclusion.

For all of these reasons we should ensure our development of a feature is isolated from the rest of the development team and only made generally available when complete and ready for integration testing.

There’s an interesting side effect to taking this approach. If we develop features in isolation and consider Conway’s law which when paraphrased says that system architectures reflect the way the organisation communicates, then by nature the systems we develop using a branch per story model will likely be architected and designed as componentised and modular systems, mirroring the development approach we are using.

Downsides

What are the downsides, then? Surely the administration overhead goes up and chances of screwing up merges increases, and yes, there is an element of that, but it isn’t as bad as you think.

Administration time goes up because we now have to remember to create a branch, and we have to remember to switch branches when we work on different stories in the same sprint. Is this really an issue though? Maybe it is. However maybe it’s a hidden blessing in disguise. When working in an agile manner we want to minimise wasted effort and keep our work in progress as low as we can. We know that the costs of multi-tasking, working on different stories at the same time, means we’re go slower overall than if we just work on one story at a time because of the mental context switch and yet the temptation to multi-task is high, especially if the stories we work on are somewhat boring.

By following a branch per story strategy we discourage ourselves from multitasking since the simple annoyance of switching to a solution file on a different branch gives us a natural prevention mechanism. Note that this annoyance doesn’t work with DVCS systems like git and mercurial since branch switching is very quick and easy, but in TFS, SubVersion and similar branches are represented as folders and switching means swapping folders, and thus closing and re-opening the solution.

What about merging? Branching is easy but a great deal of pain can be had in the merging of branches. This pain is most often encountered when the two branches have diverged significantly. However, in a branch-per-story model most branches are short lived and thus merging fairly straightforward. It doesn’t mean merge conflicts can’t occur, just that the merges are likely to have small amounts of conflicts.

Visual Branching Model

So let’s have a look at what we’re doing with the branching model. For each story in the sprint we work on we’re create a story branch by branching the main integration branch.

Let’s say the team picks up three stories for the sprint. We create the story branches and the team commences work:

Let’s say Story 1 gets completed first. The code for story 1 is merged back to the integration branch, the integration code is checked and verified and when all the tasks for the story are complete the branch is killed off.

Next, Story 2 is completed so the developers pull from the integration branch, merge the changes, confirm things are OK locally, then push their changes back to the integration branch. Again, the developers check the code in the integration branch is OK, and when it is the story 2 branch is killed off.

Finally Story 3 is code complete. Again, the developers pull the branch code down to their story branch, do the merge and make sure it’s OK. When it looks good they push their changes back to the integration branch, make sure the integration branch is OK and kill of the Story 3 branch.

Pretty simple process, right?

Doing it with TFS

So, enough with the explanations let’s see how we do this with TFS.

Creating branches is easy enough, but how do you name the branches? We don’t want to try and embed the story name in the branch name since that will increase folder length and makes it far more likely that we’ll hit the file path length limit (yes, there is one and it’s smaller than you think).

The strategy I prefer is simple. Because we are using TFS and stories are just TFS work items, I like to use the story number as the branch name. Here’s an example:

Now let’s do some work on story 2639 (aka “Make this system more awesome!”) and check it in. Now we need to make sure that we’re on par with the integration branch by doing a merge. We simply right click the Integration branch and select Merge:

Then merge to the appropriate story branch

Select the latest version to make sure we’re current and hit the button

It appears there are no changes to merge. Excellent, we’re current.

So now we merge our changes from the story to the integration branch (same process, just start by right-clicking the story branch). Also, don’t forget that merges are made as local changes and still have to be committed, so add a check in comment and do just that.

Wait for the integration build to pass and check the acceptance tests pass to let us know that the story is complete. Once it is we can now kill the story branch. To do this, simply right click the branch in source control explorer and select delete!

Again the delete’s are pending changes until we check them in. So again, add a comment and check in the changes.

Our branch hierarchy now changes from this:

to this:

Nice and simple. And not a lot of overhead.

As for the other stories we follow the exact same procedure when they are complete:

1. Make the changes needed for the story in the story branch
2. Pull and merge changes from the integration branch into the story branch
3. Deal with any merge conflicts
4. Check that the story is still OK
5. Push and merge the changes back up to the integration branch. You shouldn’t have any merge conflicts for this merge.
6. Check that the Continuous Integration build passes
7. Run any other tests on the integrated code as required.

And we’re done!

When all stories are complete in the sprint there should be no story branches left. The only time this won’t be true is when the team finished the sprint with incomplete stories.

What About Bugs?

Bugs in an agile team are just the same as stories. Create a bug fix branch each time you need to fix a bug just the same as we do for stories.

About the only time you might not do this is when you are doing really simple bug fixes such as spelling mistakes where the changes are just cosmetic and there are no real logic or functional changes.

What About the Build Server?

So a question you may have is what do we do with builds and the build server? Answer: it’s up to you. Given how short lived the story branches are likely to be it’s probably not worth creating build definitions for each story, but again, it’s completely up to you. Regardless of wether you have a build per story or not, you should have a continuous integration build tied to the integration branch. When each story is complete and merged back to the integration branch a build should be triggered that compiles the code, runs all the unit tests and so forth to confirm that the code in the integration branch is OK and nothing went wrong during the merge.

How Do I Deal With “Mr Stinky” in Scrum?

2011-01-31T10:01:00.001+11:00

On one of the various mailing lists I’m part of this question came up (edited slightly)

Retrospectives teach us to say to team members “I think it would be good to improve such and such for the next sprint”. How about sensitive subjects like “one of the guys speaks in an abrupt manner” or “one of the guys has bad breath”?

Body odour and stink breath, especially for the coffee drinkers amongst us can be a fairly common complaint. If the team has to work closely with someone who has an odour issue then one of the hardest things they have to do with is hide the gagging every time Mr Stinky sits down next to them to discuss an issue. As a scrum master it’s really easy to cop out of dealing with this problem and resort to, “let the team self-manage and figure it out for themselves” but that assumes that they have the skills to do so. In the I.T. industry people are generally not so sensitive to other people’s feelings and leaving this issue alone for too long is likely to turn into a source of conflict within the team. As scrum masters we need to facilitate good team work and step in when required to help resolve this problem.

Having a subject like this pop up during a retro would be really bad for the team. (I’d going to call it a smell/stench in team behaviour, but I apparently exceeded my dad humour quota for this month already). The good thing is that it’s unlikely to happen as you’ll usually hear grumbling from individuals long before anyone on the team brings it up publicly. People usually have more sense than to take the ambush intervention approach – breakfast radio DJ’s excluded. The most common response is for the team to silently isolate the individual instead.

Now personally, I’ve had to have a a few of those body odour/stink breath conversations with people before. Sooo much fun. Not. I feel awkward and nervous and dread the conversation each and every time, but sometimes it just has to be done.

Unfortunately, there’s no “rules for dealing with sensitive personal subjects” in Scrum. You’ll have to rely purely on soft skills and the approach to take very much depends on the personalities involved. The only guidance I can really give is to put yourself in the other person's shoes first and think about how they might best like to be told bad news. For most people that means privately and in a conciliatory, supportive manner. And please, make sure you have enough self-awareness to realise that if you can’t deliver the message that way then you should go to someone else in the organisation who can and get them to step in for you. First port of call being the HR department, assuming your organisation is large enough to have one.

If this is something you’re facing at the moment, then I wish you good luck!

[Ann] Newcastle Nerd Dinner, Jan 20

2011-01-15T13:09:00.001+11:00

A very quick public announcement: there’s a Nerd Dinner happening in Newcastle this Thursday, Jan 20.

Details are on the NerdDinner site so if you’re in the area why not come along. It would be great to see you there.

The Tyranny of OR for .NET Developers

2011-01-10T17:07:00.001+11:00

Over recent times I’ve noticed a handful of people writing blog posts about why they are leaving .NET and the Microsoft platform to move to Ruby on Rails, Python or something other technology. The reasons vary from person to person but the general, recurring memes seem to encompass the following:

1. Microsoft stifles innovation
2. Almost all .NET developers are below average in skill
3. Microsoft means Closed Source. Other choices mean Open Source.
4. Newer technologies are superior to .NET
5. Visual Studio is bloatware and static typing sucks. Dynamic languages and Vim FTW!
6. Corporate development is evil and .NET means Corporate
7. Only in the open source world do people truly understand proper software engineering practices

I’m not going to argue the points since these are peoples personal perspectives and the people who have them are more than entitled to them. However, I also think there are some other unmentioned reasons that people might leave .NET that could be described as one or all of the following:

1. The new languages offer new frontiers to be explored. They like the romance and adventure and opportunity that this offers.
2. Communities in these new languages are pushing themselves to do better and as a result have some great, innovative and creative people in them. They want to be involved in what these people are doing.
3. They love learning and a new language offers many new learning opportunities.
4. Many startups are using the new languages and they prefer to work in the startup culture.
5. Because the new languages are still new, the average developer hasn’t yet heard about them. The ratio of poor developers to competent developers is good. It feels more like an elite club.
6. Switching because it seems to be the cool thing to do. To quote Troy Hunt who I was talking to about this “It’s like all sorts of other social trends where there’s an attraction to being in a minority group”. In other words: “If all those other people are switching then so should I. I might be missing out on something!”

What bothers me is not that people are switching since it’s their choice and well done for having the courage to change, but that these various exodus posts carry a sense that language and platform choice has to be an all or nothing decision. Ah, the tyranny of OR. The idea that you can’t have two seemingly contradictory ideas in place at the same time. Jim Collins wrote about it in Good to Great and talked about it in this interview:

“they get caught up in what we call "The Tyranny of the Or," the belief that you cannot live with two seemingly contradictory ideas at the same time, that you can have change or stability, you can be conservative or bold, you can have low costs or high quality -- but never both. Our visionary companies all operate in what we call "The Genius of the And," the ferocious insistence that they can and must have both at once.”

What happened to taking what you know AND adding more knowledge and skills to it? Are we so limited that we lack the ability to keep knowledge of multiple platforms and technologies in our head at the same time. Do we not know how to evaluate options and pick the right tool for the task at hand? Can we not change the community around us and improve it when we think there are problems?

Why should it be .NET -or- a community that pushes boundaries?
Why should it be .NET -or- Mac/Linux development?
Why should it be .NET -or- Open Source development?
Why should it be .NET -or- A lightweight IDE?
Why should it be .NET -or- Dynamic language development?
Why should it be .NET -or- Learning new things?
Why should it be .NET -or- Code Crafstmanship?
Why should it be .NET -or- skilled coders?
Why should it be .NET -or- a startup/dotcom style company?

Don’t make it a choice of this OR that, make it a case of this AND that AND that other thing AND oh, a bit of that over there.

If you want to switch, go for it, it’s your decision, just don’t be ruled by the Tyranny of OR. Try to embrace the Genius of AND.

Professional Scrum Master Course, Perth, Feb 2011

2010-12-23T11:19:00.001+11:00

Just a quick note letting you know that I’m running a PSM course in Perth. February 3rd & 4th, 2011. If you’re interested in registering then head over to http://scrummastercourse.eventbrite.com/ for the details.

I’d also encourage you to have a look at the details of the Scrum.org PSM course and the curriculum before registering. And before you ask, no, you do not automatically get a certification for just attending.

One Year of Podcasting

2010-12-19T23:11:00.001+11:00

When I announced the Talking Shop Down Under podcast back in February earlier this year I wasn’t really sure what would happen. I didn’t know if I’d be able to find enough people to talk to, wether I could keep up an (almost) weekly broadcast schedule and do it on a shoe-string budget, or even if the show would be interesting enough for people to listen to more than once, and yet here I am at the end of the year having just published the 40th episode for the year and with a slowly growing audience base.

Wow! I’m very, very surprised.

I’m so appreciative of all the guests who have appeared on the show and have had a great time talking with each and every one of them. I’ve also really enjoyed the audience interactions I’ve been having via Twitter, and lately with the livestream broadcast of the recordings.

This last one is something I’d like to try more of. It’s obviously much rawer than the edited episodes, but I think having you listening in live while an episode is being recorded gives you a much greater chance to hear the questions asked that you want asked, not just whatever pops into my head at the time, so keep an eye on the @talking_shop twitter account and when an episode is recording feel free to ask questions via the chat room. We may even try for some dial-in talk-show style interactions in the new year.

Anyway, here’s some stats for those who are interested. As a note it’s always hard to know just how many people listen because subscribers to the feed and episode downloads don’t always mean the show was listened to, plus the download stats from archive.org (where I host episodes) seem to update at random times and not very often at that.

Subscribers:

The show is sitting at around 250 people who follow the feed and as you can see, the number of listeners has steadily grown throughout the year. Those little blue spikers are when people are downloading/listening to the mp3 file.

Most shows get around 300-350 listeners an episode, with the largest number so far being 700+ for the Scott Barnes/WPF is Dead episode, and next being the WebForms MVP episode with Tatham Oddie.

As would be expected, most people who follow the show are from Australia, which is to be expected since that’s the audience I’m targeting. The next 4 countries of the top 5 subscribing nations are:

United States
United Kingdom
Belgium
Mexico

And finally, for the curious, more people listen to the show via the RSS feed than they do from ITunes (though it’s a close run thing).

So if you’ve been a regular listener this year then I tip my hat to you and say THANK YOU!

P.S. Suggestions for guests and other show ideas are always welcome.

A (not so serious) C# 5.0 Language Suggestion

2010-12-14T12:05:00.001+11:00

Occasionally I run across less then optimal code as part of my day-to-day work, as do most people who deal with legacy code bases. Even if your code is pure as the driven snow, if you’ve ever spent any time looking at the Code Snippet of The Day on the Daily WTF then you’ll have seen this sort of thing before:

           for (int i = 0; i < 200; i++)
            {
                try { someCollection.RemoveAt(42); }
                catch { }
            }

Yes, it’s the classic Try, Catch, Swallow pattern in action. If there’s a problem in there, we put our hands in the air like we just don’t care.

So today one of my fellow Readify colleagues, Ivan Hamilton, suggested a new keyword be added to C# 5.0 to help all those developers out there who are constantly writing this sort of thing. Behold the OBVLIVIOUS keyword!

           for (int i = 0; i < 200; i++)
            {
                oblivious { someCollection.RemoveAt(42); }
            }

Sheer genius! That code exhibits the same behaviour and is now so much more readable!

If you were on the C# team, what syntactic sugar would you add to the language?

Udi Dahan at Sydney Alt.Net

2010-12-01T08:41:00.001+11:00

Last night at the Sydney Alt.Net group we had Udi Dahan for an open Q&A session where he talked about systems design and NServiceBus. The session was live streamed at the time, and the now the recording is available for posterity.

Watch live streaming video from rbanks54 at livestream.com

Enjoy!

And don’t forget to subscribe to the ozalt.net mailing list to stay in touch with other Aussies in the community wanting to improve the way they develop software and work with .Net as well as keeping up to date with other happenings at user groups around the country. There’s also a set of RSS feeds on the main ozalt.net site you may find useful to keep in touch with other alt.net bloggers in Australia.

Needless If Statements

2010-11-30T12:11:00.000+11:00

I was looking through some code today and came across this:

context.HttpContext.Response.Clear();

if (ImageFormat.Equals(ImageFormat.Bmp))
    context.HttpContext.Response.ContentType = "image/bmp";
if (ImageFormat.Equals(ImageFormat.Gif))
    context.HttpContext.Response.ContentType = "image/gif";
if (ImageFormat.Equals(ImageFormat.Icon))
    context.HttpContext.Response.ContentType = "image/vnd.microsoft.icon";
if (ImageFormat.Equals(ImageFormat.Jpeg))
    context.HttpContext.Response.ContentType = "image/jpeg";
if (ImageFormat.Equals(ImageFormat.Png))
    context.HttpContext.Response.ContentType = "image/png";
if (ImageFormat.Equals(ImageFormat.Tiff))
    context.HttpContext.Response.ContentType = "image/tiff";
if (ImageFormat.Equals(ImageFormat.Wmf))
    context.HttpContext.Response.ContentType = "image/wmf";

You’ve all seen this sort of thing before, right? And no doubt it’s cousin, the switch statement, is also very familiar to you.

The problem with that this sort of thing is that those if statements just aren’t required. For amusement and/or education, go have a look at the Anti-If campaign to get a more detailed view as to why If statements are undesirable.

so when you see this sort of thing, take the few minutes you need to refactor your code to something like the following:

var contentResponses = new Dictionary<ImageFormat, string>()
                     {
                         {ImageFormat.Bmp, "image/bmp"},
                         {ImageFormat.Gif, "image/gif"},
                         {ImageFormat.Icon, "image/vnd.microsoft.icon"},
                         {ImageFormat.Jpeg, "image/jpeg"},
                         {ImageFormat.Png, "image/png"},
                         {ImageFormat.Tiff, "image/tiff"},
                         {ImageFormat.Wmf, "image/wmf"}
                     };

context.HttpContext.Response.Clear();
context.HttpContext.Response.ContentType = contentResponses[ImageFormat];

You’ll have fewer lines of code and the person who next looks at your code will appreciate it.

How to Build Linux Code with TFS 2010 Team Build

2010-11-23T19:34:00.001+11:00

With the release of Team Foundation Server 2010 and Team Explorer Everywhere Microsoft extended the reach of TFS beyond just the Microsoft ecosystem and provided a way for people doing Linux and Mac development to use TFS to meet their Application Lifecycle Management (ALM) needs.

Whilst TFS works great for source control and work items for Linux development it doesn’t include a Linux specific build agent so many people think it can’t be done. But that’s not quite true. And yes, before people point out the obvious, there are a number of excellent Linux specific build engines that can do automated builds from TFS source by calling the tf command line, but they don’t integrate into TFS in anywhere near the same way that Team Build does which is why Team Build a desirable option for many places.

Anyway, back to the issue at hand, thanks to tools like PuTTY we can do remote shell calls to Linux boxes as part of the build process, and you we can also copy files to and from the Linux box as part of the same process which gives us the ability to compile on Linux and still get the compiled binaries placed in the drop location as per normal windows builds.

For example I have a customer at the moment who is moving their Progress source code (yuck!) out of Roundtable and into TFS, and as part of that transition we’re moving the build from a custom set of shell scripts into Team Build. Without going into the specifics of their particular needs, let’s have a quick look at some of the key ingredients needed to get Team Build successfully executing commands on a remote Linux server.

Install and Configure PuTTY on the Windows Build Agent

As mentioned before we’re going to use some of the PuTTY tools to connect to the remote Linux box. If you haven’t already done so, go grab the Windows PuTTY installer from the download page and install it on your build server.

Now we need to configure PuTTY so it knows how to connect to the remote server. We’re going to use SSH to do this, and since we don’t want to store passwords in our build scripts we want to use a public key for authentication.

Login to your build server using the build service account. Note: This is important! If you don’t do this then you will likely have issues the first time you run a build as ssh will prompt the first time you use a public key for authentication and the build will hang waiting for a response.

Now open a command prompt, go to the install folder for PuTTY and run puttygen.exe. A dialog will appear.

Click Generate and move the mouse around a little as requested (such fun!) until you get a key generated.

Note that we’re intentionally leaving the passphrase blank so that we don’t get prompted for a password during the build process. This of course means there is a potential security hole if someone attacks the windows build agent machine, so make sure that the account you will log in to on the Linux box is not a privileged account. Save both your public and private keys.

Next, login to your Linux box and open the $HOME/.ssh/authorized_keys file in vim and paste in the public key as a new entry in that file, then save the changes, close the file and log off.

Now to test it and get through that first configuration prompt.

From your windows command prompt run plink to do a listing of your home directory on the Linux box. For example:

plink –batch –ssh –i privateKey.ppk linuxBuildAccount@linuxServer “ls –l”

When prompted to store the key answer with a “y"es. Once that’s been done once we won’t get asked again when we run automatic builds.

Assuming this works, and you see something coming back then we’re right to move on.

Customising TFS Team Build to Build on Linux

From here it’s pretty simple and works much the same as the customisation for VB6 builds I’ve posted about in the past. This won’t be a complete blow-by-blow on how to do it – just enough information to cover the important parts you need to know.

For all the remote Linux interactions we’re going to rely on the InvokeProcess workflow activity to make the calls we need for our build process.

As a note, I usually take the existing Default Process template and gut it – removing most of the activities from after the workspace has synced (i.e. the get latest section) and the code has been pulled down to the build agent and use that as a starting point for building up the Linux build process.

Regardless, once the code has been pulled down into the build agent’s workspace we have two choices for making the source available to Linux. We could define a network share that points to the build agent’s $(Sources) folder and get Linux to build the sources using a UNC path (via samba), or alternatively we could use PuTTY’s pscp command to copy the sources to the Linux machine for local compilation and copy the compiled output back when the build completes. You should do whatever you are more comfortable with, and since both have pros and cons it will be a matter of how your Linux build works that dictates the best approach.

For this example let’s do a copy of code onto the Linux box and then call the compile.

Begin by dragging an InvokeProcess activity into your build process workflow at an appropriate point:

and set the properties of it as follows

FileName: """" & Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86) & "\PuTTY\pscp.exe" & """"
Arguments: "-batch -scp -i """Path\to\\privateKey.ppk"" “ & SourcesDirectory & “ linuxBuildAccount@linuxServer:/build/sources"""

Don’t forget to check for error conditions when the task completes.

Next drag another InvokeProcess activity into your workflow and this time use plink instead of pscp and call the command or script you need to do the compile. The following activity properties show an example:

FileName: """" & Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86) & "\PuTTY\plink.exe" & """"
Arguments: "-batch -ssh -i ""Path\to\privateKey.ppk"" linuxBuildAccount@linuxServer ""<command to run – e.g. make all>"""

Again, don’t forget to check for errors.

Finally when the build is done use another InvokeProcess activity to call pscp as shown above and copy any compiled output to the drop location. For reference the drop location folder can be found using the BuildDetail.DropLocation property.

Hopefully this is enough to get you on your way to building your Linux applications via TFS 2010’s Team Build. Good luck!

How to Use CodedUI Tests, Watin and MTM Together

2010-11-08T16:45:00.002+11:00

A customer I’m working with has placed a heavy investment in Watin testing over the years and with a recent move to TFS2010 they also wanted to take advantage of the new Microsoft Test Manager (MTM) feature and the ability to associate automated tests to test cases in MTM. Here’s a quick how-to for those of you wanting to do the same thing.

Create A Test Case

First up, let’s create a test case:

Pretty simple – open browser and check the url in the address bar. What I have also done with this test is use parameters to supply the data allowing testers to decide what values they want to test with. This is better than the devs doing this, plus it makes for a much nicer UI for data driven tests than excel or CSV files do.

Create The CodedUI Watin Test

Next we need to create the automation for this test.

Add a Coded UI test class to a test project but don’t go create any tests via the wizard that appears. Just press cancel and then go to your test code and add a normal Watin test as per usual. Oh, if you’re a person who normally deletes all that TestContext stuff, then you’ll need to leave it in place this time around – don’t delete it.

Here’s an example:

using Microsoft.VisualStudio.TestTools.UITesting;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using WatiN.Core;

namespace CodedUITesting
{
    [CodedUITest]
    public class CodedUITest1
    {
    ...
    [TestMethod]
    [DataSource("Microsoft.VisualStudio.TestTools.DataSource.TestCase",
 "http://tfs2008-vm:8080/tfs/TemplateTrials;Scrum v5",
 "101", DataAccessMethod.Sequential)]
    public void RunWatinTestParameterized()
    {
 var url = TestContext.DataRow["url"].ToString();
 var result = TestContext.DataRow["result"].ToString();
 using (IE ie = new IE(url))
 {
  Assert.AreEqual(result, ie.Url);
 }
    }
}

The things to note in this test are that the data source attribute is used to pull data from the TFS Test Case work item – specifically the URL of the team project is included, as it the test case id.

In the test itself we pull data from the parameters in the test case using the TestContext.DataRow[“parameter'NameHere”].ToString() calls, and the rest is just normal Watin code.

If you have any issues with missing references make sure you reference Watin and Interop.ShDocVw and that both get copied to the output folder as part of the build.

Attach the Automation

The only thing we need to do once we have this test is to link it to the test case as it’s automation method. Open the test case in Visual Studio, navigate to the Associated Automation tab and click the […] button to select the method. You should see something like this once it’s done:

Run The Test

Assuming you have a lab environment with test agents installed you should then be able to trigger a new build and when it’s complete start an automated test run for that build and see everything working as you would expect.

Here’s a result from a run on my local TFS server:

I hope this helps!

How To Stop Users Creating Work Items In TFS

2010-10-28T16:24:00.001+11:00

I regularly get asked if there is any way to prevent users creating certain types of work item in TFS – the most common scenario being stopping people who are using the work item only view from creating anything other than bugs.

TFS still doesn’t let me hide blocked work item types from the users in the first place, but I can at least prevent users creating new work items of a certain type, which is a nice workaround.

Here’s how:

1. If you haven’t done so install the latest Team Foundation Power Tools for your appropriate TFS version. If you are on TFS 2010 you’ll want the TFS 2010 September release.

2. Start Visual Studio and use the Process Editor to open the work item type you want to edit

3. Go to the workflow definition for the work item type and find the initial transition – it will be the one where the workflow moves from a blank state to an initial state:

4. Double click the transition and in the properties locate the Transition Detail tab and the “Not” field. This field is used to exclude users or groups from being able to use this transition, so set the value as appropriate. In the example I am excluding a dummy user from a local VM I have.

5. Publish the work item type back to your TFS server and refresh team explorer to pick up the changes.

Done!

Let’s check it. Connect as a blocked user and try and create a work item – in my example I excluded my dummy user from bugs. Initially I see that I need to supply the Title, just as I had to before:

However, once I supply a title I now see the following:

Notice that now the State field is showing as required, but I am now unable to set the state to a valid value which effectively prevents me creating the work item type.

Hopefully that helps.

Why does Git Merge Work Better than TFS Merge

2010-10-22T16:32:00.001+11:00

The question came up during a discussion on our internal mailing list as to why Git’s merge is seen as better than the TFS merge. What better way to explain it than via a worked example:

TFS Example

Consider the following solution in TFS:

Now let’s branch it for two different teams. Team A and Team B.

Now let’s go into TeamA’s code and refactor SomeClass to have a better name. Here’s the changeset that gets created. Note that we’ve changed the .csproj and Program.cs as well since they both had references to SomeClass.

Meanwhile TeamB adds an extra property for some functionality they are adding:

Team A then merges back to trunk. When merging in Visual Studio you can only merge between branches that are directly related to each other.

Team B then wants to merge to trunk, but as Team A checked in first, they decide to follow good practices and pull down the latest changes from Trunk and merge them first. Because the SomeClass file was renamed we now have a merge conflict as seen here:

And until we fix it our solution is broken.

Visual Studio asks us what we want to do with the file name and we need to figure out what the right option is. Giving choice like this to the user is unnecessary and can easily result in a big mess.

Git Example

Let’s do the same thing using git. We start by creating a new project and making the two team branches. Note how the branches all point to the same commit instead of creating copies of all the files.

Now let’s refactor the TeamA code and add the property to TeamB as we did with the TFS example and commit the changes. We see the branches now have some changes and are diverging from each other.

Now let’s merge the TeamA changes to TeamB. For consistency with the TFS example we’ll do it by merging TeamA to master, and then master to TeamB

Note that the merge from TeamA to master is a fast-forward merge. This happens because trunk hasn’t changed since TeamA branched so master can just be repositioned to the TeamA commit..

You can see that in the second merge from master to TeamB an auto-merge occurred, and git automatically detected that the changed SomeClass.cs file and the new SomeBetterName.cs file are actually the same file (with an 84% certainty), so it performed a rename for us automatically.

When we reload the solution in Visual Studio, everything looks fine, and we can get on with our development activities. Here’s what it looks like in the repository viewer:

As a note, with git we don’t have to go via the master branch to merge TeamA changes to TeamB, we could have just done git merge TeamA as shown here:

For reference, you don’t have to merge from TeamA to TeamB via Trunk in TFS either. TFS has a baseless merge option that you can run via the command line, though when you do the branch history can get a little messed up.

Here’s hoping that the next version of TFS will have a much better story around rename detection and version control in general.

Visual Studio and Deja Vu

2010-10-16T13:11:00.001+11:00

This a post about fonts, not echoes of memories, just in case you’re wondering. Now, let me say from the outset that I like Consolas and think it’s a great font, but almost everyone I know who uses Visual Studio does so using either it or one of the other fixed width fonts supplied with windows.

Given that the font is the thing I spend most time looking at, I wanted something a little different from the norm and that my eyes liked better so when I came across the Deja Vu font via Twitter I thought I’d give it a try. And I must say, I’m very happy with it. Here’s a screenie of it in action:

As you can see it’s got dotted zero’s, good fixed width (mono spaced) characters, is sans serif and has quite a different look to Consolas, shown here for comparison

Oh, if you’re wondering, that colour scheme is the “Easy on the Eyes” theme from StudioStyles, but with a light coloured background instead.

As a note I’m also using DejaVu for my command prompt font as well:

Note that there’s a trick to getting other fonts in the command prompt these days, which I only ran across recently when looking at the Meslo font, which for reference looks like this in Visual Studio:

As you can see, Meslo is similar to DejaVu in overall style but the characters are a tad wider, punctuation characters are bolded and the line spacing is a little larger as well. I’m happy to stick with DejaVu.

What about you? Are you still using the defaults or have you given your settings that personal touch? Feel free to post a comment with a link to your font of choice.

Is The Way Hiring Happens Changing?

2010-09-20T21:54:00.001+10:00

For those who don’t know (or just plain forgot) I run a weekly podcast for developers at http://www.talkingshopdownunder.com and in one of the episodes I talked with Matthew Wills about an idea I blogged about – the Developer Experience Index and wether we need one or not to improve the way we find and hire talent and raise the general skill level of the industry.

Interestingly I just ran across an opinion piece on GigaOm about the way hiring is changing and wether resumes are headed the way of the dodo - http://gigaom.com/collaboration/the-future-of-work-wont-contain-resumes/

It’s worth having a read, and most interestingly talks about the social networking aspects of hiring and how LinkedIn and your online presence in open source efforts can be a reflection of how well respected you are and wether you’re a good potential hire or not.

I still don’t think we’re there yet, but the aggregation of social networking information into a ranking of some kind is a very interesting approach to finding people, though likely will tend to favour those with the best connections or most popular projects, not necessarily the best developers for your team. Still, if nothing else, it reflects passion and involvement, and without passion for what they do a developer is pretty much worthless.

How To Fix Branches After Migration to TFS2010

2010-09-15T13:50:00.001+10:00

Let’s say you’ve just migrated your code from another version control system to TFS2010 by grabbing the old code, copying it into your workspace as is, and then checking it in to TFS as a single massive import. It’s a really easy and common way to do tip migration.

When you do this, you will notice that all your branch relationships are missing and source control will look something like this:

The old system had Trunk branched to Feature X and Version 1, etc, but now there’s no relationships and trying to merge from Trunk to a branch brings up a dialog with no targets.

Bummer, huh? Yeah, but what did you expect would happen? You’ve just imported a bunch of folders from the file system and TFS has no way of knowing that they’re branches.

We need to let it know which folders the branches are and the relationships between them. Here’s how we do it:

Step 1: Convert Folders to Branches

Right click the trunk folder (or whatever your root branch folder is) and convert it to a branch.

It should now look like this:

Do this for all the other target branches you have. e.g. Feature X and Version 1.

Step 2: Perform a Baseless Merge

Next, perform a TFS baseless merge to establish a relationship between the parent branch and the child branches. Don’t worry about the contents, we’re only going to merge the folder, not it’s contents.

TFS baseless merges are performed via the command line, so open up your VS2010 command prompt and do the following:

cd <workspaceFolder>
tf merge /baseless <trunk> <childBranch>

Check in your pending changes.

Step 3 Reparent Child Branches

At this point we have a loose link between the branches but the relationships are still not finalised. We need to fix that.

Select your child branch in Source Control Explorer and from the File menu choose Source Control –> Branching and Merging –> Reparent... NOTE: This is not available via the context menu in Source Control Explorer.

In the dialog box, choose the appropriate branch as the new parent. There generally should only be one, unless you have done multiple baseless merges.

Now look at the properties of your child branch and you should see something like this:

Excellent! If you go to your Trunk branch and in the branch context menu choose View Hierarchy. You should see something like this:

Brilliant. Now we’re all done. You can carry on using TFS as you normally would.

Enjoy!

Aw, Snap! (or How I got Hacked)

2010-09-13T23:04:00.001+10:00

So there I am surfing the web and catching up on some blogs and news when I notice my Skype icon blinking away at me in the windows taskbar. Hmm, someone’s sent me an IM, thinks I only to discover that Skype logged me out.

That’s weird I say to myself. I guess I’ll just log in again. Click. What? Invalid login? Hmm. Try again. Click! Click!! Click!!! Dammit! What’s going on. Oh look – I just got an email. It’s from Skype.

Aw, Snap!!! (or insert expletive of your choice).

Yes, my Skype account had been hacked and on gaining entry the attackers had immediately changed the account password and email address on me, blocking me out.

Long story short, the good news is that after immediately contacting Skype they restored my account to me (thank you!!) in less than 2.5 hours and it only cost me a few euro in Skype credits and a few hours of panic. Yet the whole thing was entirely preventable.

But How?

So the obvious question: how did it happen? Simple – I was stupid and lazy and forgot some of the basics of online security. Doh!

You see, when I’d first used Skype years and years ago, it was way back in it’s early days and at that time I used an insecure password. It was a dictionary word of all things – I know! I know! You don’t have to tell me! But because I was just trying the thing out I figured that if it was useful then I’d go back and change my password later on. At the time I’d also clicked the auto-login option and let Skype sign itself in for me.

Unfortunately, because I never used it much early on I never went back and changed the password, and over time forgot what it was. Kind of like when we tell ourselves we’re going to write those unit tests once we get this code working. The reality is that we get distracted or do something else, forgetting to go back and clean up after ourselves. As the saying goes, the road to hell is paved with good intentions.

Of course, at any point I could’ve done the “I forgot my password” routine, but as Skype kept logging itself in, I just forgot about it and fixing the password drifted to the bottom of my “stuff I should really do to be a good human being but that I’ll likely never get around to doing because I’d rather be sleeping or eating or having s..” well, cough, ahem, you get the idea.

Using a real word for a password all those years ago and not taking the one measly minute needed to fix it is pretty lazy of me, huh? Yet so many people do it. And it could’ve turned out so much worse. Thankfully that password wasn’t used anywhere else, so I didn’t have to worry about the hackers using that to break into other accounts of mine.

Of course, what irks me most is that these days I use KeePass and I’ve even blogged about it in the past (though I now use DropBox instead of Mesh for syncing), and I’ve read plenty of tales in the past of accounts being hacked and how easy dictionary based attacks are to pull off. And yet here I am. A victim. Grrr. Dumb, Richard. Dumb!

So what are my lessons? What do I learn from my dumbicity?

1. NEVER. Not ever. Not even on my deathbed will I use a weak password for anything. Even if it’s a throw away account to register for some software trial that I’ll never use again. I have Keepass and it can generate passwords for me that are safe.

2. Never reuse passwords across sites. Once a password is compromised on one site it’s compromised everywhere.

3. Keep my OpenId accounts extra secure. If I lose an OpenId account I’d be really messed up, especially as these days the use of OpenId is increasing and more and more sites are accessed only via OpenId accounts.

4. Go and change all those other passwords I have just in case. I can’t think of how many other sites I’ve used over the years that I no longer visit and where I may have old passwords laying around. If one of those sites was compromised and I’ve reused that password elsewhere and not realised it, what else can the attackers get to?

So, enough beating myself up about this. I’ve learned my lesson. Hopefully you can learn from my mistake as well and avoid being a statistic like me.

TechEd Australia 2010

2010-08-31T15:16:00.002+10:00

I’ve been quiet the last few weeks due to TechEd Australia coming up and my need to actually put together a session that flowed nicely, as well as getting through all the usual client work and so forth that was needed. Well, actually I was quiet on the blogging front, my tweeting continued as per usual (140 characters doesn’t take much time to bash out).

Yet again, TechEd Australia was a great personal experience for me. I delivered my unit testing session and got some great feedback (thanks to everyone who attended and put in an eval!), I also managed to record 5 episodes for the Talking Shop Down Under podcast, did plenty of networking, including meeting the DotNetRocks guys as well as a bunch of other people I knew only via twitter, and I even attended some sessions and learnt some stuff.

For those interested, Microsoft should soon make my session available online and I’ll update this with the location once it goes live.

Update: The recording will be up at: http://www.msteched.com/2010/Australia/DEV362

The Developer Experience Index

2010-08-09T22:18:00.002+10:00

I’ve been musing on developer skills, certification rorts, hiring, and a whole lot more recently and I’ve been thinking that it’s about time we had something akin to the Windows Experience Index, but for developers – what I’ve whimsically titled the Developer Experience Index. A representation of a persons skills and abilities in various areas of development and maybe some way of rating them overall as a developer.

Because my thinking on this is still solidifying, instead of writing down all my thoughts and having a long rambling post that gets misunderstood, I’d instead love for you to have a listen to Episode 24 of Talking Shop Down Under and get a feel for what I’m really talking about. It’s only 24 minutes so it won’t take forever to listen to.

I’m after feedback and thoughts on this to decide if it’s worth pursuing, so even if you don’t subscribe to my awesome podcast (and why not!?), have a listen to this episode and see what you think. Even better, spread the word about it so that others can talk about it as well and we can get some conversation happening.

Would you be willing to contribute to such a community? Would you be willing to go through a community certification process? If you are in a position to hire people, would you rather interview people who are rated well by their peers or those who are certified by an organisation that makes money from people attempting certification exams? Am I completely bonkers and this is a really dumb idea? Let me know

P.S. For those wondering (and who haven’t yet listened to the episode) I am aware of the Java Black Belt exams, and while that’s a good approach and shows the potential of this, it’s not quite what I’m after.

How to Build VB6 Apps with TFS Team Build 2010

2010-08-08T22:53:00.001+10:00

So you’ve got yourself a nice, shiny, new TFS 2010 server and you’re using its build automation features to build your .NET code but you also have some, shall we say it, “legacy” VB6 code laying around that you have to keep alive. You’ve retired source safe and installed the MSSCCI provider TFS 2010 so TFS is your source repository but now you want the build server to build your VB6 code just like it does for your .NET code.

Here’s how to get VB6 applications built using TFS 2010:

Preliminary Steps

1. Go to your build templates folder in source control and make a copy of DefaultTemplate.xaml. Call it VB6BuildTemplate or something similarly memorable.

2. Open up the new template and find the “Compile the Project” activity sequence. For reference it’s roughly located in “Compile, Test and Associate Changesets and Work Items” > “Compile and Test” > “Compile and Test for Configuration” > “If BuildSettings.HasProjectsToBuild” > “Compile the Project”

3. Find the “Run MSBuild for Project” activity and delete it. We’re going to replace that with our own tasks.

Ensure the Output Directory Exists

When you that MSBuild activity runs to compile your .NET projects the output locations are created for you automatically but since we’re not using MSBuild we don’t have that luxury for our VB6 compilations so we have to create the folder ourselves.

Start by dragging an “If” Activity into the sequence

Then drag a CreateDirectory task (from Team Foundation Build Activities) into the “Then” section as shown

Now the point of this is to check if the outputDirectory has already been created and to create it if it hasn’t.

Set the Condition for the If Activity to: Not System.IO.Directory.Exists(outputDirectory).

Set the Diirectory property of the createDirectory to outputDirectory

For maintainability, rename the activities in the designer as well so that you can better understand what is happening.

By the way, if you are sure the directory doesn’t get created earlier in your process then you can drop the if activity and just place the createDirectory activity into the flow directly.

Ensure a Log Directory Exists

When we run the VB6 compiler in a build we need to capture the log output to a text file otherwise VB will want to try and open a dialog box telling us there was a compiler problem and want us to click OK. Unfortunately when running unattended, there is no UI and we will never see a window to click the link on.

We’re going to place our log file output in the drop location so that we can easily access it once the build is complete.

Create another if task (or copy/paste) from the previous step and ensure that we use logFileDropLocation instead of outputDirectory.

Call the VB6 Compiler

Now drag an InvokeProcess activity into the workflow and set it up as follows:

DisplayName	VB6 Compiler
FileName	Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86) + "\Microsoft Visual Studio\VB98\VB6.exe"
Arguments	"/make """ + localProject + """ /out """ + logFileDropLocation + "\vb6.log"" /outdir """ + outputDirectory + """"
Result	VB6Result

Note that the VB6Result variable will likely to show up with a warning until you create it as a variable in your workflow. So on the workflow create the variable with a type of Int32 and a scope of “Compile the Project”

If you wish, you can also send stdOutput and errOutput from the InvokeProcess tasks to the build log using the WriteBuildMessage and WriteBuildWarning tasks. For each of these use the appropriate std/errOutput variables as the values for the Message property, though with the VB6 compiler you’re unlikely to see any messages since we’re sending output to the log file.

The workflow should now look something like this:

Check the Compiler Result

Finally we need to check if the compile passed or not. If it fails we will get a non-zero result back from InvokeProcess

If we don’t check this then the build process just assumes things work and continues on it’s merry way. so add another “If” Activity to the flow and in the Then part add a “Throw” Activity from the Error Handling group. Set the Throw Activity’s Exception property to “New Exception” and the Condition on the “If” activity to “VB6Result <> 0”.

Don’t forget to rename the activities to help you diagnose any problems.

Use It in a Build

Finally, save your workflow, check it in to source control (in the BuildProcessTemplates folder) and then create a build definition using the new template.

Trigger the build and check the compilation results. Everything should now work as expected. Now all you need to do it retire that VB6 code :-) Good luck with that!

Mocking Comparison – Part 12: The UnMockables

2010-08-06T08:35:00.001+10:00

The frameworks we’ve been looking at in previous parts only work well when they can override the properties of the classes you wish to mock, or when you use interfaces. So what happens when you need to deal with a test that is time dependant, or if you want to verify data being written to the console or you have to deal with SharePoint or other similar products that are a dogs vomit of static classes, sealed types and leaky abstractions that make testing with them almost impossible using normal techniques?

The answer is to move away from regular mocking frameworks and use tools like TypeMock Isolator, Microsoft Moles or Telerik Just Mock (as a note, I don’t have a copy of JustMock so I’m going to leave it out of this series)

DateTime.Now

So let’s say you’ve got a class that references DateTime.Now and changes behaviour based on the time of day. How do you test behaviour correctly and more importantly,how do you do this reliably? You can’t really mess with the system clock. The trick is to intercept the call to DateTime.Now and provide your own method that gets called instead, and this is what TypeMock and Moles both allow you to do.

TypeMock

Here’s the basic code for mocking out DateTime.Now with TypeMock

readonly DateTime dateToUse = new DateTime(2010, 07, 17, 8, 0, 0);

[Fact]
public void Isolate_current_time()
{
 Isolate.WhenCalled(() => DateTime.Now).WillReturn(dateToUse);
 Assert.Equal(dateToUse, DateTime.Now);
}

Pretty simple stuff.

If you wanted to provide a method implementation rather the just returning a value you would replace the .WillReturn() call with .DoInstead()

So let’s see what this looks like in a test. Once again, this is somewhat testing the mock which you shouldn’t do in the real world, but it does show you what the syntax is like, which is the goal after all.

Oh, as a reminder the relevant code from the class under test is as follows:

public void CleanMonkey()
{
 // <snip!>
 if (AssignedMonkey.IsAwake(DateTime.Now))
  AssignedMonkey.Clean();
}

So in our test we are going to set the mock to only return true if the time passed to the IsAwake method matches our specific date time. In other words, we should see that DateTime.Now is returning the value we specify, not the current time.

[Fact]
public void Isolate_monkey_should_be_awake()
{
 Isolate.WhenCalled(() => DateTime.Now).WillReturn(dateToUse);

 var monkey = Substitute.For<IMonkey>();
 monkey.CurrentFleaCount().Returns(20);
 monkey.IsAwake(Arg.Is(dateToUse)).Returns(true);

 var keeper = new ZooKeeper();
 keeper.AssignedMonkey = monkey;

 keeper.CleanMonkey();

 monkey.Received().Clean();
}

And as expected, this test works. Now the keen eyed amongst you will see that I’m actually mixing TypeMock Isolator and NSubstitute in the one test. I’m using Isolator to mock out the static DateTime.Now method and NSubstitute to create the mock monkey object.

Also, in terms of running, the tests there’s a few little changes to the tests and things take longer because Isolator is injecting itself in your code. The other thing to note is that DateTime is part of the Base Class Library and TypeMock doesn’t support all of the methods in the BCL, just certain methods so if you want to mock out a method Isolator doesn’t support you’re on you own.

Mircosoft Moles

Moles is a framework that is usually obtained with the Pex download from Microsoft Research, but it’s also available in a standalone form.

Moles is still very much a product with some rough edges. I’ve had moles randomly stop working with the only fix being an un/reinstall at times.

Now the good thing about Moles is that it can replace the method call for anything you want. No limitations at all, however the way it does it is to inspect the assembly you want to mock and then it generates a separate buddy library that provides a way to mock out or stub the method calls you are interested in. It’s fine when working with things like mscorlib or other assemblies that don’t really change, but if you’re applying it to your own libraries and they change method signatures regularly then you will need to regenerate the moles assemblies each time which is a pain.

The following code is using the Moles.Xunit extension to run the tests you can’t just run the tests via TestDriven.Net like you can with Isolator – you need to call the tests via the Moles TestRunner. I use a batch file as follows to help with this:

cd c:\MyCode\bin\debug
"C:\Program Files (x86)\Microsoft Moles\bin\moles.runner.x86.exe" Monkeys.Moles.Tests.dll /runner:c:\path\xunit-1.5\xunit.console.x86.exe /x86 
pause

You’ll also need to update assemblyinfo.cs to include attributes that tells Moles which methods you are using like so:

[assembly: MoledType(typeof(System.DateTime))]
[assembly: MoledType(typeof(System.Console))]

And once that’s in place finally you can write a test as follows:

[Fact]
[Moled]
public void Replace_current_time()
{
 MDateTime.NowGet = () => dateToUse;
 Assert.Equal(dateToUse, DateTime.Now);
}

[Fact]
[Moled]
public void Monkey_should_be_awake_for_cleaning_at_eight_am()
{
 MDateTime.NowGet = () => dateToUse;
 var monkey = Substitute.For<IMonkey>();
 monkey.CurrentFleaCount().Returns(20);
 monkey.IsAwake(Arg.Is(dateToUse)).Returns(true);

 var keeper = new ZooKeeper();
 keeper.AssignedMonkey = monkey;

 keeper.CleanMonkey();

 monkey.Received().Clean();
}

So here you may notice that we have an extra attribute on our test method to indicate that this test method uses Moles. In addition we provide a lambda to MDateTime.NowGet instead of DateTime.Now. This is the method in the buddy assembly that gets called when DateTime.Now is referenced. Also, the method naming for Moled types gets a bit funny. Methods are named based on the method you are mocking and then either a list of types based on the method being called or a Get/Set for properties. It works, but it’s a little clunky.

Conclusion

So, my preference here from a syntax viewpoint is the Isolator syntax by far, though the fact that it can’t get to everything in the BCL (such as Console.WriteLine) and that it is a commercial product takes the shine off a little. On the flip side I like the power of Moles but it’s very clunky to work with, breaks easily and is a pain to use when the target assembly changes a lot and the price and power doesn’t offset this problem.

That’s All Folks

And that, my friends, is that for this series.

I hope you’ve enjoyed it and have a good idea of what the various frameworks are capable of. If you haven’t already guessed, my new favourite framework is NSubstitute. If you haven’t already, go give it a try and see what you think and give feedback to the guys that wrote it on the NSubstitute mailing list.

Happy testing!

Other posts in this series:

Mocking Comparison – Part 11: Multiple Interfaces

2010-08-05T23:00:00.001+10:00

Continuing with our comparison of Rhino Mocks, Moq and NSubstitute we have a look at a little used feature in mocking being the ability to generate mocks that implement multiple interfaces.

Why would you do this though? Well, that’s a good question. Simple example would be when your class under test expects and object to implement interface X and also implement IDisposable. It doesn’t happen often, but when it does it’s nice to know the facility is there.

What you’ll see in all the examples is that the mock natively implements a main interface and that to do any interactions with the methods of the second interface requires casting of the mock to that interface.

For the purposes of the code we’re going to pretend that the monkeys of our little zoo are self managing, can act as ZooKeepers and can thus look after themselves. It’s silly, but it shows the syntax.

Rhino Mocks

The thing to note here is that we can’t use GenerateStub here. We have to use GenerateMock, which then means we don’t get automatically backed properties, so we have to set them up ourselves as well.

[Fact]
public void Rhino_multiple_interfaces()
{
 var monkey = MockRepository.GenerateMock<IMonkey, IZooKeeper>();
 monkey.Stub(m => m.Name).PropertyBehavior();
 ((IZooKeeper)monkey).Stub(k=> k.AssignedMonkey).PropertyBehavior();

 monkey.Name = "Spike";
 ((IZooKeeper)monkey).AssignedMonkey = monkey;

 Assert.Equal("Spike", ((IZooKeeper)monkey).AssignedMonkey.Name);

 Assert.IsAssignableFrom<IMonkey>(monkey);
 Assert.IsAssignableFrom<IZooKeeper>(monkey);
}

You can also see that we have to cast monkey to IZooKeeper every time we want to do something on the IZooKeeper interface. Annoying, but that’s the way it goes.

Moq

The code here is a little different in that we create the mock the normal way, and then add a new interface to it after it’s already created using the .As<T>() method.

Also, when we set up the property behaviour on the IZooKeeper interface we have to go through some ugly casting and the use of Mock.Get() because of the way Moq separates the Mock and mocked object instances. Blech.

[Fact]
public void Moq_multiple_interfaces()
{
 var monkey = new Mock<IMonkey>();
 monkey.As<IZooKeeper>();
 monkey.SetupProperty(m => m.Name);
 Mock.Get((IZooKeeper)monkey.Object).SetupProperty(k => k.AssignedMonkey);

 monkey.Object.Name = "Spike";
 ((IZooKeeper)monkey.Object).AssignedMonkey = monkey.Object;
 
 Assert.Equal("Spike", ((IZooKeeper)monkey.Object).AssignedMonkey.Name);

 Assert.IsAssignableFrom<IMonkey>(monkey.Object);
 Assert.IsAssignableFrom<IZooKeeper>(monkey.Object);
}

NSubstitute

This code is by far the smallest because we don’t need to set up the property behaviours. It’s uses the same approach as Rhino to create the mock itself, and still has the issues of needing to cast to the IZooKeeper interface, but apart from that it’s once again nice and clean code.

[Fact]
public void Nsubstitute_multiple_interfaces()
{
 var monkey = Substitute.For<IMonkey, IZooKeeper>();

 monkey.Name = "Spike";
 ((IZooKeeper)monkey).AssignedMonkey = monkey;

 Assert.Equal("Spike", ((IZooKeeper)monkey).AssignedMonkey.Name);

 Assert.IsAssignableFrom<IMonkey>(monkey);
 Assert.IsAssignableFrom<IZooKeeper>(monkey);
}

The choice of syntax here is again, quite easy to make. NSubstitute takes it out.

This also represents a conclusion to the posts focusing on Rhino Mocks, Moq and NSubstitute in the mocking comparison series. I’m not quite done though as I want to show some usage scenarios where those frameworks don’t work and where tools like Microsoft Moles and TypeMock fit in, so stay tuned – we’re not quite done yet! :-)

Other posts in this series:

Mocking Comparison – Part 10: Events

2010-08-04T12:20:00.001+10:00

So far in our comparison we’ve been looking at mock objects as if they were much like any other object, but what happens when we want our mocks to either raise or subscribe to events?

If you’re testing how your class under test reacts when it receives an event, or want to know if it raises an event with correct values then you really need your mock framework to be able to support this.

Subscribing To Events

To get a mock object to subscribe to an event is pretty easy. Just do it like you normally would, and then if you want to assert anything about how the event was raised, simply assert that the subscription method was called as expected.

Rhino Mocks

[Fact]
public void Rhino_event_subscriber()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 var keeper = new ZooKeeper();
 
 keeper.OnBananaReady += monkey.BananaReady;
 
 keeper.FeedMonkeys();
 monkey.AssertWasCalled(m => m.BananaReady(
  Arg<object>.Is.Equal(keeper)
  ,Arg<BananaEventArgs>.Matches(b => b.IsRipe
 )));
}

As you can see, we subscribe to the event normally, with the event being raised by the FeedMonkeys() call.

We then check that the event was called correctly and that the IsRipe flag was set correctly.

Moq

[Fact]
public void Moq_event_subscriber()
{
 var monkey = new Mock<IMonkey>();
 var keeper = new ZooKeeper();

 keeper.OnBananaReady += monkey.Object.BananaReady;

 keeper.FeedMonkeys();
 monkey.Verify(m => m.BananaReady(keeper, 
  It.Is<BananaEventArgs>(b => b.IsRipe)));
}

The syntax is much the same as for Rhino Mocks apart from the fact that the .Object. syntax again makes things feel clunky. On the positive side of things, the better constraint syntax in Moq makes the verify call far less noisy.

NSubstitute

[Fact]
public void Nsubstitute_event_subscriber()
{
 var monkey = Substitute.For<IMonkey>();
 var keeper = new ZooKeeper();

 keeper.OnBananaReady += monkey.BananaReady;

 keeper.FeedMonkeys();
 monkey.Received().BananaReady(keeper,
   Arg.Is<BananaEventArgs>(e => e.IsRipe));
}

The NSubstitute version is looks much the same as the Moq syntax, just without the .Object. stuff.

Raising Events

Raising an event is a pretty simply process. We simply get our class under test to subscribe to an event on our mock object and then ask our mock to raise an event.

Rhino Mocks

[Fact]
public void Rhino_raising_an_event()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 var tourist = new Tourist();

 tourist.SeeAMonkey(monkey);

 monkey.Raise(m => m.Dance += null, monkey, new EventArgs());
 Assert.Equal(1, tourist.PhotosTaken);
}

The line to pay attention to here is the second last one. The monkey.Raise() call. What you notice in here is that in order to raise an event we need to pass in an expression that registers an empty event listener. This is so Rhino can pick up the signature of the event you wish to raise.

Once that’s done we just provide arguments for the sender and event args that we wish to use for the event.

It’s a little weird looking but it works.

Moq

[Fact]
public void Moq_raising_an_event()
{
 var monkey = new Mock<IMonkey>();
 var tourist = new Tourist();

 tourist.SeeAMonkey(monkey.Object);

 monkey.Raise(m => m.Dance += null, new EventArgs());
 Assert.Equal(1, tourist.PhotosTaken);
}

The Moq code is much the same as the Rhino code, with the only difference being that by default the sender is the object raising the event and we don’t need to specify it.

NSubstitute

[Fact]
public void Nsubstitute_raising_an_event()
{
 var monkey = Substitute.For<IMonkey>();
 var tourist = new Tourist();

 tourist.SeeAMonkey(monkey);

 monkey.Dance += Raise.Event(new EventArgs());
 Assert.Equal(1, tourist.PhotosTaken);
}

Here you see the code is much simpler. We still need to register a pseudo event listener when we want to raise the argument, but at the same time, it’s a little more obvious what’s going on.

All three frameworks suffer from needing to use event subscriptions to figure out what event to fire, but that’s a result of limitations in the way C# works rather than a poor design decisions. With that in mind the verdict on which syntax to choose goes to NSubstitute. Since event subscription is much the same across all 3 frameworks there’s not much to differentiate them, however event raising in NSubstitute is cleaner and more expressive than the syntax of both Rhino and Moq, making my choice rather easy.

Other posts in this series:

Technical Debt in Scrum Teams

2010-08-02T21:48:00.001+10:00

On a mailing list I’m on there was a thread recently about dealing with technical debt in a scrum team. One of the responses went something along these lines (paraphrasing a bit here)

For delivering functionality you should use stories, but for technical debt don’t. All teams accumulate technical debt and dealing with it doesn’t fit into the story paradigm so just create tasks in your sprints to deal with it that way instead.

This, of course, garnered a response from yours truly as follows (with a little editing):

-----

Why doesn’t it fit into stories? All “non-functionals” can be represented as stories with business value. If you can’t do that, then they shouldn’t be done.

Examples:

As a Dev Manager I want the XYZ module refactored so that future development continues or improves upon the pace it is at now
As a Team Lead I want to clean up the FxCop warnings and reduce the cyclomatic complexity of the XXX assembly so that it is easier to change when we need to deliver the functionality expected in later sprints.
As an Architect I want to improve some of the implementations the team has made so that it aligns with the SOLID principles and provides a system that is more adaptable to changes in requirements
As a developer I want to clean up the rubbish I wrote in the previous sprint so that I can make the code easy for others to understand when they look at it

All of these can have a business value attached to them, be prioritised by your product owner, and broken down into tasks by the team, just as they should be. I’ve seen too many teams putting lipstick on their pigs and failing to deliver simply because “technical purity” was deemed more important than delivery (and I’ve definitely seen the reverse as well!). Every team carries technical debt – heck, code is technical debt all by itself – but the level of that debt that should be managed and balanced against new functionality by the product owner in consultation with the team, not by the team on their own.

-----

The lesson? Technical debt is a business risk. Avoid accumulating it whenever and wherever practical. Prevent it through sound development and architectural practices and improve and adhere to your Definition of Done. Once it’s there though, it’s up to the product owner and not the team to decide how much effort should be put into reducing the debt versus delivering new functionality.

Teams that mutiny against their Product Owners and do what they deem appropriate have either failed to convey the cost of debt sufficiently or have failed to understand the business drivers that drive the Product Owner to prioritise new functionality over of a sustainable code base and have ineffectual Scrum Masters that are not managing the process correctly. If this is you and your organisation, it’s time to end it and put things right.

Viemu and Visual Studio 2010

2010-08-02T10:26:00.001+10:00

If you’ve been keeping your ears open over the last few months you’ll have heard noises from a number of folks who have been talking vim up as a replacement editor.

On the other hand there have been people like Yehuda Katz claiming that it’s all hype and everyone should go back to their homes and shut the doors because the crazies will be gone soon (ok, I’m paraphrasing a lot there).

Of course, all of this made me chuckle and scratch my head at the same time.

Why? Because 20 years ago I was C++ on unix, using vi, as part of my Uni degree. I even wrote a vi clone as one of my Uni team projects! At the time I knew how to get around the editor reasonably well, though by no means was I a ninja, but I also thought it was as ugly as warts on your bum and compared to just being able to edit text the way you could with every other editor in the world at the time other than emacs, all that switch in/out of edit mode just felt like overhead.

As Uni turned into career I started worked on platforms and languages where vi didn’t exist (Wang VS, VAX/VMS, Linux, Windows, 4GLs, VB4+, Visual Studio, etc) and I gradually forgot all my vi editing skills, got used to living in a constant edit mode and never missed vi for a minute.

That said, it’s always good to question what you do and how you do it, and so if vi is being picked up by a whole new generation of developers then maybe this old fossil had better challenge his assumptions and re-evaluate wether vi is better than what I’m using currently and cut through all the talk with a little bit of personal experience. That said, I didn’t really want to lose my Visual Studio IDE and all the goodness ReSharper brings to it and my usual development workflow (i.e. the stuff that goes beyond just typing code) so I actually wanted the best of both worlds.

And thankfully it turns that there is something like this out there. There’s a Visual Studio add-in that brings all the good bits of vi into Visual Studio called viemu and I’ve been using it for a while now and really liking it. The guys who make it have also put together a great article explaining why people use vi/vim, and what some of the problems are in adopting it. It’s well worth a read and just as soon as you finish reading this post you should go have a read of that one as well.

Now, I will say up front that viemu is a commercial product, but since it has a 30-day trial there’s plenty of time for you to work out wether viemu will help you or not. Personally, I’ve found it improving my productivity quite a lot and it’s really reduced my hand movements and mouse usage even more than R# did, so I’ve gone and acquired a licence.

One of the issues I had initially was clashes with other extensions I have loaded (I have quite a few) so if you have ReSharper, the Visual Studio 2010 Productivity Power Tools or other similar extensions loaded then you may need to turn off a few options in them. What sort of clashes, you ask? Well, as vi uses a normal keyboard characters for navigation such as braces, brackets and parentheses other extensions pick up the key presses and think they are just normal typing so they go ahead and helpfully auto insert the matching closing characters, leaving random characters littered around your code if you’re not paying attention. Just go into your tools and find the relevant auto completion options and turn them off.

I should also mention, there’s a very handy shortcut to enable/disable viemu at any point in VS2010 so if someone else comes to your machine to do some pairing you can easily switch it off, let them work the way they wish and switch it back on when you have the keyboard again. Nice!

Finally, if you’re just learning the vi/vim commands I’d recommend you run through the visual cheat sheet and tutorials on the viemu site. It really helped me a lot in that regard, and made adoption much quicker. So with that said, if you want to save your hands and wrists then go download it and give it a try today. I’m really enjoying it, and you may just do so too!

Mocking Comparison – Part 9: Functions

2010-07-30T20:19:00.001+10:00

Let’s say you’ve got a mock object and you want a method on your mock to do something with a particular method that goes beyond just returning a specified value. What do you do? Why, you use a function of course! When you stub a method call on a mock you simply tell the mock object to call a method or use a lambda to calculate the return value rather than just returning a specified value.

Let’s have a look at how Rhino Mocks, Moq and NSubstitute do this.

What we’re going to do is supply some simple methods that our mock object will use when we call certain methods so that we can dynamically alter the return value from the CurrentFleaCount method and we’ll then assert that the value has changed.

Rhino Mocks

[Fact]
public void Rhino_functions_and_callbacks()
{
 var fleaCount = 25;
 var monkey = MockRepository.GenerateMock<IMonkey>();

 monkey.Stub(m => m.CurrentFleaCount()).Do(new Func<int>(() => fleaCount));
 monkey.Stub(m => m.TryAddFleas(1)).IgnoreArguments()
  .Do(new Func<int, bool>(fleas =>
  {
   fleaCount = fleas;
   return true;
  }));

 Assert.Equal(25, monkey.CurrentFleaCount());

 monkey.TryAddFleas(10);
 Assert.Equal(10, monkey.CurrentFleaCount());
}

Since this is a reasonable chunk of code, let’s just look at the key parts. When we stub the CurrentFleaCount method call we tell it to use a function that takes no arguments, and use the value of the fleaCount variable (defined in the test) to figure out what returns.

You may ask why didn’t we just do a .Return(fleaCount) like we normally would? Simple answer: we want to get the value to change as the test progresses. By using a Func<T> means that the return value is calculated each time we call the stubbed method, rather than just having a single fixed value returned for every call.

Similarly in the stubbed TryAddFleas() method, we are providing a function that takes one parameter and returns a boolean. Our stub method simply changes the value of fleaCount variable so that the next CurrentFleaCount() call will return a different value, and this is what the Asserts are checking for.

Hopefully that makes sense. Form a day to day usage viewpoint it’s not something you do that often but when you need the functionality it’s really useful.

Moq

[Fact]
public void Moq_functions_and_callbacks()
{
 var fleaCount = 25;
 var monkey = new Mock<IMonkey>();
 
 monkey.Setup(m => m.CurrentFleaCount()).Returns(() => fleaCount);
 monkey.Setup(m => m.TryAddFleas(It.IsAny<int>()))
  .Returns<int>(fleas =>
  {
   fleaCount = fleas;
   return true;
  });

 Assert.Equal(25, monkey.Object.CurrentFleaCount());

 monkey.Object.TryAddFleas(10);
 Assert.Equal(10, monkey.Object.CurrentFleaCount());
}

The Moq syntax is much the same as the Rhino syntax, as you can see. It’s probably a little nicer in that you use the same Returns() method to either return fixed values or call a function, unlike Rhino Mocks where you have to use the .Do() method.

It also doesn’t require the creation of new Func<T> objects – you just supply the method body you wish to use, which means less code.

NSubstitute

[Fact]
public void Nsubstitute_functions_and_callbacks()
{
 var fleaCount = 25;
 var monkey = Substitute.For<IMonkey>();

 monkey.CurrentFleaCount().Returns(args => fleaCount);
 monkey.TryAddFleas(Arg.Any<int>())
  .Returns(args =>
  {
      fleaCount = (int)args[0];
      return true;
  });

 Assert.Equal(25, monkey.CurrentFleaCount());

 monkey.TryAddFleas(10);
 Assert.Equal(10, monkey.CurrentFleaCount());
}

The NSubstitute code is a little different to the others in that instead of having parameter lists to deal with you are passed a single array containing all the parameters and it’s up to you to pull out the ones you wish to use and cast them as required by your test.

This has it’s advantages in that you avoid code littered with arguments you never use, but it has a downside in that you need to cast every parameter you do use. That said, just like Moq, you get to use the same Returns() method for either returning a fixed value or supplying a method and you don’t need to create new Func<T> objects so the code isn’t noisy. And better than Moq is it’s overall cleaner syntax, as we have seen in many of the previous posts.

My preference? NSubstitute. The casting of parameters is a little annoying, but it doesn’t have Moq .Object. tax and this is one of the few times you’ll actually see a lambda in a test using NSubstitute.

Other posts in this series:

How To: Versioning Builds With TFS 2010

2010-07-30T09:29:00.001+10:00

I’ve written in the past on how to do automatic assembly versioning with TFS Team Build 2008 so it’s about time I got around to showing you how to do with with TFS Team Build 2010.

By the way, for a great series of blog posts on customising team build with TFS 2010 it’s worth having a look at Ewald Hofman’s series on customising team build.

What We Want to Achieve

So, the goal here is to change the standard build process to enable us to do automatic versioning of assemblies. To do this what we need to do is insert some steps in the process just after the source has been retrieved from TFS. We want a flow that goes something like this:

Get Latest –> Update AssemblyInfo files with new version –> Do rest of the build

One extra wrinkle to this is that when team build gets the code from TFS the files are in read only mode, so what we’re going to do is switch the read only flag off, change the files, and then turn it back on. This is just in case an future incremental get tries to update the file – the read only flag will stop TFS checking if the file is different.

One thing we’re not going to do is check the updated assembly info files back into source control. This means all developer builds will by default have a version number of 1.0.0.0 and build server builds will have an incrementing build number. It’s a handy way to know if someone has tried to deploy code built on their machine instead of code built by the server.

This approach does raise a small issue though – where do we keep the build number between builds? i.e. how to we know what the previous build number was so we can increment it. For this we’re going to use a simple version.txt file stored in the root of the drop folder. If you want to secure this so that only the build process updates the version number I would suggest making the drop location read only for all users except the account the build runs under.

Anyway, enough talk. Let’s see what we need to do.

Getting Started

1. Open VS2010 and create a solution with two C# Class LIbrary projects in it. One for the custom build tasks we’re going to create, and one to hold the process template we’re going change. I have called mine CustomBuildActivities and CustomBuildProcess

2. In the CustomBuildProcess project add a Workflow activity and then delete it. This just helps with getting a bunch of references in place and adds the appropriate content type we’ll need when we add our build workflow in the next step.

3. Now go copy the DefaultTemplate.xaml file, rename it to something you like and include it in your project. I’ve called mine VersionedBuildProcess.xaml. Once it’s included in the solution change the Build Action to XamlAppDef.

At this point if you try compiling you’ll get a bunch of missing references, so add the following (sorry it’s a laundry list of items!)

System.Drawing
Microsoft.TeamFoundation.Build.Client
Microsoft.TeamFoundation.VersionControl.Client
Microsoft.TeamFoundation.WorkItemTracking.Client
%Program Files%\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\
Microsoft.TeamFoundation.Build.Workflow.dll
%Program Files%\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\
Microsoft.TeamFoundation.TestImpact.BuildIntegration.dll
%WinDir%\assembly\GAC_MSIL\Microsoft.TeamFoundation.TestImpact.Client
\10.0.0.0__b03f5f7f11d50a3a\Microsoft.TeamFoundation.TestImpact.Client.dll

UPDATE: If you set the Build Action to None then you don't need to worry about setting all those references and you can still edit the XAML as per usual. This is a lot easier for many people, but the downside is that you can't verify the workflow is 100% correct unless you manually look through the whole workflow or try a build with it. My preference is the first, but do whatever you're comfortable with :-)

Create the First Custom Activity

Next we’re going to create our first custom activity – this one will be the one we use to toggles the read only flags on AssemblyInfo files. In your CustomBuildActivities project add a new Workflow Code Activity called SetReadOnlyFlag. We’ll use this to toggle the read only bits for our AssemblyInfo files later on.

Now add references to Microsoft.TeamFoundation.Build.Client and Microsoft.TeamFoundation.VersionControl.Client and then use the following code for the class:

using System.Activities;
using Microsoft.TeamFoundation.Build.Client;
using Microsoft.TeamFoundation.VersionControl.Client;

namespace CustomActivities
{
 [BuildActivity(HostEnvironmentOption.Agent)]
 public sealed class SetReadOnlyFlag : CodeActivity
 {
  [RequiredArgument]
  public InArgument<string> FileMask { get; set; }

  [RequiredArgument]
  public InArgument<bool> ReadOnlyFlagValue { get; set; }

  [RequiredArgument]
  public InArgument<Workspace> Workspace { get; set; }

  protected override void Execute(CodeActivityContext context)
  {
   var fileMask = context.GetValue(FileMask);
   var workspace = context.GetValue(Workspace);
   var readOnlyFlagValue = context.GetValue(ReadOnlyFlagValue);

   foreach (var folder in workspace.Folders)
   {
    foreach (var file in Directory.GetFiles(folder.LocalItem, fileMask, SearchOption.AllDirectories))
    { 
     var attributes = File.GetAttributes(file);
     if (readOnlyFlagValue)
      File.SetAttributes(file, attributes | FileAttributes.ReadOnly);
     else
      File.SetAttributes(file,attributes & ~FileAttributes.ReadOnly);
    }
   }
  }
 }
}

The [BuildActivity] attribute on the class indicates that this class can be used as a workflow activity in the designer, and that it should be loaded on the build agent when a build runs.

This code here is how we define the arguments that the activity will use – they will appear in the properties window when the activity is selected in the designer, and the RequiredAttribute indicates that these properties must have values for the workflow to be valid.

[RequiredArgument]
public InArgument<string> FileMask { get; set; }

[RequiredArgument]
public InArgument<bool> ReadOnlyFlagValue { get; set; }

[RequiredArgument]
public InArgument<Workspace> Workspace { get; set; }

We’re going to use the Workspace to get information about where the build agent has physically put files on the disk so that we can get path information and search for the files we wish to change. The other properties are used to actually find out what files to change and which way to set the flag.

Create The Second Custom Activity

For this activity we want to take a set of files as defined by a mask and do a search/replace on them to update the version numbers for the AssemblyVersion and AssemblyFileVersion attributes.

Here’s the code:

[BuildActivity(HostEnvironmentOption.Agent)]
public sealed class UpdateAssemblyVersionInfo : CodeActivity
{
 [RequiredArgument]
 public InArgument<string> AssemblyInfoFileMask { get; set; }

 [RequiredArgument]
 public InArgument<string> SourcesDirectory { get; set; }

 [RequiredArgument]
 public InArgument<string> VersionFilePath { get; set; }

 [RequiredArgument]
 public InArgument<string> VersionFileName { get; set; }

 protected override void Execute(CodeActivityContext context)
 {
  var sourcesDirectory = context.GetValue(SourcesDirectory);
  var assemblyInfoFileMask = context.GetValue(AssemblyInfoFileMask);
  var versionFile = context.GetValue(VersionFilePath) + @"\" + context.GetValue(VersionFileName);

  //Load the version info into memory
  var versionText = "1.0.0.0";
  if (File.Exists(versionFile))
   versionText = File.ReadAllText(versionFile);
  var currentVersion = new Version(versionText);
  var newVersion = new Version(currentVersion.Major, currentVersion.Minor, currentVersion.Build + 1, currentVersion.Revision);
  File.WriteAllText(versionFile, newVersion.ToString());

  bool changedContents;
  foreach (var file in Directory.EnumerateFiles(sourcesDirectory, assemblyInfoFileMask, SearchOption.AllDirectories))
  {
   var text = File.ReadAllText(file);
   changedContents = false;
   // we want to find 'AssemblyVersion("1.0.0.0")' etc
   foreach (var attribute in new[] { "AssemblyVersion", "AssemblyFileVersion" })
   {
    var regex = new Regex(attribute + @"\(""\d+\.\d+\.\d+\.\d+""\)");
    var match = regex.Match(text);
    if (!match.Success) continue;
    text = regex.Replace(text, attribute + "(\"" + newVersion + "\")");
    changedContents = true;
   }
   if (changedContents)
    File.WriteAllText(file, text);
  }
 }
}

At this point you should be able to compile your application and see it all pass, but until we change the workflow itself this is pretty useless.

Updating the Build Workflow

In your process project open up the build process. In the toolbox you should now see something like this:

We want to drop these tasks into our workflow at the appropriate point, so to do this find the part of the workflow that looks something like this:

For reference it’s in ….Sequence > Run On Agent > Initialize Workspace (near the bottom)

Now add a sequence activity after the get workspace activity like so:

Change the display name property to “Update AssemblyInfo Versions"” or something similar. This not only appears in the build log, but has the advantage of helping you understand your workflow better.

Now drag the ReadOnly flag activity we created into the new sequence activity you added – it should now look something like this:

That error indicator means we haven’t yet supplied some property values for the activity, so we’d best do that now.

Set Activity Properties

If you look at the properties window for our activity you should see something like this:

What we want is for the users of our workflow to be able to specify the values for the FileMask via the Build Definition window, and we want to set the values for the Workspace based on whatever is current in our workflow.

Let’s tackle the FileMask first. To do this we’re going to add a new Argument to our overall workflow. Find the Arguments tab at the bottom of the designer:

Click in the Create Argument box and add a new argument called AssemblyInfoMask and give it a default value of “AssemblyInfo.*”

Before we use this in our activities let’s just make a few more changes to make this argument appear in the build process window the way we want it. Go to the metadata argument a few lines above and click the ellipsis […] button. You will see a window appear where we can set values that will let Visual Studio know how to display this argument to the end user. Let’s do just that:

Now let’s fix the properties on our Activity

Now you may be asking where the Workspace value comes from since it’s not an argument for the workflow. If you look a few activities above you will see a create workspace activity and one of it’s properties is an OutProperty called Result:

This is where the Workspace variable is created. Unfortunately there’s not really an easy way of tracking this sort of thing with the workflow, but fortunately most variables in the workflow are well named and you should be able to figure out what most of them do.

Finishing the Workflow

Let’s finish off the workflow. Drag the UpdateAssemblyVersionInfo task into the workflow along with a second SetReadOnlyFlag task.

Before we set the properties on these, we’re going to need one more workflow Argument, being the name of the version file we’re going to store the version information in.

Don’t forget to set the Metadata as well so that it appears in the correct place in Visual Studio when we define builds.

Now set the properties on the UpdateAssemblyVersionInfo activity as follows:

Since we want to store the file we hold our version info at the root of the drop location we have set the VersionFilePath to BuildDetail.DropLocationRoot. You can of course, change this to put it wherever you like.

Finally set the properties for the second SetReadOnlyFlag task, this time with the ReadOnly flag set to true.

At this point build your project. If it’s all OK everything should compile and you should be ready for the next step.

Using The New Build Process

Before we can use the new build process, we have to ensure both the process and the custom activities are in source control.

The .xaml process file should be added to the BuildProcessTemplates folder, and I usually place custom activities in a subfolder within that. For example:

Now we have to tell our Build Controller where to find our custom activities otherwise the build will fail. Go to Manage Build Controllers…

and in the properties window set the path to the activities

Now we can finally create a build definition.

In the new build definition window, go to the Process tab, select the Show Details window and Click New..

Select an existing .xaml file (being the new process you uploaded)

If you set your metadata properties correctly, the process settings should now look something like this:

If all goes well, you should get a completed build and see something like the following in the log, indicating our new steps occurred.

Finally go to the drop location, right click one of your assemblies and see that the version information is being updated.

Phew! That’s it! We’re done!

I know it’s a fair bit of work getting this all set up, but once you’ve done it once and have your initial workflow project in place, you can use it as the basis for any future process customisations which makes things much quicker. Also as you get more familiar with the workflows themselves and knowing where to make changes the process customisation itself will also become faster and easier.

Good luck customising your builds!

Mocking Comparison – Part 8: Recursive Mocks

2010-07-29T21:21:00.002+10:00

Recursive mocks (or nested mocks as some people call them) are a feature of the mocking frameworks where they will automatically create mock objects for items they should return if you reference a property or method of that object when setting up expectations. The advantages of doing this are that we have less “arrange” code in our test classes and can focus our efforts more on our act and assert code.

Maybe that explanation of recursive mocks doesn’t clarify things much for you so let’s just look at some code instead and see how Rhino Mocks, Moq and NSubstitute help us out.

Rhino Mocks

[Fact]
public void Rhino_recursive_mocks()
{
 var monkey = MockRepository.GenerateStub<IMonkey>();
 monkey.Name = "Spike";
 monkey.Stub(m => m.Keeper().AssignedMonkey).Return(monkey);
 Assert.NotNull(monkey.Keeper());
 Assert.Equal("Spike", monkey.Keeper().AssignedMonkey.Name);
}

If you have a look at the code you can see that we create a stub object for the the IMonkey interface. Within that we set up an expectation that when we check which monkey the keeper is assigned to that it should be the monkey object we just created (i.e. we’re setting up a circular object reference).

We don’t need to create a specific IZooKeeper stub object here as Rhino will do that for us and if you step through the test in debug mode you can see that we have a fake object created for us:

Moq

The code for Moq is much the same apart from the fact that we have to set up the property behaviour for the monkey’s name and remember if we’re dealing with the mock or the object it’s returning.

[Fact]
public void Moq_recursive_mocks()
{
 var monkey = new Mock<IMonkey>();
 monkey.Setup(m => m.Keeper().AssignedMonkey).Returns(monkey.Object);
 monkey.SetupProperty(m => m.Name);
 monkey.Object.Name = "Spike";
 Assert.NotNull(monkey.Object.Keeper());
 Assert.Equal("Spike", monkey.Object.Keeper().AssignedMonkey.Name);
}

Interestingly, if you look at the code in the final assert closely you’ll see that the mock/object distinction is lost when we start using the recursive mocks. Instead of using Keeper().Object.AssignedMonkey we just have Keeper().AssignedMonkey. It’s not a big deal, but it seems to break the paradigm that Moq has used elsewhere of separating the Mock from the object itself.

NSubstitute

And finally the NSubstitute approach

[Fact]
public void Nsubstitute_recursive_mocks()
{
 var monkey = Substitute.For<IMonkey>();
 monkey.Keeper().AssignedMonkey.Returns(monkey);
 monkey.Name = "Spike";
 Assert.NotNull(monkey.Keeper());
 Assert.Equal("Spike", monkey.Keeper().AssignedMonkey.Name);
}

Nice and clean. No lambdas. Expressive and direct. What more could you want :-)

P.S. At time of writing the recursive behaviour was only available when building from source.

The verdict? NSubstitute is the clear winner here.

Other posts in this series:

How To “Remember My Password” with TFS 2010

2010-07-29T10:16:00.001+10:00

If you connect to a TFS server with a machine that isn’t in the same domain then you will typically see something like this:

So you click the Use different credentials button to login and get a dialog that looks the this. But wait! Where’s the “Remember my password” checkbox?!

It’s not there! It’s OK, don’t panic. There is a way to avoid entering your credentials every time you want to connect.

In Windows 7 you can use the Credential Manager feature as follows. Head to the control panel and click the Credential Manager icon.

Next click the “Add a Windows credential” link:

Then enter your details. Not that the network address is just the machine name of the TFS server you are connecting to.

And you’re done! Go back to Visual Studio, connect to TFS again and you won’t have any more login prompts. Yay!

For the Windows XP/Vista users you will need to go to Control Panel -> User Accounts -> Manage your Network Passwords instead. The UI is a little different, but it should be fairly self-evident..

P.S. For the observant amongst you wondering why my machine is TFS2008-VM when this is a post about TFS2010, it’s because I’m using an upgraded TFS2008 instance. It’s definitely a TFS2010 machine :-)

Mocking Comparison – Part 7: Exceptions

2010-07-28T11:25:00.001+10:00

One of the great benefits of using mocks in your tests is being able to check how your classes behave when exceptions are thrown. You do test for this sort of thing, right? :-)

Let’s say we have a persistence mechanism that talks to SQL. What happens when we get a SQL primary key violation? What if we are talking to web services and the connection drops or we get some other WCF exception? How do we handle that?

More importantly, how do we get Rhino Mocks, Moq or NSubstitute to raise those exceptions. Let’s have a look.

Rhino Mocks

[Fact]
public void Rhino_throwing_exceptions()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 monkey.Stub(m => m.Name).Throw(new ApplicationException());
 Assert.Throws<ApplicationException>(() => monkey.Name);
}

This is pretty simple code. Instead of returning a value, just throw an exception when the method is called. Too easy!

Moq

[Fact]
public void Moq_throwing_exceptions()
{
 var monkey = new Mock<IMonkey>();
 monkey.Setup(m => m.Name).Throws(new ApplicationException());
 Assert.Throws<ApplicationException>(() => monkey.Object.Name);
}

The Moq code is much the same as the Rhino code, except we still have that .Object. tax that annoys me so much.

NSubstitute

[Fact]
public void Nsub_throwing_exceptions()
{
 var monkey = Substitute.For<IMonkey>();
 monkey.Name.Returns(args => { throw new ApplicationException(); });
 Assert.Throws<ApplicationException>(() => monkey.Name);
}

Not quite as clean as the other two frameworks here, though I’m sure the guys will rectify this soon enough.

And the winner: Rhino Mocks. Even though Moq requires slightly less code than Rhino it’s .Object. distinctions will always annoy me.

Other posts in this series:

Bad Keyboard Design

2010-07-27T13:16:00.001+10:00

I have to wonder at times what goes through designer’s heads and wether they use their own products. Have a look at the following keyboard for a HP machine I’ve been given to use when on site.

Look at the size of that Shift key on the left there. The thing is about half it’s normal size, which of course means I keep hitting the key next to it far too often and screwing up my typing. I have to train my hands to perform more finger gymnastics than is normal, and can’t easily slide my left thumb into position like I normally would (maybe I shouldn’t use my thumb for shift, but it’s a habit I’ve picked up from gaming and it’s hard to overcome).

But maybe there’s a reason why they did it. A reason why they cut the left shift key in half but kept the right hand one full sized? Oh, there’s it is! It’s so they could add an extra (and duplicated) key on the keyboard! I for one know that the backslash and pipe characters are easily the most commonly used ones in my arsenal. On my laptop the backslash key is so worn away from use I can hardly make out the symbols on it any more. It’s worse than even the ‘e’ and return keys! Thank goodness keyboard usability was sacrificed to add an extra one of those puppies! Thank you HP! Thank you!

OK. Rant over. Time to go steal a keyboard from someone else in the office, and while I do that why don’t you let me know what the most annoying keyboard design is that you’ve used or seen?

Mocking Comparison – Part 6: Multiple Calls

2010-07-26T14:54:00.001+10:00

Our comparison of Rhino Mocks, Moq and NSubstitute continues with a look at how multiple calls to a mock are handled and what you do if you want to alter the return values on subsequent calls.

Consider the scenario where you have a method you’re calling that you want to be successful the first time you call it, but where subsequent calls should fail (such as trying to save the same data twice, etc). How do you do this?

Rhino Mocks

In Rhino Mocks to set return values for multiple calls to a method you simply specify the return value that many times. To avoid duplication of code you can use the repetition syntax we saw in Part 5.

[Fact]
public void Rhino_multiple_calls()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();

 monkey.Stub(m => m.TryAddFleas(1)).Return(true).Repeat.Twice();
 monkey.Stub(m => m.TryAddFleas(1)).Return(false);

 Assert.True(monkey.TryAddFleas(1));
 Assert.True(monkey.TryAddFleas(1));
 Assert.False(monkey.TryAddFleas(1));
}

Given that we have set up the return value 3 times, what happens when we make the call a fourth time? At this point Rhino Mocks, having exhausted it’s known set of return values, will start returning the default value.

What if you just want to return the value True for every call? We would use the Repeat.Any() method as shown here:

[Fact]
public void Rhino_multiple_calls()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();

 monkey.Stub(m => m.TryAddFleas(1)).Return(true).Repeat.Any();

 Assert.True(monkey.TryAddFleas(1));
 Assert.True(monkey.TryAddFleas(1));
}

Moq

Moq doesn’t have a nice way of defining mixed return values (not that I can find anyway) however you can implement the same thing using callbacks, which we’ll cover in a later post.

By default setting a return value on a method call will always return that value no matter how many times it is called, so we can at least do the following:

[Fact]
public void Moq_multiple_calls()
{
 var monkey = new Mock<IMonkey>();
 monkey.Setup(m => m.TryAddFleas(1)).Returns(true);

 Assert.True(monkey.Object.TryAddFleas(1));
 Assert.True(monkey.Object.TryAddFleas(1));
}

NSubstitute

The code for mixed return values in NSubstitute is so nice. To handle multiple calls providing different return values you can just provide multiple values or use an array in the return statement as follows:

[Fact]
public void Nsubstitute_multiple_calls()
{
 var monkey = Substitute.For<IMonkey>();

 monkey.TryAddFleas(1).Returns(true,true,false);

 Assert.True(monkey.TryAddFleas(1));
 Assert.True(monkey.TryAddFleas(1));
 Assert.False(monkey.TryAddFleas(1));
}

And if you just want to always return true, then it works just like Moq does (with the benefit of not requiring the .Object. tax in the assert statements:

[Fact]
public void Nsubstitute_multiple_calls()
{
 var monkey = Substitute.For<IMonkey>();

 monkey.TryAddFleas(1).Returns(true);

 Assert.True(monkey.TryAddFleas(1));
 Assert.True(monkey.TryAddFleas(1));
}

If you can’t tell, my decision on the best framework to choose goes to NSubstitute. It has such a simple and elegant way to handle both requirements, and again, not a single lambda in site. Excellent!

Other posts in this series:

Mocking Comparison - Part 5: Repetitions

2010-07-23T13:23:00.002+10:00

In Part 4 we looked at how parameter constraints are handled and in Part 3 we looked at how to do interaction based tests with mocks. In this part we bring those two pieces together and add a little extra to check if a call was made a specific number of times.

Let’s just jump straight into the code shall we?

Rhino Mocks

Our test here is simply going to call a method a number of times and verify that the call was made the correct number of times using constraints to verify the correct calls. It’s a completely useless test, other than as a vehicle to show you how to do this sort of thing

[Fact]
public void Rhino_repetitions()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();

 monkey.TryAddFleas(5);
 monkey.TryAddFleas(-1);
 monkey.TryAddFleas(9);

 monkey.AssertWasCalled(m => m.TryAddFleas(0),
  options => options.Constraints(
   Is.GreaterThan(3) && Is.LessThanOrEqual(10)
  )
  .Repeat.Twice());
 monkey.AssertWasCalled(m => m.TryAddFleas(-1),
  options => options.Repeat.Once());
}

Note the important part, the .Repeat.Twice() and .Repeat.Once() calls. It’s these calls that define our expectations as to how many times the call should have been made.

Rhino also features a .Repeat.Time(n) call you can use as well if once or twice don’t cut it for you.

Moq

[Fact]
public void Moq_repetitions()
{
 var monkey = new Mock<IMonkey>();

 monkey.Object.TryAddFleas(5);
 monkey.Object.TryAddFleas(-1);
 monkey.Object.TryAddFleas(9);

 monkey.Verify(m => m.TryAddFleas(
   It.IsInRange(3,10,Range.Exclusive)
  ),
  Times.Exactly(2));
 monkey.Verify(m => m.TryAddFleas(-1), Times.Once());
}

Instead of using the word Repeat, Moq uses Times. Apart from that there is little difference.

NSubstitute

Unfortunately NSubstitute doesn’t support this feature yet as it’s still a maturing framework. If you really need to do this type of testing then you’ve got a few options – use Rhino or Moq, contribute to the NSubstitute project, or to just not do this type of testing :-).

Interaction based testing is valid at times, but it’s generally brittle and is usually a sign of “implementation verifying” tests rather than behaviour/specification verifying tests (but that’s an argument for another time)

Verdict: Moq wins out in this case simply because it’s constraint system is more terse than the Rhino one, but this is purely a personal taste thing.

Other posts in this series:

Mocking Comparison – Part 4: Parameter Constraints

2010-07-22T16:45:00.001+10:00

Continuing with our comparison of Rhino Mocks, Moq and NSubstitute we now turn our eye to how constraints are managed.

Consider a method with parameters that was want to mock. By default, a mock object will only return a specified value if the parameters passed to it exactly match the call signature specified to the mock object. Maybe that’s a bit wordy, so as a quick example if you say Method(“a”).Returns(“Fred”) you’ll only get “Fred” back from the mock when you pass “a” as the parameter. Passing “b” gets you nothing. Make sense?

OK, so what if I then want my mock object to provide different return values when different parameter values are used. How do we avoid writing too much code or having to work out exactly what we should expect as a parameter every time? And what if I don’t care what’s passed in, I just want a return value.

This is where constraints come into play. Let’s look at some code to show how it works:

Rhino Mocks

Here’s a test where we try to add fleas to our monkey. Adding positive numbers of fleas should succeed and adding a negative number of fleas should fail.

[Fact]
public void Rhino_no_constraints()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 monkey.Stub(m => m.TryAddFleas(5)).Return(true);
 monkey.Stub(m => m.TryAddFleas(-1)).Return(false);
 monkey.Stub(m => m.TryAddFleas(9)).Return(true);

 Assert.Equal(true, monkey.TryAddFleas(5));
 Assert.Equal(false, monkey.TryAddFleas(-1));
 Assert.Equal(true, monkey.TryAddFleas(9));
}

Notice how the use of explicit parameter values in the stubs means we have to repeat a lot of code. Hmm, that’s annoying.

Thankfully we can simplify this by just ignoring the arguments as seen in the code below. Note that we still have to supply a parameter value for the TryAddFleas lambda in the Stub call, even though it’s ignored.

[Fact]
public void Rhino_ignore_arguments()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 monkey.Stub(m => m.TryAddFleas(0)).IgnoreArguments().Return(true);

 Assert.Equal(true, monkey.TryAddFleas(5));
 Assert.Equal(false, monkey.TryAddFleas(-1));
 Assert.Equal(true, monkey.TryAddFleas(9));
}

However this will now cause the test to fail because we no longer return a false when passed -1 as a value.

So what we really want is to only return true when the argument value is in a certain range. For fun let’s make that range between 4 and 9 inclusive. Here’s the test now, using constraints:

[Fact]
public void Rhino_constraints()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();

 monkey.Stub(m => m.TryAddFleas(0))
  .Constraints(Is.LessThan(10) && Is.GreaterThan(3))
  .Return(true);
 Assert.Equal(true, monkey.TryAddFleas(5));
 Assert.Equal(false, monkey.TryAddFleas(-1));
 Assert.Equal(true, monkey.TryAddFleas(9));
}

Whilst this means I have 2 less Stub calls to make, it does tend to be a little verbose. Expressive, but verbose. For those wondering why I don’t have a constraint for the -1 argument, I’m relying on the standard behaviour of mocks. If a constraint isn’t matched then the standard mock behaviour is to return the default value of the return type, being false in this case.

Moq

Here’s the same thing in Moq. For brevity and completeness I’ve included a commented out line that shows what you would do if you just wanted to ignore parameter values

[Fact]
public void Moq_constraints()
{
 var monkey = new Mock<IMonkey>();

 //monkey.Setup(m => m.TryAddFleas(It.IsAny<int>())).Returns(true);
 monkey.Setup(m => m.TryAddFleas(It.IsInRange(3, 10, Range.Exclusive)))
  .Returns(true);
 Assert.Equal(true, monkey.Object.TryAddFleas(5));
 Assert.Equal(false, monkey.Object.TryAddFleas(-1));
 Assert.Equal(true, monkey.Object.TryAddFleas(9));
}

The IsInRange method is quite nice, and the range constraints can be either inclusive or exclusive, however the code feels as verbose if not more so than the Rhino approach.

Note that if you use a test harness like MSpec (Machine.Specifications) then the “It” static class that Moq uses clashes with the “It” class used by MSpec for defining specifications which makes writing code a little painful at times.

NSubstitute

Finally the NSubstitute version.

[Fact]
public void Nsubtitute_constraints()
{
 var monkey = Substitute.For<IMonkey>();

 //monkey.TryAddFleas(Arg.Any<int>()).Returns(true);
 monkey.TryAddFleas(Arg.Is<int>(count => count > 3 && count < 10))
  .Returns(true);

 Assert.Equal(true, monkey.TryAddFleas(5));
 Assert.Equal(false, monkey.TryAddFleas(-1));
 Assert.Equal(true, monkey.TryAddFleas(9));
}

This works much the same as the others with the difference being that you have a predicate as the parameter and you need to supply the parameter type to the Arg.Is<T> call.

From a readability perspective, there’s less code which is good and it’s easier to read than the other frameworks because of it’s terseness. As a bonus, using the Arg.Any<T> call means we can avoid lambdas completely..

Verdict: I’ll go with the NSubstitute version as my first choice, though it’s more a matter of style choice than anything else. After that I prefer the Moq syntax over Rhino in this case.

Other posts in this series:

Mocking Comparison – Part 3: Interactions

2010-07-21T21:37:00.001+10:00

Our comparison of Rhino Mocks, Moq and NSubstitute continues with a look at how these frameworks support interaction based testing (whether that’s a good idea or not is not going to be dealt with here!).

The idea behind interaction based testing is checking if our class under test makes appropriate calls to the mocked objects. Typically this is done when testing against API’s that want things done in a certain order or where you want to check that the Save method of a repository was called, as an example.

For our example code we’re going to be testing that the Keeper makes the appropriate call to check the current flea count and then, because the flea count is low, does not try and clean the monkey, i.e. Monkey.Clean() should not be called.

Note that code for the classes under test is in Part 1 of this series.

Rhino Mocks

[Fact]
public void Rhino_method_was_called()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 var keeper = new ZooKeeper {AssignedMonkey = monkey};
 monkey.Stub(m => m.CurrentFleaCount()).Return(0);

 keeper.CleanMonkey();

 monkey.AssertWasCalled(m => m.CurrentFleaCount());
 monkey.AssertWasNotCalled(m => m.Clean());
}

So in the initial arrange section of our test we stub out the CurrentFleaCount() call to return zero fleas when called.

We then perform the Act part of our test and ask the Keeper to clean the monkey.

Finally in the Assert part of our test we check if the monkey had methods called on it – the CurrentFleaCount method should be called, and the Clean method should not be called.

If you’re playing along at home, you may have noticed that changing the monkey’s flea count to 100 still makes the test pass, when we should have expected the test to fail (because the clean method should now be called). This won’t happen because there is a second guard clause in the keeper’s CleanMonkey() method that checks if the monkey is awake and this will always return false.

It brings up an important point with all mock objects in that the default response for any method not explicitly stubbed out is to return the default value, and the default for a bool is false.

Moq

[Fact]
public void Moq_method_was_called()
{
 var monkey = new Mock<IMonkey>();
 var keeper = new ZooKeeper() {AssignedMonkey = monkey.Object};

 monkey.Setup(m => m.CurrentFleaCount()).Returns(0);

 keeper.CleanMonkey();

 monkey.Verify(m => m.CurrentFleaCount());
 monkey.Verify(m => m.Clean(), Times.Never());
}

The code here is similar to Rhino’s code however you’ll notice that to configure our mock object in Moq we use Setup instead of Stub/Expect calls to set the return behaviour for the flea count method.

Moq uses a single Verify method to check that a call was made, so to check that something wasn’t called you have to check that it was called zero times – expressed in Moq syntax as Times.Never(). Make your own mind up over whether this is clear enough from a readability perspective, but I find that it feels a little like Yoda has been writing code and the Verify call seems like it should have a boolean statement for its parameter, not be asserting that a method was called.

NSubstitute

[Fact]
public void Nsubstitute_method_was_called()
{
 var monkey = Substitute.For<IMonkey>();
 var keeper = new ZooKeeper { AssignedMonkey = monkey };
 monkey.CurrentFleaCount().Returns(0);

 keeper.CleanMonkey();

 monkey.Received().CurrentFleaCount();
 monkey.DidNotReceive().Clean();
}

Firstly, not the lack of lambda methods anywhere in this code. The mock object behaviour is setup by simply attaching a .Returns(0) to the monkey.CurrentFleaCount() method making the code more expressive and simpler to read.

As far as the asserts are concerned we check that a call was Received() by our mock object or that the mock DidNotReceive() the call. I find this syntax better than the other frameworks in that there’s no lambdas, but it doesn’t read quite as well as I might like.

The verdict: It’s a split decision between Rhino and NSubstitute, with me wanting the best of both.

Other posts in this series:

Mocking Comparison – Part 2: Properties

2010-07-20T17:51:00.001+10:00

Carrying on with our Rhino Mocks, Moq and NSubstitute comparison, let’s now look at how the various frameworks handle properties on their mock objects.

Rhino Mocks

So in RhinoMocks you have two choices for creating mock objects – using GenerateMock<T>() or GenerateStub<T>(). GenerateMock will create a mock object that tracks calls made to it so that you can assert expectations against which calls were made at the end of your test. GenerateStub on the other hand creates a stub object, which is to all intents and purposes the same as a mock object just without any of the overhead for tracking which calls were made against it. In other words you can do asserts to check if a call was made on a mock, but not on a stub.

Why does this matter? Because properties on mocks and stubs have different default behaviours in RhinoMocks.

For a mock object we have to explicitly indicate if we want a property to have a standard getter/setter applied to it (i.e. just like an autoproperty implementation). Here’s some code

[Fact]
public void Rhino_properties()
{
 var monkey = MockRepository.GenerateMock<IMonkey>();
 monkey.Stub(m => m.Name).PropertyBehavior();

 monkey.Name = "Spike";
 Assert.Equal("Spike", monkey.Name);
}

and the same test with a stub

[Fact]
public void Rhino_properties()
{
 var monkey = MockRepository.GenerateStub<IMonkey>();

 monkey.Name = "Spike";
 Assert.Equal("Spike", monkey.Name);
}

Note that the stubbed object requires none of the property behaviour setup and so it feels more natural. While some people may prefer to see properties being set up explicitly rather than implicitly I think that if it is a well known behaviour then it’s not going to be a problem that the property behaviour is implicitly provided on the stubbed objects.

Moq

The Moq code is much the same, however as you can see we have to pay the Moq .Object. tax on our calls.

[Fact]
public void Moq_properties()
{
 var monkey = new Mock<IMonkey>();
 monkey.SetupProperty(m => m.Name);

 monkey.Object.Name = "Spike";
 Assert.Equal("Spike", monkey.Object.Name);
}

This makes the code feel just a little more verbose and cumbersome than the Rhino and NSubstitute versions.

In fairness, if you want all properties to be automatically set to the standard autoproperty behaviour for a mock object you can use the SetupAllProperties method in Moq as follows:

[Fact]
public void Moq_properties()
{
 var monkey = new Mock<IMonkey>();
 monkey.SetupAllProperties();

 monkey.Object.Name = "Spike";
 Assert.Equal("Spike", monkey.Object.Name);
}

NSubstitute

The NSubstitute code shown below is much the same as the Rhino Mocks code when using stubs. The difference being that NSubstitute doesn’t differentiate between stubs and mocks.

[Fact]
public void NSubstitute_properties()
{
 var monkey = Substitute.For<IMonkey>();
   
 monkey.Name = "Spike";
 Assert.Equal("Spike", monkey.Name);
}

Overall, Rhino and NSubstitute are on par, however the more expressive mock object creation and reduced confusion over whether to use mocks or stubs in NSubstitute tilts the balance in favour of NSubstitute.

Other posts in this series: