# Thursday, 21 April 2016

A few years before I left Microsoft UK to join RippleRock, I remember having a conversation with one of my future colleagues about RippleRock’s value proposition and their response was simply this:

“We will make your Agile project successful”

Now, of course they went on to caveat that this requires buy-in from the business among other things but RippleRock’s specialism in both Lean/Agile process and ALM/DevOps tooling give them a unique position among the Microsoft UK Partners.

Since I joined the team, RippleRock have continued to deliver on that statement but there is one thing that comes up project after project and that is the difficulty and inaccuracy teams encounter with gaining usable insight into their development process . On top of that, most organisations insist on reporting on metrics that will only drive the wrong behaviour and cause dissatisfaction in the team.

Some examples include:

  • How accurate are the team’s initial estimates?
  • How many bugs have the testers raised?
  • How many lines of code have been written?
  • Comparing velocity across teams
  • Cost per team/Story Point

This type of behaviour and the difficulty in authoring reporting (initially in TFS/VSTS but also in Jira etc.) caused RippleRock to develop SenseAdapt.  The name obviously comes from the tool’s aim which is to allow teams to ‘sense’ what is going on in their project and ‘adapt’ their process in order to improve things.

Some examples of what SenseAdapt is visualising for your team:

  • When will this project complete?
    • Based on real historical data and using Monte Carlo simulation to predict the likely range of completion dates.
  • How healthy is our backlog?
    • Are we working on the right things?  Have we given the team all the information they need to do their jobs?
  • How much ‘sludge’ is in our backlog?
    • Typically, there is lots.  This is work that never makes its way to the top of the backlog and will never be addressed, it just sits there, growing and demoralising the team
  • Where are the bottlenecks in our process?
    • How can we improve the flow of value to users

pasted_image_at_2016_04_21_06_26_pm

Figure 1: Currently available charts in SenseAdapt

Our clients have been using SenseAdapt for five months and the insights that it brings to teams and management is leading to real change in both process and project scope as they rely less on the current subjective reporting and groupthink.

Recently we came up with what I think is the perfect description of what RippleRock are enabling with SenseAdapt:

Process Telemetry

Whilst we use tools such as Application Insights and Dynatrace to monitor a running application or website, SenseAdapt monitors your development process and helps you to see and then take action to improve the system.

If you are interested in a demo or a trial of SenseAdapt or want to discuss what it could offer you then contact us.

If you are UK based then come along to our free event at Microsoft Campus in Reading on 6th May where we will talk about all this and much more.

More details and signup here:

Engaging the Business with Team Foundation Server: From Idea to Live – Microsoft Campus, Reading (Friday 6th May 2016)

More information on SenseAdapt available on http://www.senseadapt.com

Cheers,

Richard



.

Thursday, 21 April 2016 20:05:29 (GMT Daylight Time, UTC+01:00)  #    Comments [0]


# Friday, 10 July 2015

Are you adopting TFS 2013, 2015 or even Visual Studio Online?

Do you need to train a lot of staff members with different roles?  eg. developers, testers, scrum masters, product owners, stakeholders.

Is it difficult to allow team members to be out of the office for 2, 3 or 5 consecutive days at a training course.

RippleRock can customise a flexible TFS training course to suit you and if required combine it with consultancy, coaching and certification (eg. Certified Scrum Master, Certified Product Owner).

We typically deliver training onsite and configure the agenda and schedule to suit your requirements meaning it is a much more cost effective of training the right people on the right topics.

RippleRock are a Microsoft Gold Application Lifecycle Management Partner and our trainers are ALM Consultants with Microsoft Certified Solution Developer: Application Lifecycle Management

officiallogo     mcsd

As an example of potential topics:

Introduction and overview
  • What is Application Lifecycle Management?
  • What is Team Foundation Server?
  • Visual Studio Tools line up
  • Process Templates & Work Items
  • Choosing a Process Template
  • Understanding Team Projects & Project Collections
  • Client Access and Tools
  • Scrum Process re-cap
  • The Visual Studio Scrum Process Template
TFS Architecture & administration
  • Planning a TFS  Deployment
  • Installing Team Foundation Server
  • Migration/Upgrade considerations
  • TFS Administration Console
  • Setting up SMTP & Email Alerts
  • Monitoring Server Health
  • Backup and Restore
  • Administration via Command Line and PowerShell
  • TFS Security and Permissions
  • Rebuilding the TFS data warehouse and adding reports
