blogs.conchango.com

I've worked on a couple of projects for Microsoft UK - one of the many great aspects of those projects was being able to use some very cool internal tools; my two favourites being the pre-cursors to Team Foundation Server (Product Studio + Source Depot) and StyleCop - which is to source code what FxCop is to binaries.

StyleCop quickly found a very special place in my heart - mainly because it soothed my coding standards / consistency / best practice OCD. I'm a fervent believer in coding standards - not only for the obvious reasons of consistency and maintainability - but mainly because I like the aesthetics of elegant code. It's hard to describe without sounding like a kook, but I find code formatting and refactoring quite soothing while I'm trying to solve bigger business logic problems - it helps me get into the zone.  Consistently well formatted code sits well in my visuospatial sketchpad - it forms visual patterns that are easy to recognise when scanning code - an upshot of which is that it's very easy to see out of place (bad / sloppy) code and thus spot where bugs are likely to appear.

Using StyleCop meant an end to all the stupid arguments I used to get embroiled in whenever a new developer would start on a project; even though there was obviously a standard in place that the team was adhering to, the new developer would insist on coding "m_" styleee because that's how they'd always coded. StyleCop became the H-Bomb argument killer - if you didn't conform to the standard, you would break the build. With one less thing to worry about, your team can focus on the much more important issue of delivering business value to the customer.

The genius behind StyleCop is Jason Allor - he's done an awesome job by not only creating a tool which the whole C# community has been crying out for, but also achieved the amazing feat of getting buy-in from (or wrangling) a large number the internal MS teams to adopt StyleCop; hopefully this is a win-win situation as it helps make the products better, but also if Microsoft continues to push the envelope with it's transparency - we should all benefit.

After many people begged for it to be released externally, StyleCop has been rebranded as Microsoft Source Analysis for C# (MSAFC) and released on the MSDN Code Gallery, Jason has also created a Source Analysis blog where documentation, hints, tips and trivia will live. The first release has MSBuild integration and wonderfully Eugene Zakhareyev has already created a TFS Check-In Policy 

One aspect that already amuses me is the number of people who are regurgitating many of the internal arguments that happened during StyleCop's infancy - "what do you mean 'use spaces instead of tabs'! No way - spaces are evil" - or the number of people who have raised issues because they want to be able to selectively turn rules on and off. Duh. I really hope Jason has copies of those flame-war threads so he can publish them onto the blog so that people understand the reasoning behind the rules - if only to highlight the point that if 1000's of Microsoft Product Team Developers can agree - then persuading your development team to adopt the rules should be easy.

When time came to leave those Microsoft UK internal projects - the hardest part was going through StyleCop withdrawal. When I went to the Team System SDR in 2004 I begged and pleaded like a fanatic to have StyleCop included in the product - but it was not to happen. I started to look around the web for alternative tools - but there were only pale imitations. So I started to do a little research into what it would take to write my own.

I soon discovered that I was no-where near hardcore enough to write my own C# parser - even worse, many of the open source ones only worked for .NET 1 / 1.1 and had not been updated to support 2.0 with generics support - and as Conchango deals with cutting edge .NET projects we need .NET 3.5 language features to be supported (although I have just discovered LINQ over C# - which looks like it could do the trick!). I started looking at DXCore but then on a tangent started to see if there was anyway to extend ReSharper via their Open API. There wasn't a huge amount of documentation - but I managed to piece together what was required from a few blog posts and samples. I wanted to create a tool that had the features of StyleCop and the elegance of Resharper - namely that I wanted real-time syntax checking - so it's slightly bittersweet that Microsoft Source Analysis for C# has been released just as I had completed a working prototype!

So last night - I took my abandoned ReSharper plug-in code and decided to try to integrate it with MSAFC. Below is a screenshot of the result. It's still a little buggy - but hopefully over the next few days I can fix the major issues and release a version to the web.

