Showing posts with label scrum. Show all posts
Showing posts with label scrum. Show all posts

Feb 23, 2015

Pragmatic Product Backlog Ordering

There’s a aspect to owning a product backlog that a lot of Product Owners struggle with; how do they handle all the little requests? All the relatively tiny, inconsequential backlog items, customer requests and minor improvements that in and of themselves have very little value, but combined have a lot of value in that they help improve the overall quality and polish of an application. These are the “white noise” items, the constant background hum of a Product Owner’s life and can be the main thing that Product Owners have to do that feels like administrivia and can in turn make them want to stop managing a backlog at all.

For most Product Owners setting the delivery order of items with obvious business value and significance such as key initiatives or small but critical fixes and improvements is fine. It’s something that they want to do, that they can grasp and put their heads around, something that makes sense to them, but when that same Product Owner is faced with a bucket load of tiny requests each with small individual business value, then it’s not uncommon for Product Owners to simply throw their hands in the air, and out them at the bottom of the backlog effectively ignoring these items because ordering them is simply too difficult. “I’m meant to order my backlog by value and return on investment, right?”, say the Product Owner, “but these tiny items feel more like shuffling confetti by size and weight and none of them are more important than all these other larger, more obvious items I have”. What they’re forgetting is that the confetti sized items have potentially massive value when looked at as a whole. They’re the paper cuts that people feel with a product, the little niggling things that combine to give a product an overall sense of incompleteness, and ‘not quite what I expected’ quality.

So let’s get pragmatic about backlog ordering then, shall we?

In Scrum, a Product Owner is tasked with optimising the value of a product and of working with the development team to ensure maximum Return On Investment and a low Total Cost of Ownership. At the same time, an agile team should be learning constantly and aiming to be as productive and as efficient as they can be and spending a lot of time ordering these tiny backlog items is hardly efficient.  How can we achieve both goals, and maximise value whilst staying efficient?

What I’ve done with a number of Product Owners now is to ensure that the PO is ordering all the non-trivial Product Backlog Items in the backlog as per usual, and then developing a working agreement/convention with the development team for dealing with the tiny items. During sprint planning the development team uses about 80-90% of their forecast for the planned, deliberately ordered Product Backlog Items, and then grab tiny items from the backlog until they think they’re good to go.

imageIn terms of managing this via the backlog, we still keep a single backlog (duh!), but organise it into sections. The top section are the loosely planned product releases, with items specifically ordered in the releases. Obviously, if the product doesn’t have releases and is deployed continuously or very regularly then the top section is simply the collection of product backlog items that are explicitly planned. This section is then followed by the “tiny items”. These items are also ordered, though ordering is done via conventions or rules* so that no manual ordering is required. Finally, we ensure that the development team and Product Owner are clear that items from the release section of the backlog are the more important. Should something happen during the sprint that requires scope to be removed from the sprint, then it will be the tiny items that are taken out first as they are lower in value than the planned items.

Of course, if the Product Owner specifically wants a tiny item worked on, they simply move it into the planned and ordered Release backlog section, just like every other item that they have placed there.

At the end of the day this doesn’t remove the responsibility from the PO to order the items or to focus on optimising value, but it does mean they don’t have to worry about ordering the metaphorical grains of sand in the jar, just the bigger rocks.

*P.S. For an ordering convention, I usually suggest alternating a small bug fix with a small improvement, then order by a value grouping such as Small, Very Small, Teensy, and then by date created, in descending order. As stated above, if the Product Owner wants a tiny item delivered in specific order, they just pull it up into the main explicitly ordered section.

Apr 11, 2013

Confessions of a Product Owner - Scrum Australia 2013

The Scrum Australia 2013 conference has just finished and I had the pleasure of delivering a session for Product Owners aimed at helping them improve what they do and identify some of the mistakes they may be making. A big thank you to those who attended and for making the session as interactive as it was.

As promised, I’m posting the slides from the session here. Just remember that the slides are an aid to the presentation and that the back half of the deck was designed for interactivity in the room, not for offline consumption. Regardless, here it is.

Apr 3, 2013

Why a Short Feedback Cycle is a Good Thing

n 1981, Barry Boehm published information on the cost of change in software at various stages of the development cycle. The following chart shows this cost curve:
image 
Boehm's Cost of Change Curve – 1981