Agile Planning
  • Agile Portfolio Management
  • Gathering requirements, estimation and prioritisation
  • PowerPoint Storyboarding
  • Backlog maintenance
  • Forecasting and release planning
  • Sprint Planning
  • Capacity Planning
  • Agile Boards (Task & Kanban)
  • Working with Teams
  • Team Rooms
  • Work Item Queries
  • Work Item Charting
  • Team Web Access Reporting
  • Stakeholder feedback
Agile Development
Visual Studio & Team Explorer   
  • My Work
  • Suspend/Resume
  • Code Reviews
  • Code Metrics
  • Code Clone Analysis
  • Unit Testing and code coverage
Team Explorer Everywhere
  • Cross platform version control
  • Automating builds with Nant or Maven
Version Control Basics
  • Choosing a Version Control System
    • Team Foundation Version Control Vs. Git
  • Version Control Settings
  • Check-in policies
  • Check-in notes
  • File types
  • Workspaces
    • Server Vs. Local
  • Check-in/out
  • Changesets
  • Shelving
Advanced Version Control
  • Branching & Merging
    • Branching Strategies
    • Branch Visualisation
    • Dealing with Conflicts
  • Viewing version control history
  • Rolling back code changes
  • Securing version control
  • Using custom difference and merge tools
  • Command line version control
  • Git fundamentals
Automated build introduction
  • Team Foundation Server Build architecture
  • Creating a build definition
  • Build triggers
    • Continuous Integration
    • Scheduled Builds
    • Gated Check-ins
  • Editing Build Parameters
  • Including unit tests in your build process
  • Queuing a build
  • Private Builds
Customising automated builds
  • Process customisation
  • Using 3rd Party components
  • Including PowerShell scripts
  • Versioning Assemblies
  • Cloning a build
  • Comparing Build Definitions with tfpt.exe
Agile Testing
  • Overview of test tools in Visual Studio
  • Microsoft Test Manager
    • Test Plans/Suites/Cases
    • Microsoft Test Runner
    • Exploratory Testing
  • Web Based Test Manager
  • Automated Tests (CodedUI) inc. cross browser
  • Microsoft Lab Management
  • Web Performance Test and Load Test
Microsoft Release Manager
  • Release Manager Overview and architecture
  • Licensing Release Manager
  • Integrating Release Manager with your build process
  • Creating a release
  • Using PowerShell Desired State Configuration
Team Foundation Server Reporting
  • How data flows through TFS
  • Out-of-the-box TFS reports
  • Team Web Access Reports
  • Work Item Charting
  • Work Item Reporting
  • Custom Excel Reporting
  • Custom SSRS Report
Customising Team Foundation Server
  • Understanding Process templates
  • Editing Process Templates
    • Process Template Editor
    • Witadmin.exe
  • Customising and creating Work Items
  • Working with Global Lists
  • Tailoring Agile Portfolio functionality
  • Editing the Team process
  • 3rd Party Tools and controls
  • Using the TFS API
  • PowerShell with TFS

Contact us to discuss your requirements and build a personalised training plan.

Richard



.

Friday, 10 July 2015 10:39:46 (GMT Daylight Time, UTC+01:00)  #    Comments [0]


# Friday, 12 September 2014

One of the Team Foundation Server Process Template customisations I do frequently is changing a project to make use of a custom team field rather than the default Area Path to scope Work Items to teams.

If you haven’t made use of teams in TFS 2012 or TFS 2013 yet then check out these links

Multiple Teams with Microsoft Team Foundation Server 2012 & Visual Studio Scrum

TFS 2013: Collaborate using team resources

If you don’t know what is involved in customisation then you need to check out this page.

Customize a team project to support team fields

Now, you can, as with any process update, make changes offline and any subsequent projects created using that template will see the changes.  Or, you can update an existing in-flight project with template changes. 

It’s not particularly difficult to change your template to make use of a team field but it is time consuming so I wrote a PowerShell script to do it both to save me time and to play around with using PowerShell to do XML transformations.

My script downloads the required files from a Visual Studio Scrum 2013 project, backs them up, performs an XML Transform on them and uploads them to your project.  If you are using a different process template then you will need to edit the XML transforms and the selected Work Item definitions but the technique is the same.

You can call the script Add-Teams.ps1 from the command line and provide 3 parameters

Add-Teams.ps1 “http://TFS2013:8080/tfs/DefaultCollection” MyProject “C:\TemplateUpdates”

