Definition Of Done

An Exciting new Development

2012-12-10T00:36:00.001-08:00

I am excited to share that I am now an Accredited Trainer with the Lean Kanban University (http://www.leankanbanuniversity.com). This means that I can teach Kanban practitioner courses. The LKU is a great group led by David Anderson that is looking to help people learn and adopt the Kanban Method.

If you are interested in training I have a course schedule here (http://robmaherconsulting.eventbrite.com/) or please get in touch if you would like to organise training in a different location.

Visual Studio 2012 & Code Coverage

2012-06-27T20:30:00.001-07:00

Like Unit Testing, Code Coverage has undergone significant change in VS 2012. Mostly the changes have simplified the process from VS 2010. Want to see code coverage now? How about right click the test and select Analyze Code Coverage. Sure beats what you had to do in VS 2010.

NB This information is compiled from two Microsoft blogs plus my own tinkering. The blogs have more detail than explained here. Check them out at

http://blogs.msdn.com/b/visualstudioalm/archive/2012/06/19/visual-studio-2012-rc-what-s-new-in-code-coverage.aspx and

http://blogs.msdn.com/b/sudhakan/archive/2012/05/11/customizing-code-coverage-in-visual-studio-11.aspx

Licensing

Let’s get this one out of the way quick. Code Coverage is available in Ultimate and Premium editions. Moving on…

Scope

So how does the new coverage tool know what to include or exclude? There used to be the TestSettings file that was used to specify what to include / exclude.

The new tool includes binaries “as long as these binaries are a part of your solution, and get called by any of your test cases under execution”

Ok makes sense. But what about binaries that are not part of my solution? What if I have a file reference to a different binary. Well that won’t show up. If you want to see that included in your code coverage stats then you need to do some work.

VS2012 has a new file for this called a .runsettingsfile. This is an xml file that contains which binaries to include or exclude. In RC you will need to add a new xml file to your solution and name it something.runSettings. (extension is important here) The TestSettings file is not used anymore as that was bound to MSTest and would not support the new test runner plug in architecture.

You can then copy some boilerplate text into the xml file (I am sure that the tooling will be sorted by RTM), adjust what you want to include / exclude. Finally tell you solution to use the runsetttings file and hey presto, all should be good.

Putting it all together

So lets have a go. Suppose I have the following structure.

UnitTestProject A that has a project reference to SUT.dll. These two are in the same solution so all good so far. However SUT.dll has a file reference to Account.dll. Runing code coverage from UnitTestProject A gives me.

As you can see we only get the code coverage for UnitTestProject A and the SUT.dll. This is because they are in the same solution.

So we now right click our solution, add new item, xml file. Call it CodeCoverage.runsettings (first part of the name doesn’t matter)

Now add the following xml and save.

<?xml version="1.0" encoding="utf-8"?>

<RunSettings>

<DataCollectionRunSettings>

<DataCollectors>

<DataCollector friendlyName="Code Coverage"uri="datacollector://Microsoft/CodeCoverage/2.0"assemblyQualifiedName="Microsoft.VisualStudio.Coverage.DynamicCoverageDataCollector, Microsoft.VisualStudio.TraceCollector, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">

<Configuration>

<CodeCoverage>

<ModulePaths>



<Include>

<ModulePath>.*\\UnitTestProject1\.dll</ModulePath>

</Include>

<Exclude>

<ModulePath>.*CPPUnitTestFramework.*</ModulePath>

</Exclude>

</ModulePaths>

<UseVerifiableInstrumentation>True</UseVerifiableInstrumentation>

<AllowLowIntegrityProcesses>True</AllowLowIntegrityProcesses>

<CollectFromChildProcesses>True</CollectFromChildProcesses>

<CollectAspDotNet>False</CollectAspDotNet>



<Functions>

<Exclude>

<Function>^std::.*</Function>

<Function>^ATL::.*</Function>

<Function>.*::__GetTestMethodInfo.*</Function>

<Function>^Microsoft::VisualStudio::CppCodeCoverageFramework::.*</Function>

<Function>^Microsoft::VisualStudio::CppUnitTestFramework::.*</Function>

<Function>.*::YOU_CAN_ONLY_DESIGNATE_ONE_.*</Function>

</Exclude>

</Functions>

<Attributes>

<Exclude>

<Attribute>^System.Diagnostics.DebuggerHiddenAttribute$</Attribute>

<Attribute>^System.Diagnostics.DebuggerNonUserCodeAttribute$</Attribute>

<Attribute>^System.Runtime.CompilerServices.CompilerGeneratedAttribute$</Attribute>

<Attribute>^System.CodeDom.Compiler.GeneratedCodeAttribute$</Attribute>

<Attribute>^System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute$</Attribute>

</Exclude>

</Attributes>

<Sources>

<Exclude>

<Source>.*\\atlmfc\\.*</Source>

<Source>.*\\vctools\\.*</Source>

<Source>.*\\public\\sdk\\.*</Source>

<Source>.*\\microsoft sdks\\.*</Source>

<Source>.*\\vc\\include\\.*</Source>

</Exclude>

</Sources>

<CompanyNames>

<Exclude>

<CompanyName>.*microsoft.*</CompanyName>

</Exclude>

</CompanyNames>

<PublicKeyTokens>

<Exclude>

<PublicKeyToken>^B77A5C561934E089$</PublicKeyToken>

<PublicKeyToken>^B03F5F7F11D50A3A$</PublicKeyToken>

<PublicKeyToken>^31BF3856AD364E35$</PublicKeyToken>

<PublicKeyToken>^89845DCD8080CC91$</PublicKeyToken>

<PublicKeyToken>^71E9BCE111E9429C$</PublicKeyToken>

<PublicKeyToken>^8F50407C4E9E73B6$</PublicKeyToken>

<PublicKeyToken>^E361AF139669C375$</PublicKeyToken>

</Exclude>

</PublicKeyTokens>

</CodeCoverage>

</Configuration>

</DataCollector>

</DataCollectors>

</DataCollectionRunSettings>

</RunSettings>

This is now a default runSettings file. Next we need to make sure that our extra binary gets included. To do this we can make sure that our Include section is empty (include everything.) Change the include section to look like

Finally go to the Test menu, select TestSettings, select TestSettings file. Select your runsettings file and re-run the code coverage. We now see

All of our binaries are included!

IntelliTrace Part 2 - Data Collection

2012-03-06T18:53:00.001-08:00

So lets get back to IntelliTrace. We are going to start out and see what it can do for us.

I talked a bit in Part 1 about what IntelliTrace was, so go check that out if you are unsure.

At an extremely high level, IntelliTrace works by collecting debugger state information during execution and saving it to a file. We will get into more of the detail later but that is enough to get us started. The data in this file can then be used to ‘replay’ the debugging session, step forwards and backwards and examine various information.

What does IntelliTrace collect

It’s important to understand from the beginning that IntelliTrace will not capture everything. The product group have had to balance performance considerations with the amount of data collected. So if you are expecting a full fidelity debugging experience with no performance loss you are going to be disappointed.

That said, the data that is collected is configurable and is tremendously useful. There are 3 main options around data collection.

IntelliTrace Events – This is on by default. Microsoft have defined 150ish events. This is instrumentation that they have added to the product. By default not every event is turned on for capture but the most common are enabled. To see this list you can go to Tools –> Options –> IntelliTrace and select Diagnostic Events.

So what gets captured at these events. Well, we will dig into more details later, but the short answer is “a small amount of data that is custom tuned to be relevant to the specific event being examined.” If you try and navigate backwards to see what happened exactly before that event you probably will see the IntelliTrace data not captured message. This is IntelliTrace saying – “sorry didn’t capture that.”
Later in this series we will see how this event data collection is configured. An example of this is opening a file. The file name is collected.

Calls Mode

When Calls Mode is turned on expect a performance hit. We are now instrumenting much more data and so this will come at a cost.

Calls mode instruments the entry and exit calls of every method in your code, including their parameters. Note that this is in addition to any collection based on IntelliTrace events. So you can expect to be able to see exactly which of your functions were hit, as well as what data was passed into them and what data they returned.

This collection works for one level of indirection for objects passed to/from the function. So you won’t get all the data for deep nested objects.

Debugger Break Points

If you had any break points set when you ran the application then these are also recognised by IntelliTrace and have special collection behaviour. At breakpoints IntelliTrace will collect local variable values and basic data types one level from objects (as with calls mode.) So at these lines you can open the locals window and see values! Breakpoints create a special type of IntelliTrace event called a debugger event (more on this later)

Choosing a Collection Option

So now we know what our options are, how do we select an appropriate collection level. Go to Tools –> Options –> IntelliTrace

You will see that by default, IntelliTrace is enabled and the collection level is IntelliTrace events only. In this dialog we can select Events and Call Information (Calls mode)

Obviously we can place a breakpoint anywhere in our code. Each breakpoint will enable local variable collection.

Where is the data stored?

This has changed in SP1. Previously, the default was to write to a folder on your drive. Now this is turned off by default. So once you have SP1, IntelliTrace will not capture files on your drive by default. To check your setting choose Advanced from the Tools – > Options –> IntelliTrace menu. Here is the default on my machine

You can see from here that the file collection is turned off. If we do enable writing files then from this dialog we can also limit the amount of space that these files should take up.

So do I need to turn this on in order to use IntelliTrace – no! The new default behaviour will capture the IntelliTrace information temporarily whilst you are in a VS session. At any point in that session you can decide that you want to persist the IntelliTrace file in order to return to it later, but the default is to delete the information. We will cover this later in the series.

So that about wraps up our default collection options. We now have an overview of what IntelliTrace is and how we can choose different collection options. Next time we will start collecting some data!

Craftsmanship in Corporate Software

2012-02-26T20:46:00.001-08:00

The software craftsmanship movement is gaining momentum. The idea that writing software is a craft is one that you may or may not agree with, but it is hard to disagree with some of the practices that the community promotes. There are conferences and a manifest0 here that outlines the intent.

So what practices are actually involved in the craftsmanship movement? Opinions are somewhat divided but most people will point to this book as a good starting point.

It is easy to see this as a collection of the best and brightest in the industry promoting the next big thing, that can seem unattainable if you are working for a big corporate. Deadlines, ‘heavy management’, ‘good enough thinking’ might be familiar friends. Sure, the people of the cusp of this are notable ‘big thinkers’ but this movement has become more than this, and there are ways to bring this into to your organisation.

I am not going to give you a definition of the practices that I think make up a ‘craftsman’ but writing SOLID code is a great start. But it’s more than that. In my view a couple of key points are:-

Encourage a learning culture
Practice

Encourage a Learning Culture

This isn’t about building a skills matrix or sending people on courses. This is about finding time to learn new things that could be brought into the workplace to make everyone better. Building this culture takes time and effort. Some / a few people need to lead it – note when I say lead I am not necessarily talking about managers. I mean organise, facilitate, prepare. This can be done by one / a small number of passionate people.

In my view, a learning culture means a supportive failure free environment. I don’t want to get all tree-huggish here, but these are important concepts. To me supportive means that people help each other learn. This is not about one ‘expert’ that does all the teaching. This will limit learning to the experience and expertise (not to mention bias) of that ‘expert.’ Supportive should mean that no-one is left behind. If they don’t get ‘it’ then they are helped to understand.

Failure free is really about the idea that no question is too dumb, and no-one is wrong. Think that something is a class not an interface great, lets have a discussion about it. Don’t think that there is any value in TDD – let’s talk. The most valuable insights can be gained from watching how other people do it or from disagreements.

Practice

If I am going to present a talk then I will practice speaking. If I ever had to play an instrument in public (god forbid) then I would practice. One of the tenets of craftsmanship is this idea that people should practice their craft. So for us that means practicing code and everything related to coding outside of working on a product / project.

How to do it?

Ok, this all sounds good, but how do we do it, and how much will it cost? There are three things that I would start with., and none of them should cost any money. Feel free to try one, two or all three depending on your organisation.

Communities of Interest

Form a community. No really – do it. Find a group of like minded people within your organisation. Send out a mail to all developers about craftsmanship and see who responds. Once you get off the ground others will join – I guarantee it.

Once you have some people who are keen to participate decide on what you want to achieve. Want to be better devs? Want to learn TDD, BDD, ATDD? Want to understand and write SOLID code? Once you have a community you can move on to..

Run a Coding Dojo

Huh? A what? A coding dojo is simply one way to achieve or practice a technique often using pair programming. There are lots of links out there but I would recommend this one for TDD. A good way to start is this.

Define your goals – what are we trying to learn e.g. TDD.
Work out some rules for the Dojo. Here are some example rules I have used in the past.

Coding challenge announced
Changes to pair every 10 mins
Everybody pairs
Stop when someone doesn’t get it
Design comments on green bar only
Do not add code if people are unhappy with design
Use TDD
Code in iterations

Define a backlog – the link above has a couple of great backlogs to get you started. You could use these backlogs as a sample to build your own, or in place to use any technique – estimation / sizing, TDD, BDD etc.
Get Started!

I usually recommend doing a dojo at lunchtime. Bring your lunch and code whilst eating. This way it costs nothing. I would definitely promote pairing as a great way to encourage shared learning. There is nothing like watching other people code to learn new things. If you have never paired before, who cares! Give it a try.

Run a conference

An internal education event. OK this one takes some money. It costs time which means it costs money. If the two things above have become successful then this can be a great next step. I would start small, maybe a couple of hours one afternoon. See if your management will give you that time (hey even if you make it up later) Get a few keen people to give 30 min quick talks on things that they are passionate about. It could be things that they have learning in dojos, or technologies that they code in at home. What’s important is that they are passionate and keen to present. I am sure that people who are not part of the community / dojos will want to attend.

If that is successful then do another one, until maybe you get a full day’s conference. If management won’t give you the time then run it on a Saturday. Trust me if people don’t want to / won’t give up their Saturday then the craftsmanship movement is not for them.

Call to Action

Email your colleagues, start a community. Try a dojo. Take responsibility for your own development. Trust me if you don’t no-one else will.

Looking to start a craftsmanship community in your organisation? Need some help? Get in touch at info@robmaherconsulting.co.nz

IntelliTrace Part 1

2012-02-11T23:03:00.001-08:00

IntelliTrace is one of the killer features in VS 2010 and yet seems to be one of the most under used.

Whenever I speak at user groups or events I often ask the audience who uses IntelliTrace.. Every time almost no hands go up. I am not sure if this is because it can be a bit difficult to learn or whether it hasn’t been marketed enough.

So this series is my attempt to provide a good overview of the feature set, where it works and where it doesn’t.

Over the next few posts I will drill into IntelliTrace, show how it works and how to get the best out of it

If you have any questions that you would like answered as part of this series please post a comment and I will make sure that I address them.

I am intending to collate this info into a presentation and present at Tech-Ed and some user groups.

Getting Started

Ok, so let’s ease our way into it. Firstly in order to view the IntelliTrace logs you will need Visual Studio 2010 Ultimate. So if you don’t have that, then you might want to download the trial edition if you want to follow along. You can download the trial here http://www.microsoft.com/visualstudio/en-us/try

What is IntelliTrace?

MSDN docs say that IntelliTrace provides an enhanced picture of your application compared with traditional debuggers. I would probably push the boat out a bit further than that and say that it is a fantastic feature that not only makes development easier, but help diagnose those ‘impossible bugs’. If you have VS Ultimate edition and don’t make use of IntelliTrace then you are really missing out.

In my view IntelliTrace is like 2 things. The most common example is a Flight Recorder (think the indestructible black box on an aircraft) The black box enables engineers to extract the data and ‘replay’ the flight as it happened using telemetry and instrument diagnostic data. Well IntelliTrace is very much like that. Deploy your software to test, turn on IntelliTrace and a log file will be generated. That file is your telemetry data. Using that file enables you to recreate what happened to your application. If you find yourself having to write a lot of Trace statements to understand why certain errors are happening you are going to love this.

So what else is IntelliTrace like. Remember the Tom Cruise movie Minority Report. Stay with me here. Tom Cruise used his hands to interact with data coming from psychic err something's. I am not talking about the flipping the hands to load a new scene, but how he actually goes backwards. He uses an imaginary dial and twists his hands left and right to go backwards and replay a scene. Well whilst you are developing code IntelliTrace is exactly like that. How many times have you gone through this cycle.

Add a breakpoint to some code that is not working.
F5
Hit your breakpoint and realize that you have gone too far and now need to start again from step 1.

And it could be worse, you could be manually updating variables, skipping statements etc., so starting again from the first step could be a big waste of time. This is where IntelliTrace comes in. You can use IntelliTrace to go back through the debug session to find the part you need. How useful would that be? You can examine the call stack, local variable values and return values from functions. So that cycle above should now be a thing of the past.

Excited, interested, not bored yet. Excellent. See you in Part 2.

Death, Taxes and Test Automation

2012-01-19T02:08:00.001-08:00

One of the most common issues that I encounter with Scrum teams involves testing at the end of sprint. It is easy to say test as you go, or Scrum involves doing all the SDLC activities concurrently. Unfortunately it is often very difficult for teams to achieve in practice.
Successful Scrum teams work like this.

However teams that are new to Scrum will almost always try and compress a traditional waterfall approach into their sprint.
So their Sprint looks something like this.

At the end there is a mad rush to finish testing, and the testers are often working long hours to get the testing finished. This often leaves testers wondering if Scrum is such a good idea..
Without help a lot of teams stay in this state indefinitely. I have been to companies where this is still the norm and the team are at Sprint 20. Often at this point the testers have stopped doing regression testing because they can’t keep up. So now there is an unknown amount of work to do when the Product Owner wants to ship the software. Are we really producing Done features?
It happens like this. Each sprint the developers can produce this many features.

This works fine. In Sprint 1 the testers can easily test those features. Now in Sprint 2 the developers produce that many features again. However the testers also need to make sure that the features delivered in Sprint 1 haven’t broken. So now there is this much testing to do.

(You can see where I am going with this) Fast forward to Sprint 10

Can the testers still keep up? At this point someone suggests that they save regression testing until the customer wants to release the product. The problem goes away and the pressure is off. Unfortunately the team is now simply accumulating technical debt that must be paid, and telling a Product Owner that features are done when they have not been tested will result in a lack of trust when the regression bugs arrive.
There is a famous quote about Death & Taxes being life’s only certainties. I would like to add Test Automation to that list. The only way out of the problem that I have outlined is through ruthless automation of manual testing wherever possible.
Test automation needs to be a religion in the team. It should be in the Definition of Done, it should replace manual test cases, and it should certainly be done by everyone in the team.
One technique that is proving very popular with teams right now is Acceptance Test Driven Development combined with Specification by Example. They are topics for another post, but the crux of the method is to write the automated test before the code. More to come on this later.
I am going to be as blunt as I can. If your team is not taking advantage of automation for your testing, at some stage your testers will be unable to keep up. At that point they will either drop regression testing or quit from exhaustion. As certain as death & taxes.
Does your team suffer from the mini-waterfall problem? Need some help with Test Automation or ATDD? Get in touch at info@robmaherconsulting.co.nz

Microsoft WebMatrix

2012-01-12T17:02:00.001-08:00

There seems to be so much coming out of Microsoft at the moment that it’s hard to keep up. One thing that you might have missed is WebMatrix.

WebMatrix is a lightweight IDE for building websites. It uses the Razor View Engine to make pages and the sites can be expanded to use full ASP.NET MVC later if required. It has a rock star package manager process (more on this later) and has some nice things out of the box like SEO hints.

There is a gallery with asp.net and Php (did i mention that you can build Php sites?) applications like Twitter helpers, BlogEngine.Net etc. It also ships with some basic templates like a store application.

So what’s different? Well the data access is well data access. No ORM, no config, no plumbing just access your data. It kind of feels nice to write queries again.

Rob Conery has a great write up of WebMatrix here. Here is a quote from Rob

var db = Database.Open("TDL");

var selectQueryString = "SELECT * FROM Articles";

shows = db.Query(selectQueryString, slug);

Hooray for SQL! OK stay with me – what this returns is IEnumerable < dynamic >. Which means that it’s typed on the fly – DUCK FRICKIN TYPING. Well sort of. I can now loop this comme ca:

@foreach(var show in shows){

The title is @show.title

}

That’s Razor in action – a terse, easy to love and understand markup for working in WebMatrix. The point here is that “show.Title” shouldn’t exist – “Show” isn’t a class anywhere in my project. This is the Groovy Dynamic Freakshow that’s built into C# 4.0.

You also get built in tooling for SQL CE (file based) which is downloaded with WebMatrix.

When you 0pen WebMatrix, you will see the box below

Choose templates and Starter site, give your site a name

Click Files

and open the Styles and css file and you will see the designer. It’s a little bit “I know that you are not a serious dev so I have made the font large and friendly” but stay with it. Have a look around it should be familiar

Package Mgr

Add an _admin to the end of your url when running in a browser and the package manager will appear

Once you have entered your password you can see what packages that you have installed. Here are mine

Change the dropdown to online and you will see

all of the packages that you can download!

Anyway I am just getting started – more to come!

Download it now and give it a try – Download WebMatrix

Creating a new TFS Report–Work In Progress

2011-12-19T00:11:00.001-08:00

Continuing our series on enhancing reports in TFS, I wanted something that focused on Work In Progress or WIP. Limiting WIP is one of the principles of lean thinking (and a guiding rule of Kanban systems.) Limiting WIP in Scrum teams can be an effective practice also.

One thing that I often notice when coaching Scrum teams is that the number of active or in progress user stories often matches the number of developers in the team. So rather than one team of 9 people, I often see 9 teams of one.

Trying to explain why this is not necessarily the only way to work leads to conversations about technical practices, swarming and encouraging team behaviours (but that’s another post entirely.
Monitoring the number of active user stories is good way to keep an eye on this. If the team is working together to take features to done then the number of user stories will be small. Some teams even try and only work on one story at a time (single piece flow) Depending on the complexity of these features that may or may not be appropriate. But certainly monitoring WIP is a good idea, as it can be a diagnostic indicator that the team could possibly improve its practices.

The MSF template (or the Scrum Template) do not ship with this type of report, so I have written one.

This report looks across the last month and charts the number of user stories that have active tasks as children, with a non-zero work remaining value.

This shows a trend of team behaviour. The report does not currently include bugs as WIP, but this is a trivial change to make. If desired the date ranges could also be made into parameters.
Here is a screenshot.

You can find the report here.

Need help with Team Foundation Server reports or technical practices. Get in touch at info@robmaherconsulting.co.nz

White paper published on Scrum.org

2011-12-17T00:40:00.001-08:00

The Scrum.org site has started showcasing more community content. I have the distinction of authoring the first whitepaper listed in the Community Work section.
Increasing Team Productivity
The whitepaper investigates productivity from different angles including project vs product teams, the impact of multitasking and impacts of matrix management structures.
Enjoy!

Looking for Scrum Training or consultancy? Get in touch at info@robmaherconsulting.co.nz

Another Professional Scrum Master course wraps up in Malaysia

2011-12-12T10:00:00.000-08:00

I am sitting in my hotel in Malaysia after finishing another PSM course with a great bunch of students in Kuala Lumpur.
I am always surprised at the level of interest and passion that the training invokes in students. We had a great two days with lots of laughs. I will always remember the ‘2 week sprint’ – sorry private joke I’m afraid – but you know who you are!
I have heard people say that the Asian culture is not suited to working with Scrum. I completely disagree. I have found that people embrace the Scrum concepts entirely and find no cultural barriers at all.
One of the things that the students here tell me they like most about the Scrum.org courses is the fact that they use the same content worldwide. So whether you sit a PSM class in London or Malaysia the course content is the same. Different instructors will bring different experiences to the course, but the material remains consistent. The feedback often cites this as a key reason behind choosing this course.
Well time to fly home soon. If you are based in Malaysia and would like Scrum training then I have a new public course scheduled in May – details here:-
PSM Malaysia

Looking for Scrum Training or consultancy? Get in touch at info@robmaherconsulting.co.nz

November Auckland .Net User Group meeting

2011-12-03T19:32:00.001-08:00

We moved to a new location for the November meeting – the Microsoft offices. This worked really well.

Thanks to Dave Dustin for a great session on the new Developer tools in the upcoming version of Sql Server.

Here is a shot from the event

Thanks again to Dave for presenting and to Microsoft for giving us a great venue. See you in Jan!

Creating a new TFS Report–Bugs added after done (or Regression Bugs)

2011-11-16T20:14:00.001-08:00

I have been thinking about different ways to promote and track quality practices and one aspect of that is bugs.

Lots of Scrum teams treat bugs differently. Some log every bug, some log only those found once a story is done. This can make it difficult to apply traditional quality measures to a Scrum team.

One metric that I think is worth tracking is bugs after done. What does this mean? Well once a story is finished it is marked as done (You are using a consistent definition of done aren’t you?)

If, as part of a later testing effort we discover a bug in the implementation of that story (either through a regression issue, or maybe we missed it first time during testing) then that might indicate an issue with our practices. If we find lots of these, then it is probably worth the team spending some time to understand why these are occurring. I decided that it would be nice to have a TFS report that could track the trend of these over time.

We are looking for a count of bugs that were active and linked to a user story (that was closed or resolved) trended against time.

Note – this will also identify any bugs that were raised against an open user story and then forgotten to be closed (even though fixed) I could omit these by also checking if the bug creation date was after the date the user story was closed, but I am happy to identify these also.

Writing this report will give us some good insights into the TFS_Warehouse database. We need to understand how the User Stories have changed over time, as well as how their child (bugs) work items have changed over time.

The Report

This is an idea of what the report should look like:-

You can see that we are trending the number of regression bugs over time.

The Query

This is the query that we will use in the report.

select
        allDates.DateSK as 'DateActive',
        coalesce(count(distinct insidewits.System_Id),0)
from
        DimDate allDates
left join

(select
        wi.System_Id,d.DateSK
from

        DimDate d
cross apply
        DimWorkItem wi
cross apply
        GetWorkItemsTree(@TeamProjectCollectionGuid, wi.System_Id,N'Child', d.DateSK) wit
left join
        WorkItemHistoryView wih_child
        on wih_child.WorkItemSK = wit.ChildWorkItemSK
inner join
        DimTeamProject tp on wi.TeamProjectSK = tp.ProjectNodeSK
where

        d.DateSK > DATEADD(month,-1,getdate())
        and d.DateSK < GetDate()
        and wi.System_ChangedDate <= d.DateSK
        and wi.System_RevisedDate > d.DateSK
        and wi.System_WorkItemType = 'User Story'
        and (wih_child.RecordCount != -1 or wih_child.RecordCount is null)
        and wih_child.System_State = 'Active'
        and wih_child.System_WorkItemType = 'Bug'
        and wi.System_State = 'Closed'
        and wi.System_Reason = 'Acceptance tests pass'
        and tp.ProjectNodeGuid=@ProjectGuid) insideWits

    on (allDates.DateSK = insideWits.DateSK)


    where
        allDates.DateSK > DATEADD(month,-1,getdate())
        and allDates.DateSK < GetDate()
group by allDates.DateSK

I will not go through it line by line. A couple of points to note – we are using the GetWorkItemsTree to get the particular state of workitems over time. We are also using the ChangedDate and Revised date fields to optimize our query as explained here. This is using Work Item Tracking compensating records to find work item dimension data quickly. This query shows us the data over the last month. Obviously you could adjust that or add it to the report as a parameter.

I have attached the finished report rdl here, for anyone who might find it useful. Stay tuned for more quality focused reports.

Scrum Trainer Meet up

2011-11-15T11:02:00.001-08:00

Right now I am in Redmond with a bunch of other trainers from Scrum.org talking all things Scrum and the future of Scrum.org and it’s programs. This is the second one of these that I have attended.

On both occasions I have been reminded about just how much these guys know about Scrum and all things agile. These are truly some of the world’s best at Scrum.

It has been a fantastic two days - exchanging ideas, planning the future and working out how best to invest our time and efforts over the next year.

It is great to get recharged, re-energized and excited about the coming year. Can’t say much yet but look out for some fantastic progress from Scrum.org this year.

Need help with Scrum? Need help implementing agile technical practices? Get in touch at scrumdod@gmail.com

Upcoming Courses

2011-11-14T16:27:00.001-08:00

I have some great courses lined up over the next 3 months or so. I have included some details below. If you are looking for some Scrum Training and are in SE Asia then have a look at these!

December 5-9
Bangalore, India
Professional Scrum Developer (.NET) Plus
Register >

December 12-13
Bangalore, India
Professional Scrum Master
Register >

January 9-10, 2012
Hong Kong, Hong Kong
Professional Scrum Master
Register >

January 16-17, 2012
Ho Chi Minh City, Vietnam
Professional Scrum Master
Register >

January 30 - February 3, 2012
Manila, Philippines
Professional Scrum Developer (.NET) Plus
Register >

Looking for Scrum training or consultancy? Need a private course? Contact me at scrumdod@gmail.com

Scrum Training in Malaysia

2011-11-13T14:41:00.001-08:00

I recently ran a Professional Scrum Master Course (PSM) in Malaysia. It was my first time in Malaysia, a fantastic place.

The students were all really engaged, we had some fantastic conversations about experiences and lessons learnt. The students all learnt a great deal from each other.

I am looking forward to heading back to Malaysia to run another course in a couple of weeks.

Here are some pictures from the course.

Good luck with Scrum!

Need help with Scrum? Looking for some training or consultancy? Get in touch at scrumdod@gmail.com

Speaking at the ALM Summit

2011-11-08T17:15:00.001-08:00

I will be part of the User Panel at the Microsoft ALM Summit in Redmond next week. The conference runs from Nov 14th-18th and looks fantastic.

There are lots of Dev 11 sessions as well as Hands on Labs – great for getting up to speed on the latest bits.

Hope to see you there!

I am now an ALM MVP

2011-10-02T16:20:00.001-07:00

Yesterday I received a fantastic email..

Congratulations! We are pleased to present you with the 2011 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others. We appreciate your outstanding contributions in Visual Studio ALM technical communities during the past year.

Thanks to everyone who has helped to make this possible. I am really looking forward to the next 12 months – a new version of Visual Studio, Team Foundation Server and Windows!

Build Deploy Test Enhancements

2011-09-13T21:13:00.001-07:00

I have put some more effort into the Build Deploy Test build xaml referenced in earlier posts.

There are a couple of bug fixes around failing the build if one of the deployment scripts return a non 0 value.

The main enhancement is using Build Quality to drive the promotion process of a build.

The target is this. A CI build compiles the product and runs unit tests. A BVT build (on a rolling schedule) picks up the last good CI build, deploys to a Dev server and then runs some automated BVT automated tests. (Think Integration, maybe some basic Acceptance tests.) If these pass then the original CI build quality is updated to BVT Tests pass.

Another build (maybe overnight) picks up the last good CI Build with a quality of BVT Tests pass and then deploys to a Test Server. This build runs a full automated suite. If these all pass then the build quality is updated to Tests Pass.

Finally another manual build could then be used to deploy that CI build to a manual exploratory environment to let the manual testers at it. This way we can guarantee that the environment used by the manual testers is high quality and not a waste of their time. The picture below illustrates part of this process.

Changing the build process

In order to support the scenario above a few changes have been made to the xaml. The parameters can now be seen below.

The new parameters are as follows.

Build Quality Filter – This is used to pick up a CI build of a certain quality. If we are the BVT build then this will be blank. If we are the overnight build then this will be “BVT Pass.” If we are the final manual build then this will be “Tests Pass”

Update Build Quality – This is the quality to update the CI build to, following a successful test run. e.g. if we are the BVT build then this is “BVT Tests Pass” etc.

I have included the xaml file and code here. The code includes the build xaml and some custom activities. Make sure to put these into the area of Source Control that your build controller looks to for custom code. More details on that can be found in my previous blog.

Happy Building!!

Code Camp NZ 2011

2011-09-06T18:08:00.001-07:00

Was a great event. I was a co-track lead for the Dev track and a speaker this year. We ended up with over 250 people attending. The Auckland Business School provided a fantastic venue. The lecture theatres were perfect for the sessions.

My BDD slides are on the Code Camp site at http://www.dot.net.nz/codecamp/Presentations/Forms/AllItems.aspx

Thanks again for all who attended.

Tech-Ed NZ

2011-09-05T17:16:00.001-07:00

Tech-Ed was fantastic this year.I gave two talks and really enjoyed them. They were back to back over lunch on Thursday so it was nice to get them both out of the way together.

Thanks to everyone who attended the sessions. The slides are up on the Tech-Ed site.

For anyone that is thinking about speaking at Tech-Ed or any other technical event here are a few tips that I found useful.

When you attend others presentations, rather than focus on the content only, watch how they present. It’s amazing how many different styles there are and how effective they can be. I learned a lot from other peoples sessions and tried to incorporate some techniques into my own talks. This is something that I will spend more time when I watch some of the recorded sessions.
Pick a topic that you are passionate about. You can deliver a lot of content in one hour, make sure that it is exciting to you, or your audience definitely won’t be excited!
Demos rock – People like to see live demos and they like to see them succeed.

This year attendees provided online feedback that was instantly available to speakers – nail biting stuff…

I hope to get the opportunity to speak again next year!

ADUG MVC3 session wrap up

2011-08-01T15:32:00.001-07:00

Thanks to everyone who came to the 2nd session of the ADUG. We had double the turnout – 36!!

Daniel Larsen (@DanielLarsenNZ) from Spendvision did a great session on MVC3. The feedback from a number of attendees was really positive.

So if you didn’t come along then make sure you do next time!

Thanks again Daniel.

Speaking at Tech-Ed NZ 2011

2011-07-31T17:29:00.001-07:00

I have had two sessions accepted for Tech-Ed NZ this year.

DEV313 Be the envy of your build buddies! (or How to implement a real world (non-CI) build in Team Foundation Server 2010 in 1 hour)

and

DPR201 Implementing Scrum and Team Foundation Server 2010 at a large New Zealand Insurance Company

Looking forward to it!

Test Impact Analysis does not work with WCF

2011-06-26T16:28:00.001-07:00

What! How can this be? Yes it’s true, after many hours testing and contacting several people at Microsoft I can confirm that TIA will not work with WCF. The WCF client side code works correctly however the WCF service server side code will not get picked up by TIA.

I got this response from a helpful source at Microsoft:-

in IIS scenarios, we use the proxy to help pair up a client's requests (with are tied to the executing test) with the code executing in the server even in the process of multiple clients testing the same machine. The design principle was to err on the side of under-reporting to avoid saying a piece of code impacted a test unless it was truly caused by the test and avoid pollution from other concurrent requests. To accomplish that we hook in to the requests coming into the IIS pipeline and check for the "dye" we inject in the http headers at the client with the proxy. If the request is missing the dye, we don't account for the data to avoid pollution. Only HTTP requests can inject dye. WCF requests, because they don't necessarily pass through the proxy or have headers to inject the dye into, do not. Therefore we drop the request data on the floor.

This behaviour is intentional.

Whoa!! This is a biggie for me. Next task is to try and get this feature requested in vNext!

Ken Schwaber is coming to NZ

2011-06-02T18:36:00.001-07:00

Ken ‘father of scrum’ Schwaber is coming to NZ in August to deliver two courses. He will run a Professional Scrum Master course on August 29-30th and a Professional Product Owner course on September 1st-2nd.

I am working with Ken to make this happen. Be in quick, the opportunity to learn from the source does not come along often!

I am also twisting Kens arm to present during his off day in the middle. More details to come.

To register for the courses go here.

PSM

http://courses.scrum.org/classes/show/180

PSPO

http://courses.scrum.org/classes/show/181

NZ Code Camp dates announced

2011-05-24T17:35:00.001-07:00

This year Code Camp will take place on the Sunday after Tech-Ed – 28th August.

It will be held at the University of Auckland Business School. This should be a great (and free) event. I am co-leading the Developer track and hoping for some great speaker submissions.