This model has historically led the industry to believe that the most important thing we can do is “get the requirements right!”.  The thing is, the model above is somewhat incorrect. It assumes a traditional software development lifecycle is the only way software is built and that working software can only be used at the end of a project.  With the rise of agile development techniques this is no longer true and we can deliver usable software every week or two.

Also, from the chart, consider that bottom axis – time. Time here represents the length of the feedback cycle; i.e. how long it takes to realise a problem exists and that a change is needed. Time is the critical element in determining the cost of any change. The longer we go before realising we need a change, the higher the cost of that change.
In an agile approach, the short iterations of a few weeks or less result in a much shorter feedback cycle.

Scott Ambler published the following chart on the cost of change in relation to defect correction and the point in the development cycle where that defect is detected.  Again, the longer the feedback cycle the higher the cost of rectifying the problem.

image
Image via Scott Ambler - http://www.ambysoft.com/essays/whyAgileWorksFeedback.html

So by using Scrum and putting in place good engineering practices alongside a short feedback cycle we establish a number of mechanisms that help us rapidly detect mistakes in both requirements and their implementation. This in turn allows us to take corrective action and fix the problem while it is still cost effective for us to do so.

In the end, this helps us keep our application quality high and provides better value to our end users and customers.

Jan 25, 2013

A Scrum Reading List

When I run one of my Scrum.org classes I’ll often mention various books that I’ve found useful and students will typically jot down those book names for looking up later. When one of the students in a class I did recently asked for links to all the books I mentioned I thought to myself “Why didn’t I have that list handy?” So, after that #facepalm feeling passed I organised myself and put together an Amazon ListMania list for future reference. Here it is for your perusal.

Richard’s Scrum Reading List

Enjoy!

Jan 22, 2013

Oh dear. Another Waterfall #FAIL…. to the sum of $1.3 Billion

Have a read of this article on the NYTimes - http://www.nytimes.com/2012/12/09/technology/air-force-stumbles-over-software-modernization-project.html about a failed US Air Force project. Failed to the cost of US$1.3 Billion, 6 years and with nothing to show for it. Nada. Zip. Diddly squat. Zero.

austin_powers_mike_myers_as_dr_evilTake a few moments to get over that sick feeling you have in your stomach and then ask yourself “When will people learn?”

I’m still shaking my head over this article.  And more so over statements like “did not succeed in imposing the short deadlines of 18 to 24 months”. 2 years is short? Seriously?

What about this; “We’ve never tried to change all the processes, tools and languages of all 250,000 people in our business at once”? Or this; “We started with a Big Bang approach and put every possible requirement into the program, which made it very large and very complex,”. It appears people still haven’t learned that the only thing you will likely get from a big bang approach is a loud explosion, lots of smoke and debris and, if people are involved, there’s usually plenty of blood on the walls. There’s always people involved.

Unfortunately I know of far too many projects right now that are still taking the big bang approach and hoping it will work. Note that key word there – “hoping”.  Hope, as one of my former CEO’s used to love to say, Hope is not a business strategy.

Companies should be learning the painful lessons of other organisation’s #FAILs and taking on more agile approaches.  Steve Denning has put together an interesting write up of the whole fiasco and the organisational impediments that prevented such an approach from being undertaken let alone being successful. Maybe the scale of waste in the project will be just the catalyst the military needs to genuinely improve, and maybe people will learn that COTS like Oracle or SAP or any of those consulting-ware packages combined with old-school systems integrators like CSC really aren’t worth the money they charge.  Then again, maybe not. #sigh

Sep 3, 2012

An Exercise in Analysing Estimates

I’m currently coaching an organisation undergoing a Scrum implementation and we’re having some problems with velocity within teams and the consistency of estimates across teams.  The teams are delivering well, but velocity is a little choppy and the teams are feeling a little blind as to their true rate of progress.

As an exercise we looked at the stories the teams sized up and took on across a few sprints, and we looked at their estimated effort for each story once they did the task breakdowns and had built their sprint backlog.

The Data

Here’s what we saw after a few sprints:

Team 1

Points Avg Estimated Time Standard Deviation
3 2.5 1.32
5 2.67 1.89
8 7.67 3.25
10 9.75 1.77
13 9.67 7.23
20 19.86 9.33
30 22 0

 

Team 2

Points Avg Estimated Time Standard Deviation
3 2 .71
5 8 0
8 9.5 4.69
13 23.5 16.99
20 44.67 9.29

 