While catching up on long overdue flagged posts to read - I spotted a familiar meme on becoming a better developer – I wrote about Continuous Education almost 2 years and it’s nice to see that this topic keeps reappearing. I’ve updated my bubble graph of the technologies to include those that I’ve used over the last 12 months and have also added training courses and events I’ve attended:

Apart from the foray into WPF development in late 2006 / early 2007 and a little dabbling with Silverlight 1.1 post Mix 07 – I’ve been involved predominantly in the RIA space. It was a bit of a mental shift working on several smaller projects in 2007 as until Christmas 2006, I had been working for the same client, creating a number of products based on a shared platform for almost 2 years.

Another change that’s happened in the last 18 months is that I took on the role of a Technology Coach responsible for the career development and appraisals of a number of developers within Conchango. Performing this function has given me a new perspective Continuous Education; one thing that Agile Methodologies has taught me is the power of a feedback loop – the tighter the feedback loop the greater your ability to inspect and adjust; this can work really well if you know the career aspirations of the people in your team and you have the mechanism (i.e. an iteration) where you can let those people learn and grow.

One topic I've been spending a lot of time thinking about over the last year is "how do you hone a development team into a state of hyperproductivity?" If you assume that the foundation of the team is an Agile process with iterations and a feedback loop (retrospective), what other facets do the team need? At the moment I'm convinced it's confidence or to be more specific, fearlessness, the state of mind you can achieve when you have confidence that you know what you are doing, confidence that you can make a change and you know the impact and ramifications of that change. Team velocity can be severely impaired by the fact that a development team is intimidated by the codebase, either because it is very large, complex or mainly unknown to them – they fear making changes because they don’t know what the cost of that change would be.

Two vectors that I believe helps developers into the fearless state of mind are test coverage and refactoring tools. Empowering the team with Resharper and spending time teaching them how to really use it means that they are suddenly much more in control of the codebase than before; they can easily see the interconnectedness of the code; renaming, moving, deleting cleaning and extending the code has suddenly become a simple if not trivial task. A feature like Resharper's "find usages" give a great hint as the the cost of a change. But the real confidence only comes with good test coverage (integration and / or unit). These two vectors  should give them enough confidence to put them in the state of mind that they could be a bit more fearless, which tends to means that in time they start becoming more independent, self managing members of the team – which is when they are truly useful and truly productive. Ben Watson has a nice post called 6 Ways to Increase Your Confidence As You Code.

I also tend to read a lot - I subscribe to around 70 blogs (I use Newsgator Inbox (now free!) and Outlooks' search folders to filter for topics I'm interested - the rest get perused on train journeys), I'm also quite an avid consumer of books, below are the ones I’ve purchased and read in the last 12 months:

	Agile Web Development with Rails
	Ruby for Rails: Ruby Techniques for Rails Developers
	Rails Recipes
	Applications = Code + Markup: A Guide to the Microsoft Windows Presentation Foundation
	Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
	Windows Presentation Foundation Unleashed
	Windows Communication Foundation Unleashed
	Expression Blend Bible
	Introducing Microsoft ASP.NET AJAX
	Introducing Microsoft LINQ
	Herding Cats: A Primer for Programmers Who Lead Programmers
	Getting Things Done: The Art of Stress-free Productivity
	Software Estimation: The Black Art Demystified
	Deploying.NET Applications: Learning MSBuilder and Clickonce
	xUnit Test Patterns: Refactoring Test Code: Refactoring Test Code
	Regular Expression Pocket Reference
	Domain-driven Design: Tackling Complexity in the Heart of Software
	Domain Specific Development with Visual Studio DSL Tools

Last week I was doing a lot of ASP.NET debugging – tracing through Microsoft AJAX web service calls and was getting a little frustrated of the time lag for starting a site in debug mode; I remembered a Visual Studio macro for attaching to the worker process and that I had rewritten in a couple of years ago to attach to multiple worker processes, in case you were running multiple sites (i.e. a web services layer and an application layer) on either Windows XP (aspnet_wp.exe) or Windows Server 2003 (w3wp.exe). Below is the source for the macro – I've tested it on Visual Studio Orcas Beta 1.