Defaults are specified at the beginning of the script so if you plan to run it using PowerShell ISE for example, then simply change the values.

        #TFS Collection Url
        [string]$CollectionUrl =          "http://TFS2013:8080/tfs/DefaultCollection",
        #Name of the TFS Team Project to transform
        [string]$TeamProjectName =        "MyProject",
        #Working folder to store the XML transforms, downloaded files and backup
        [string]$WorkingFolder =          "C:\TemplateUpdates" 

There is some (hopefully) useful logging throughout the script which uses write-verbose, so if you want to turn it on then  give the script a –verbose flag when you run it.

The script

First we create a function called Transform-XML that takes an XML file and a transform file to apply.  We’ll use it to alter the Work Item definitions, the Process Configuration and add a Global List.


function Transform-XML 
{
     Param (
            [Parameter(Mandatory=$True)][ValidateNotNull()]$Wit,
            [Parameter(Mandatory=$True)][ValidateNotNull()]$Tfm
        )


Next, the necessary Work Item definitions (Product Backlog Item, Task, Bug, Feature & Test Plan) are downloaded from your project using WitAdmin.exe (usually found in C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\Witadmin.exe)


# Export Work Item definitions 
write-Verbose "Exporting PBI definition"
& $WitAdmin exportwitd /collection:$CollectionUrl /p:$TeamProjectName /f:$PBIDefinition /n:"Product Backlog Item"
write-Verbose "Exporting Task definition"
& $WitAdmin exportwitd /collection:$CollectionUrl /p:$TeamProjectName /f:$TaskDefinition /n:"Task"
write-Verbose "Exporting Bug definition"
& $WitAdmin exportwitd /collection:$CollectionUrl /p:$TeamProjectName /f:$BugDefinition /n:"Bug"
write-Verbose "Exporting Feature definition"
& $WitAdmin exportwitd /collection:$CollectionUrl /p:$TeamProjectName /f:$FeatureDefinition /n:"Feature"
# Required if using TFS 2013 Update 3 or later 
write-Verbose "Exporting Test Plan definition"
& $WitAdmin exportwitd /collection:$CollectionUrl /p:$TeamProjectName /f:$TestPlanDefinition /n:"Test Plan"

# Export Process Configuration
write-Verbose "Exporting Process Configuration"
& $WitAdmin exportprocessconfig /collection:$CollectionUrl /p:$TeamProjectName /f:$PCDefinition 

# Export Global List 
write-Verbose "Exporting Global List"
& $witadmin exportgloballist /collection:$CollectionUrl /f:$GLDefinition 

The we copy all the downloaded files into a backup directory.  If your Team project was called MyProject then all the files would be downloaded to C:\TemplateUpdates\MyProject and a backup would be copied to C:\TemplateUpdates\MyProjectBackup\110914.161115 where the date is 11\09\2014 and the time is 16:11 and 15 seconds.  This way, if anything goes wrong, you have your original files to upload.


# Create backup of process files 
write-Verbose "Backing up process files"
$timestamp = Get-Date -UFormat "%d%m%y.%T" | foreach {$_ -replace ":", ""}

Copy-Item -Path $ProjectFolder -Container -Destination "$($ProjectFolder)Backup\$timestamp" -Recurse -force

After that we call the Transform-XML function against the required files

try
{
    #Try transforming the required files and exit the script if there are any problems
    
    # Add Global List 
    write-Verbose "Adding Team Global List"
    Transform-XML $GLDefinition $GLTransform

    # Update Work Item Definitions to add new Team field and include on form 
    write-Verbose "Updating PBI Definition"
    Transform-XML $PBIDefinition $WITTransform
    write-Verbose "Updating Task Definition"
    Transform-XML $TaskDefinition $WITTransform
    write-Verbose "Updating Bug Definition"
    Transform-XML $BugDefinition $WITTransform
    write-Verbose "Updating Feature Definition"
    Transform-XML $FeatureDefinition $WITTransform
    # Required if using TFS 2013 Update 3 or later
    write-Verbose "Updating Test Plan Definition"
    Transform-XML $TestPlanDefinition $WITTransform

    # Update Process Template to make use of new Team field instead of AreaPath 
    write-Verbose "Updating Process Configuration"
    Transform-XML $PCDefinition $PCTransform
}

The XML transform for a Work Item looks like this for example


<?xml version="1.0"?>
<witd:WITD xmlns:witd="http://schemas.microsoft.com/VisualStudio/2008/workitemtracking/typedef" xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <WORKITEMTYPE name="Bug">
    <FIELDS>
    <!-- If the team field has already been added then remove it first-->
    <FIELD name="Team" xdt:Transform="Remove"  xdt:Locator="Match(name)" />
      <FIELD name="Team" refname="RippleRock.Scrum.Team" type="String" reportable="dimension" xdt:Transform="Insert">
        <HELPTEXT>Name of the team that will do the work.</HELPTEXT>
        <ALLOWEXISTINGVALUE />
        <ALLOWEDVALUES >
          <GLOBALLIST name="Teams" />
        </ALLOWEDVALUES >
        <DEFAULT from="value" value="Unassigned" />
      </FIELD>
    </FIELDS>
    <FORM>
      <Layout>
      <Group>
      <Column>
        <Group Label="Status">
          <Column PercentWidth="100">
          <!-- If the team field has already been added then remove it first-->
            <Control FieldName="RippleRock.Scrum.Team" xdt:Transform="Remove"  xdt:Locator="Match(FieldName)" />
            <Control FieldName="RippleRock.Scrum.Team" Type="FieldControl" Label="Team" LabelPosition="Left" EmptyText="&lt;None&gt;" xdt:Transform="Insert" />
          </Column>
        </Group>
        </Column>
        </Group>
      </Layout>
    </FORM>
  </WORKITEMTYPE>
</witd:WITD>


This adds a field called RippleRock.Scrum.Team to the Work Item and then adds a Field Control at the end of the Status group on the Work Item form.  I added an additional Remove transform for both elements so that if you run the script against an item that already has a Team field then it will be replaced.

Finally, we import all our definitions and we should be good to go.


# Import Global List 
write-Verbose "Importing Global List"
& $witadmin importgloballist /collection:$CollectionUrl /f:"$ProjectFolder\GlobalList.xml"

# Import Work Item definitions 
write-Verbose "Importing PBI definition"
& $WitAdmin importwitd /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\TypeDefinitions\ProductBacklogItem.xml" 
write-Verbose "Importing Task definition"
& $WitAdmin importwitd /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\TypeDefinitions\Task.xml" 
write-Verbose "Importing Bug definition"
& $WitAdmin importwitd /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\TypeDefinitions\Bug.xml" 
write-Verbose "Importing Feature definition"
& $WitAdmin importwitd /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\TypeDefinitions\Feature.xml" 
# Required if using TFS 2013 Update 3 or later
write-Verbose "Importing Test Plan definition"
& $WitAdmin importwitd /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\TypeDefinitions\TestPlan.xml"

# Import Process Configuration 
write-Verbose "Importing Process Configuration"
& $WitAdmin importprocessconfig /collection:$CollectionUrl /p:$TeamProjectName /f:"$ProjectFolder\WorkItem Tracking\Process\ProcessConfiguration.xml"


Remember to follow the steps in the “Configure Team Settings” section of the Customize a team project to support team fields to alter how Work Items show up on the team backlogs.

image

Download the script and the transforms here.

I hope it saves you some time.

Cheers,

Richard



.

Friday, 12 September 2014 07:00:00 (GMT Daylight Time, UTC+01:00)  #    Comments [0]


# Tuesday, 02 July 2013

Recently I’ve been working with a customer on migrating their existing Team Project to a new Process Template on Team Foundation Server 2012. 

We’ve decided to go with the TFS Integration Tools to move selected Work Items and code across to a new project in a new Team Project Collection.  There were a number of alternative options open to us but this is a large project that has been migrated through the versions of TFS and we’re going to take the opportunity to clean it up and consolidate.

I spent some time mapping their existing Microsoft Solutions Framework for Agile Software Development 6.1 project to Microsoft Visual Studio Scrum 2.2.  I had to take into consideration some custom fields that had been added to the template and also some legacy fields that had been left hanging around after previous migrations.

The customer is not a heavy Visual Studio user, doing most of the development through Eclipse and as a result they are licensed for Visual Studio Professional 2012.  In turn this means that their developers have “Standard” licenses for Team Web Access

As part of the work we have been doing to transform their development process we have a need to use both the Product Backlog view and the Kanban board, both of which are only available to users who are “Full” licensed users of TWA. 

The cost of upgrading the developers to Visual Studio Premium was prohibitive as they will not make use of the additional Visual Studio features and the current Microsoft licensing did not give us any other option.

I evaluated both Urban Turtle and the Eylean products and although they both have their plus points and are very economically priced, neither gave us exactly what we were looking for.

Last week at the Build Windows Conference, Microsoft released a Preview of Team Foundation Server 2013 which also has a Go-Live license

Ordinarily it would be a pretty gung-ho decision to move your business onto pre-release software but in this case it is worth considering.  The reason is that Microsoft have listened to the feedback and re-jigged the licensing for TWA. 

TFS2013 now provides both the Kanban Board and the Backlog & Sprint Planning Tools to “Standard” users (VS Pro) and rightfully provides some very cool additional features (Portfolio Management, Team Rooms, Test Case Management, Feedback Management) to “Full” users (VS Premium, Ultimate & Test Pro

 clip_image002  

TFS 2012 Team Web Access Levels

TFS 2013 Preview Team Web Access Levels

As a result, there is a strong case to move the project to TFS2013 and although the decision on which way to go has not been made yet, I was worried that the TFS Integration Tools mapping that I had written would need a lot of work to update it for the Microsoft Visual Studio Scrum 3.0 Template.

I downloaded the Scrum 2.2 and Scrum 3.0 Templates and performed a Diff on the folders.

image

There were some minor build changes and some changes to allow for the new Git support but I was particularly interested in the Work Item and Reporting changes. 

Release Burndown report – Order by Iteration Path

image

Minor change but hopefully a helpful one as I have run into this problem before and presumably this small change to the rdl file will resolve it.

New Category – Feature Category

image

New Work Item Type - Feature

image

Both of these have been added to support the new portfolio management functionality in TWA.

And that’s it, so there are no field changes to the core Work Items.  Obviously it is still a Preview version of the template but it shouldn’t change significantly and I can make any tweaks if it does.

If you’re in a similar position in that you would like some of the “Full” features from TWA 2012 but the Premium upgrade does not make financial sense then TFS 2013 could give you what you need.

Cheers,

Richard



.

Tuesday, 02 July 2013 14:56:08 (GMT Daylight Time, UTC+01:00)  #    Comments [0]


# Wednesday, 01 May 2013

Are you using TFS 2012? 

Are you using or adopting Scrum?

Then get the most out of your tools and your process by attending a 2-day Certified ScrumMaster course with a free one day Scrum with TFS course.

The CSM course is taught by our Certified Scrum Trainer, Colin Bird, and I will be helping out with the optional, free third day which will give you hands on experience with TFS 2012, putting into practice what you have learned in the first 2 days.

The course will be held on Microsoft Campus in Reading on the 21st May – 23rd May

More details available here or you can register here.

If you hurry you can still get the discounted early bird price!

Cheers,

Richard



.

Wednesday, 01 May 2013 15:32:10 (GMT Daylight Time, UTC+01:00)  #    Comments [0]


# Friday, 19 April 2013

It’s my pleasure to be part of Microsoft UK Tech Days Online 2013 which is happening next Wednesday (24th April 2013).  It’s shaping up to be an excellent 3-day online event for both developers an IT Professionals with some really interesting areas being covered.  Day One is aimed at the development community with sessions on targeting Windows 8 and Windows Azure alongside Team Foundation Server and Application Lifecycle Management.  The day starts at 09:20 BST 

Introduction to Tech Days Online
Developing in Visual Studio, what's changed in the last 12 months?
Developing for Windows 8 with Visual Studio 2012
Interview with Planky/David Gristwood - Visual Studio Tools with Windows Azure
Being Agile with Team Foundation Server 2012
TFS for everyone – Using TFS in a heterogeneous project (Eclipse, Java and using Git-tf)
Upgrading to Team Foundation Server 2012
Testing enhancements in Visual Studio 2012 Update 1 and Update 2
“The Thrill of the Hunt” with Exploratory testing in Visual Studio 2012

I am hosting two of the sessions and I’ll be around to answer questions live on the day.

12:00  Being Agile with Team Foundation Server 2012

Team Foundation Server 2012 introduced a number of excellent features and capabilities to help enable your agile team to plan, manage and track their work. This session will introduce the tools and provide details on how to get the best out of them.

15:40  Testing enhancements in Visual Studio 2012 Update 1 and Update 2

Visual Studio 2012 Update 1 and the newly released Update 2 have introduced some exciting new features and functionality to the core testing tools.  This session will demonstrate the new web based Test Case Management, cross browser support for Coded UI Testing and Microsoft Test Manager improvements.

You can register for this event here and it’s worth doing even if you can’t make it on the day as we’ll follow up with resources and recordings of the sessions.

Cheers,

Richard

.


Friday, 19 April 2013 14:53:25 (GMT Daylight Time, UTC+01:00)  #    Comments [0]