Before you measure, understand the goal

The temptation when looking at any numbers here is to over analyse things and fall into the trap of “we need better estimates” and forget about the true aim of any Scrum Team, which is to deliver creatively and productively deliver business value to your customers.

The primary goal is always delivery! Not better estimates. The only reason we estimate in the first place is to help our product owners forecast when items are likely to be completed.

With that said, if we have bad estimates we will have bad forecasts and unhappy product owners and customers.  We would like to have reasonable estimates so that we have reasonable forecasts, but not if it means we spend so much time estimating that we forget to get out there and build some awesome stuff that makes people happy.

The purpose of this exercise is to improve our understanding of the estimates we are providing, But remember, better estimates are a secondary objective and inconsequential compared to the prime objective of delivery.

When scaling, should teams have a consistent baseline?

Both teams are working on the same product, though in different areas of the product to avoid stepping on each other’s toes.  Initially each time has sized the work they are doing using individual product backlogs.

Do they need to have some level of consistency between teams? Maybe – maybe not.  In my customer’s case they would like that consistency because they’re having trouble knowing how long things will take and are having trouble forecasting using the velocity numbers from each team.  While at the moment the teams are fairly separate, this may not always be the case and if the teams end up working on the same area of the product it would be nice to know that if Team 1 sizes something at 5 points that Team 2 would size the item at 5 points as well.

If the teams stayed distinct all the way through development, this consistency wouldn’t be required.

Cross team sizing comparison

Look at the estimated effort for a 13 point story in Team 1.  It’s about 10 hours.  The same 10 hours in Team 2 is an 8 point story.

Why the difference? Is it just because Team 1 is much faster than Team 2? Do they just have a higher velocity and are more awesome than the other team?

Is it because Team 2 is working on items that are harder than they estimated when they sized them?

Honestly, the numbers can’t tell you.  You would have to look beyond the numbers to see what’s going on.

In the case of my customer the two teams are roughly equivalent. Same team size, roughly the same domain knowledge and skill level. As such I would expect that both teams estimating the same sized items would come out with approximately the same number of hours for the effort involved.

When that’s added to the understanding of the numbers I’m inclined to think that Team 1 is simply estimating using higher numbers than Team 2.  This is not uncommon for teams starting with Scrum and learning to do sizing for themselves.  As long as they stay consistent, their team velocities will cancel out any “padding” of the story points they have done.

Relative sizing is “Relative”

Now we come to the more interesting thing we can consider in the estimate statistics and the one I’m much more interested in raising the awareness of within the teams.

Firstly, no team sized any 1 or 2 point stories.  This is a smell straight away for me and makes me think the team are padding their sizes.  After talking to the team, I know this to be the case and it’s something they’re having to unlearn.

Next, if we consider relative sizing then the difference between a 5 point story and a 20 point story should be about 4 times.

In Team 1, a 5 point story is 2.67 hours.  A 20 point story should be around 10 hours.  Instead we see that 10 hours works out to be around the 13 point size and the 20 point story is about 20 hours.  Almost 8 times the 5 point items.

Maybe it’s just that Team 1 didn’t use 5 as their “average” size story, but rather 8 points.  Let’s see.  An 8 point story is almost 8 hours.  OK.  So a 20 point story would be about 20 hours – not bad.  However the 13 point story doesn’t fit, nor does the 5 point story.

Only 3 estimate brackets?

In fact looking at the average estimates it would that the team can only estimate in Small, Medium and Large timeframes where small is about 3 hours or less (half a day).  Medium is a day (8-10 hours) and Large is 20 hours (2-3 days).  Again, this is not uncommon for teams starting out and something I’ll need to work through with the teams to help improve their understanding of what they are doing so that they can inspect & adapt.

What about Team 2?

Doing the same analysis of Team 2 we see that a 5 point story is 8 hours estimated work.  That means a 20 point story should be around 32 hours. Well, a 20 point story is 45 hours, it’s a difference, but not overly large..

However, the 5 and 8 point stories are fairly similar in size, so maybe the 8 is more akin to a “medium” story.  8 points is about 10 hours, give or take, so a 20 point story should be around 25 hours.  Now we have a size gap of almost 50%.  This is very similar to the behaviour we saw in Team 1.

Again, looking at the sizes it would appear that we have 4 obvious sizing ranges.  Small, 2 hours.  Medium, 8 hours,  Large, 3 days and Very Large, 5-6 days.