Imports System
Imports EnvDTE80
Imports System.Diagnostics

Public Module AttachToWebServer

   Public Sub AttachToWebServer()

      Dim AspNetWp As String = "aspnet_wp.exe"
      Dim W3WP As String = "w3wp.exe"

      If Not (AttachToProcess(AspNetWp)) Then
         If Not AttachToProcess(W3WP) Then
            System.Windows.Forms.MessageBox.Show(String.Format("Process {0} or {1} Cannot Be Found", AspNetWp, W3WP), "Attach To Web Server Macro")
         End If
      End If

   End Sub

   Public Function AttachToProcess(ByVal ProcessName As String) As Boolean

      Dim Processes As EnvDTE.Processes = DTE.Debugger.LocalProcesses
      Dim Process As EnvDTE.Process
      Dim ProcessFound As Boolean = False

      For Each Process In Processes
         If (Process.Name.Substring(Process.Name.LastIndexOf("\") + 1) = ProcessName) Then
            Process.Attach()
            ProcessFound = True
         End If
      Next

      AttachToProcess = ProcessFound

   End Function

End Module

During one of the Open Space sessions I attended at the Scrum Gathering in 2006 I put forward the analogy of "Painting by Numbers" Architecture, which is my take on how Architecture should be handled on an Agile project. The basic premise is that the Architect has the overall vision of how the solution should hang together; what its basic composition should be, what the outline is and what attributes it has; but this view is of a very low fidelity; much like the outline of a "paint by numbers" picture. It's then the team's job to fill in the segments, sprint by sprint – in whatever colour, hue or order they decide upon; they are free to improvise within that segment.

I've been thinking about writing an exhaustive post on the subject for months, but then last week I watched Dave McKean and Neil Gaiman's extraordinary film MirrorMask. The DVD is packed full of great extras, but there was one that grabbed my attention; a blurry video of a conference Q&A session with the audience, where someone asks Mr McKean about his experiences doing the spectacular Computer Graphics (CG) work for the film. The response was fantastic and is pretty much a crystallisation of my thoughts on the "paint by numbers" scenario. I paraphrase his response below:

Yes, along with Andy, Richard, Una, Paul and Mike (and Keni at MEDC) – I'm here in Las Vegas partaking in Mix07 as well. We've just had breakfast and are setting up Twitter accounts before the keynote – so if you're interested in keeping up with what we're doing you can keep an eye on http://twitter.com/HowardvRooijen or if you want to keep up to date with what's happening at Mix 07 in general go to http://twitter.com/mix07/with_friends

A couple of weeks ago I pinged Paulo for some help about a WCF service I was writing – he solved the problem I was having and replied that he liked the unit testing pattern I was using for starting the WCF service and couldn't believe he didn't think of it. So I thought I'd blog it, just in case anyone else was interested.

Basically you create a internal ServiceHost wrapper class, which creates a new instance of ServiceHost based on the type of the WCF service you're trying to test; this wrapper class has two static methods exposed: StartService() and StopService() which, starts and stops the ServiceHost instance. If you are using the Visual Studio Unit Testing framework, in your unit test class you call StartService()in the method marked with the [ClassInitialize] attribute and StopService()in the method marked by the [ClassCleanUp] attribute. If you are using MBUnit or NUnit you would use [TestFixtureSetUp] instead of [ClassInitialize] and [TestFixtureTearDown] instead of [ClassCleanUp].

namespace Conchango.WebTwo.Services.Tests
{
   using Microsoft.VisualStudio.TestTools.UnitTesting;
   using System.ServiceModel;
   using Conchango.Services.Resourcing;
   using Conchango.Services.Contracts;
   using Conchango.WebTwo.CommonTypes.Resourcing;

   [TestClass] 
   public class ResourcingServiceTests
   {
      /// <summary>
      /// Start the Resourcing WCF Service so all subsequent
      /// calls made by the unit test use this connection 
      /// </summary>
      /// <param name="testContext">Current Test Context</param>
      [ClassInitialize()]
      public static void ClassInitialize(TestContext testContext)
      {
         ResourcingServiceHost.StartService();
      }

      /// <summary>
      /// Shut down the WCF service once all tests have been run
      /// </summary>
      [ClassCleanup()]
      public static void MyClassCleanup()
      {
         ResourcingServiceHost.StopService();
      }

      /// <summary>
      /// Search for people called "Howard" at Conchango - expect 2 matches
      /// </summary>
      [TestMethod]
      public void PeopleCalledHowardTest()
      {
         using (ChannelFactory<IResourcingContract> factory = new ChannelFactory<IResourcingContract>(string.Empty))
         {
            IResourcingContract client = factory.CreateChannel();
            People people = client.GetPeopleByPartialName("Howard");
            Assert.AreEqual(2, people.Count);
         }
      }
   }

   internal class ResourcingServiceHost
   { 
      internal static ServiceHost Instance = null;
     
      internal static void StartService()
      {
         Instance = new ServiceHost(typeof(ResourcingService));
         Instance.Open();
      }

      internal static void StopService()
      {
         if (Instance.State != CommunicationState.Closed)
         {
            Instance.Close();
         }
      }
   }
}

One other point of note; on the line:

using (ChannelFactory<IResourcingContract> factory = new ChannelFactory<IResourcingContract>(string.Empty))

the string.Empty is required in the ChannelFactory contructor otherwise the following Exception is thrown: "System.InvalidOperationException: The Address property on ChannelFactory.Endpoint was null. The ChannelFactory's Endpoint must have a valid Address specified."

Last November I attended the 2006 Scrum Gathering in Minneapolis along with fellow Conchangoens Colin Bird and Gavyn Dowst. It was a conference like no other I've attended; earlier last year I co-presented a session on Agile Architecture at the Microsoft Architecture Insight Conference with Simon Evans, where to be quite frank, the reception of talking about how two experienced architects had managed to deliver and continued to deliver business value, iteration after iteration, was frosty to say the least and in some cases downright offensive.

The reception these ideas and experiences received at the Scrum Gathering couldn't have been more different. Instead of being confrontational and pouring on vitriol in order to justify their own job or methodology, attendees of the Gathering were so open minded. More often than not the reaction was "Wow, my experience of doing X was completely different. How did you handle situations like Y?" Ideas were cross-pollinated and people came away with a myriad of new techniques to try.

There were a couple of things I took away from that conference; firstly that Scrum and Agile Methodologies are really crossing the chasm - large organisations are starting to believe in them and are trying to roll it out in a top down manner (I think the largest number I heard was 700 development teams) with varying degrees of success. Secondly, Scrum causes organisational change and business transformation, more and more practitioners are realising that there needs to be a programme level project for organizational transformation otherwise Agile project teams meet friction where they have to interact with any other part of their organisation, which severely hampers, if not cripples their productivity. The third actually has nothing to do with Scrum or anything Agile - it's actually the technique called "Open Space Technology" (OST) that was used to run the Conference.

Open Spaces Technology

Open Space Technology was created in the mid 1980's by Harrison Owen who had spent a year of his life organising an international meeting with over 250 delegates; the overwhelming feedback from the delegates was that they all enjoyed the coffee breaks more than the keynotes because the breaks allowed them to interchange ideas. He was asked to arrange the event again the following year and while pondering if there was a fundamental mechanism for organising a successful conference, he remembered his experience of witnessing tribal meetings in Africa; where the circle is a fundamental form of communal meetings; if people are invited into a circle they will participate and communicate – a circle has no beginning, no end and no hierarchy.

Conferences run using Open Space Technology are different – there are no keynotes, no panels, and no pre-announced schedule; instead the Open Space Technology relies on self-organisation and is a vibrant mix of order and chaos. It can be used for any type of meeting; from envisioning to conflict resolution and it's been proven to work with 5 – 2000 delegates for 1-3 day conferences.

Anatomy of an Open Spaces Session

If you walk into an conference or meeting run using OST you'll probably find yourself in a large room with a circle of chairs in the middle (or if there are lots of delegates it will be a spiral or series of concentric circles of chairs). In the corners of the Room you'll probably see flip charts and on one of the walls you'll probably see a matrix of post it notes – this is called the Agenda Wall. When an Open Space Conference starts the delegates sit on the chairs in the circle. The first person to speak is The Sponsor – who will outline the context for the session and their hopes and expectations. For the Scrum Gathering our theme was "How do we sustain the values and principles of Scrum as we adopt the practices in our organisations?"

Next The Facilitator speaks to the delegates from the centre of the circle; they reiterate the theme and explain the process of Open Space Technology; that the agenda wall is a matrix of times and locations which can be used to host discussion groups:

Anyone can create a discussion group – all they – The Host - have to do, is take an index card, write the title of the discussion on it – assign it to a free time / space slot on the agenda wall and then announce it to the rest of the delegates.

Those who are interested in participating in that discussion should initial the card to signify their interest.

The Facilitator also has to and explain and ask the participants to adopt The Principles of Open Space for their discussion groups:

1.    Whoever comes are the right people
2.    Whatever happens is the only thing that could have
3.    When it starts, it starts
4.    When it's over, it's over (and when it's not over, it's not over)
5.    The Law of Two Feet – If you are not learning or contributing where you are, use your two feet to take yourself someplace where you can learn or contribute

Next the circle is disbanded and discussion groups convene in their allocated location, at the allocated time. The Host of a discussion group asks for a volunteer to act as The Note Taker, who captures the conversations on the flipchart while The Host facilitates the discussion. Once the session has ended – it's The Host's responsibility to turn the notes into a more permanent record of the session and so that people who couldn't attend because of a conflicting sessions can have an overview; at the Scrum Gathering we had a dedicated wiki that was used as the permanent record for both Wednesdays and Thursdays sessions – the benefit of this is that it can be opened up to the wider community who could not attend the Open Space; one of the discussion groups Gavyn and I attended was called "The Managers Role in Scrum", hosted by Jens Ostergaard. Since then, the topic has been picked up by Jeff Sutherland and continues to evolve. Another example of this happening is that Gavyn and I ran a session on "Testing in Scrum" although the turn-out was small because we were scheduled against Colin's ridiculously popular "Scaling Scrum" discussion group, some great experiences were shared and ideas were crystallised and were published in Gavyn's series of blog posts "Testing in Agile" parts one, two and three.

If the event is a multi-day affair then there will be "check-ins" in the morning and afternoon – where new sessions can be added to the agenda wall – this allows new ideas to be spun out of discussion groups and elaborated on. At the end of the event the Space is closed by The Facilitator who invites the attendees to briefly share their thoughts, reflections, experiences or learnings.

Open Spaces Technology works so well when you're trying to discuss any complex topic, especially when there are passionate people involved. The fact that there is no pre-announced schedule means that as interesting ideas crop up, new discussion groups can be spun up, which allows people to discuss much finer grain topics than are usually discussed in conferences and because of The Law of Two Feet, you only get people who are willing to contribute and so the session are so much more vibrant. I'm hoping that we try and run a Conchango Community Day using Open Space Technology soon.

As Stuart eluded to in his summary of his adventures in 2006, I spent the majority of the year as the Development Lead for HMV working on their Digital Download Platform – we achieved a huge amount in 11 months (hence why I've been so quiet here); several updates to the HMV Digital Player, we created a new permanent music download store and finally a Media Centre Online Spotlight Store (I'm sure Richard Griffin will blog about this at some point as it was his "baby").

I'm particularly proud of the permanent music download store – we set out to create a rich Web 2.0 application which delivered a simple and interesting music purchasing experience. Much kudos goes to Mike Lewis for his designs and Max Choong for his User Experience work and the dedication of the HMV developers involved. We made the decision early on that we would use Atlas (now ASP.NET AJAX) to deliver the rich interactivity and today Rory pointed out that the site is featured as part of the ASP.NET AJAX Showcase.