Why didn’t Team 1 have a similar Very Large story size in their estimates?  Likely because they recognized the Very Large story and broke it down into smaller items.

Why measure standard deviation?

You will have noticed that the stats have a standard deviation column.  This is so we can see the volatility of the estimated effort for the various story sizes.  For example the 13 point stories for Team 2 are all over the place.  A standard deviation of 16 hours is very large – that’s a 2 day variation in effort and likely indicates that the team is still learning what their story points feel like in terms of effort.

DON’T ABUSE THE NUMBERS – They’re just indicators

Now that we’ve looked at these numbers, what do we do with them?

We want to use them to Inspect and Adapt; to learn how to be better than we are today, but we must remember that the numbers are just indicators.  We may even be looking at numbers that are misleading.  If we pay too much attention to the numbers people will start to change behaviour to make them look better.  We don’t want the teams to start gaming the numbers since that would reduce visibility and transparency.

While the statistics would seem to indicate that the team do not completely understanding their requirements (the high standard deviations), or that they are padding estimates and still learning what relative sizing is all about, we cannot rely on the statistics alone.

We should take these numbers to the teams for their next retrospective and talk them through. Let’s see what the team can make of them and what steps they suggest for getting better at estimating.

Since these teams are wanting to improve, information like this can help.

Given the estimate size bandings one suggestion for the teams is to move away from story points for a time and adopt T-Shirt sizing instead.  Given they have already got this with their Small/Medium/Large time breakdowns it may help them with their estimating in the short term and then we can revisit the points approach in later sprints once they have a better understanding of themselves and what they are estimating.

The final thought: It’s OK to look at your statistics.  Learn from them, but don’t be ruled by them.

Mar 15, 2012

What do I do With Partially Completed Stories in Scrum?

It’s not that rare an occurrence for a scrum team to get to the end of a sprint and find that they have one or more stories that don’t meet the definition of “Done!”.

Question

This week from one of my former Professional Scrum Master students asked me about this situation:

”What should we do with un-done work at the end of the sprint?
I was thinking we have two options:
1) Move the user story to the backlog for re-prioritisation (maybe into the next sprint).  The problem here is that I’m not sure what to do with the story points as it screws up our sprint velocity
2) Split the user story.  In this case we would leave the old user story’s points as-is, then create a new user story with the remaining work and re-estimate with planning poker.
I was reviewing the scrum.org scrum guide and it doesn’t seem to have any details in this area.”

Answer

The lack of detail in the scrum guide should be enough indication on the approach to take. If the scrum guide doesn’t talk about splitting stories then it’s probably reasonable to assume you shouldn’t do it :-)

Putting the story back on the backlog for reprioritisation.  Sure, you won’t get any credit for the story in the current sprint because it’s not done, but it won’t screw up velocity either because velocity will be a true reflection of what you actually delivered during the sprint.  We want velocity to measure our rate of delivery not our effort. On average, over a number of sprints the velocity figures will average out in any case.  So yes, you may well have a few peaks and troughs when looking at single sprints but looking across the last 3 to 5 sprints you should have a good reflection of your actual rate of progress.

Not having a story finished and getting no credit for it also gives the team something to talk about during the retrospective. “Why didn’t we get to ‘done’ on story X?”.

On the flip side, I don’t like splitting incomplete stories because

1. it gives teams an “out” for not finishing properly and they get credit for effort not delivery. It stops them pushing for a goal and stymies the inspect and adapt process.

2. how do you actually split the story that was almost finished?  Can you split it in such a way that the work that was “almost” finished meets the “done” definition?  Can you do it in such a way that your product owner is absolutely sure that the completed part of the story is Done and that their acceptance criteria are satisfied? Can you cleanly separate the business value delivered between the completed part and the incomplete part? I doubt it.

Taking an incomplete story and splitting it just to make it look like you have a stable velocity reduces transparency and hides the truth of what you can actually achieve from your product owner, your stakeholders and most importantly yourselves.  Don’t do it.

Oct 10, 2011

Scrum is Open for Extension and Modification

The title says it all really.

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

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

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

Scrum Extension Library and Submission Guide

Scrum Modification Submission Guide

Jan 31, 2011

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

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

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

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

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

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

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

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

Dec 23, 2010

Professional Scrum Master Course, Perth, Feb 2011

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

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

Aug 2, 2010

Technical Debt in Scrum Teams

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

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

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

-----

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

Examples:

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

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

-----

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

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

Jun 18, 2010

In Scrum the Team Size is 7 +/- 2. Not 50

I was talking to someone yesterday telling me about her previous employer and the scrum team they had.  I almost fell over when she said they had 50 people on their team at the time.  Surely that was 6 or 7 smaller teams right? No – just one team.

In fact there were so many people at the daily stand up that they used to pass around a microphone so everyone could hear!  However, things weren’t quite as bad as I might think because of pair programming.  Only one person in two actually had to talk because the second person in each pair would’ve just said the same as the first.  What about rotating pairs during the day? And even then, 25 people in a team is too large.  At that size it’s not a team anymore – it’s just a crowd.

Remember, it’s 7 plus or minus 2 for the ideal scrum team size.  Not 50!

Feb 11, 2010

The Professional Scrum Developer Course

Ken Schwaber (co-creator of Scrum) moved on from the Scrum Alliance last year to found the Scrum.org organisation specifically to meet some goals that differ in purpose to those of the Scrum Alliance.  To quote from the Scrum.org front page

Scrum.org is staffed by the developers of Scrum and the best Scrum practitioners in the industry, and was founded to:

  1. Help individuals assess their knowledge of Scrum and how it is used.
  2. Help organizations find the best training courses, coaching, consulting, and topical Q&A sessions to optimize their use of Scrum.
  3. Help Scrum teams and organizations learn how to optimize their Total Cost of Ownership for systems and products built using Scrum.
  4. Initiate innovative programs, such as the Certified Scrum DeveloperTM and Professional Scrum DeveloperTM, to accelerate the effectiveness of Scrum.

Note that last point.  The one that talks about the Certified Scrum Developer program.  It turns out that the Certified Scrum Developer trainer program has recently been formally announced on the Scrum.org web site.  You can read the full announcement for yourself but to save yourself a little time here’s the summary (quoting again)

The PSD program:

  • Has been built from the ground up specifically for developers
  • Focuses on both teamwork and on technical practice, because software development in the 21st century relies on people skills as much as on tech chops
  • Addresses head on the people and technical issues that I know other Scrum courses shy away from
  • Simulates a real working environment – no “chalk and talk”
  • Utilizes an innovative continual assessment model to support student development beyond the course

What’s even better is that there are actually two flavours of this course coming.  One for .NET developers and one for Java developers as the toolsets they use are quite different.

I’ve been fortunate enough to be a lab rat for the .NET version of the course and I really enjoyed it.  That said I should take a moment for some full disclosure; I’m looking to be a Certified Professional Scrum Developer Trainer so that I can deliver it publicly through Readify (my employer) in the near future.  Now that that’s out of the way I’ll continue :-) …

In my opinion the Professional Scrum Developer course does a really good job of addressing the issues that .NET teams have doing development in a scrum environment.  Being a .NET course it specifically targets TFS 2010 and Visual Studio 2010 as tools for supporting the scrum process and providing a platform for strong agile engineering practices.  Obviously you can use tools other than these for supporting your efforts, and I don’t want to open up arguments about which tools are best, however given the majority of companies have TFS and Visual Studio it makes sense to target these platforms as a starting point.  If there’s enough interest for delivering the course using other tools such as open source alternatives then maybe an OSS version of the course can be developed but for now, it’s the pure Microsoft stack.

From a process view point the course also provides students very practical hands on experience in the tools and scrum via a series of short sprints over a 5 day period to ensure that students get a feel for the rhythm of how scrum teams should work on a day by day basis and how the tools can support them in that work.  This is, I think, where the real value of the course lies.  I’ve seen too many teams who think they’re doing scrum or agile and who are so far from it that it’s laughable, yet they just don’t realise that they’re doing things wrong.  A course like this is a great way for these teams to see the mistakes in what they’re doing and to get some practical experience on how to do things right that they can then take back to their offices to improve what they’re doing and to get higher quality software into production on a more regular basis.

One other thing to note about this course is that students who get to the end of it aren’t automatically granted a Professional Scrum Developers certification.  They will have to pass an exam to prove that they know their stuff.  This is so much better than how past scrum related certifications (think CSM) have been run and adds some weight and value to the certification process.

I’m personally quietly excited that this is happening and I’m looking forward to being able to start training others in this area.  I’ll be post some more information about it as it becomes available.