2009-06-16 Agile in the Large

Managing a portfolio of agile projects presents a unique set of challenges.   At this session, we will spend time exploring agile portfolio management, the cornerstones of agile project status reporting, managing multiple products within a small team, and operating an agile team within a non-agile organization. The discussion will also include the motivations and evaluation metrics of business benefit, Return on Investment financial models and financial reporting requirements. 

Date:  Tuesday, June 16th, 2009
Time:  4:30 to 6:00 pm
Location: McAfee Canada Inc.
565 Kumpf Drive
Waterloo
Free Parking

RSVP is required wanda@communitech.ca

Sessions planned for the rest of the year

Our planned sessions run through to the end of August. Here are the sessions plans to date:

Date	Location	Topic
June 16	McAfee	Agile in the Large Agile portfolio management Performance metrics
July 21	TBD	Lean Software Development Guest speaker : Phil Kirby – Thoughtware
August 18	TBD	Agile Tools Each tool presented by current user/vendor Interest from Rally, AgileBuddy

2009-05-19: Coding Dojo Results

Thanks to everyone that came out to the coding dojo; especially anyone who did some codin’!

It was the first time doing this for everyone and I thought we did rather well. We ended up with some pretty slick C# code for parsing Roman numerals:

using System;

namespace RomanNumeralsCodingDojo
{
  public class RomanNumerals
  {
    public long Value { get; private set; }

    public RomanNumerals(string value)
    {
      for (var i = 0; i < value.Length-1; i++)
      {
        var charValue = Parse(value[i]);
        var nextCharValue = Parse(value[i+1]);

        if (charValue >= nextCharValue)
          Value += charValue;
        else
          Value -= charValue;
      }
      Value += Parse(value[value.Length-1]);
    }

    private static int Parse(char romanCharacter)
    {
      return (int) Enum.Parse(typeof (RomanCharacters),
                        new string(new [] {romanCharacter}));
    }

    private enum RomanCharacters
    {
      I = 1,
      V = 5,
      X = 10,
      L = 50,
      C = 100,
      D = 500,
      M = 1000,
    }
  }
}

You can download the C# solution with unit tests here.

QA groups (local)

Here are a couple of links mentioned at the last meeting, so if you are looking to hook up with fellow QA folks check groups out.

• Kitchener Waterloo Software Quality Association (KWSQA) http://qualityconference.ca/ 
• Kitchener, Waterloo, Cambridge, Guelph Quality Assurance Group on LinkedIn http://www.linkedin.com/groups?about=&gid=1835348&goback=%2Egdr_1242163182206_1

2009-05-19 Test Driven Development/Design

This upcoming Communitech Peer 2 Peer session will be “coding dojo” where participants will apply test-driven development on some real code in real time. 

This will be valuable to anyone interested in agile development and automated testing, but will be of particular value to developers interested in TDD. This will be done in C# using Visual Studio 2008 and developers at all levels and experience are encourage to come out.

 Date:  Tuesday, May 19th, 2009
Time:  4:30 to 6:00 pm
Location: Accelerator Centre
295 Hagey Blvd, Waterloo
West Entrance – Room 2
Free Parking

RSVP to wanda@communitech.ca

Books on Agile Testing

Here are some good books on Agile Testing:

Agile Testing A practical guide for testers and agile teams Lisa Crispin, Janet Gregory	This is a recent book and is a comprehensive and insightful view into all aspects of testing on agile teams. Highly recommended.
Bridging the Communication Gap Specification by example and agile acceptance testing Gojko Adzic	Gojko provides a solid treatment of using examples to drive specification, understanding and development of user stories. A focus is on agile acceptance testing through executable specifications of concrete examples.
xUnit Test Patterns Refactoring test code Gerard Meszaros	A thorough book covering everything you need to know about writing tests for the xUnit tools. Highly recommended for any developer using xUnit.
Fit for Developing Software Framework for Integrated Tests Rick Mugridge, Ward Cunningham	This book provides a great introduction and all you need to know to get up and going with Fit. Fit is a tool for writing “business facing” or acceptance tests.

2009-04-21 Testing in Agile – a QA’s journey

 

Join us at this exciting session as Greg Phillips, Director of Quality Assurance at Innosphere leads off this session with a case study discussing some of the following points:

 

1)     Transition from waterfall to agile

2)     How QA currently works in an agile environment

3)     What can be done to improve the process going forward

 

Come prepared to share your thoughts as with past session, there will be a lot of opportunity for open discussion.

  

Time:  4:30 to 6:00 pm
Location: Accelerator Centre
295 Hagey Blvd, Waterloo
West Entrance – Room 2
Free Parking

RSVP to wanda@communitech.ca

Challenges with Agile Stories

This post is the result of group notes on:

“How do we get from stories to effect story tests?”

1. Use a template for stories

As a <role> I want <feature>so that <benefit>.

2. Describe the feature and break down into logical groups or “stories”

3. Elaborate stories with concrete examples that become “acceptance tests”

Acceptance tests are:

• not a substitute for unit tests
• different from UI testing
• focused on business rules

4. Tools for Test Automation

• Fit/FitNesse
• xBehave (e.g. nBehave, jBehave)
• xUnit

Fit example:
Story: As a user, I want to see full names, so that the screens are easy to read.

Story Test: I enter the first name “Joe”, last name “Smith” and I then see the full name “Joe Smith”.

First Name	Last Name	Full Name?
Joe	Smith	Joe Smith

5. Differences Between Story Tests and Unit Tests

Unit Tests	Story Tests	System Tests
Execute code paths Boundary conditions Safety for later refactoring	Examples Behaviour	End to end scenarios

6. Is is Worth the Effort?

• Version control

Developing Discipline in the Agile Process

This post is the result of group notes on:

“Developing Discipline in the Agile Process”

There were also two related issues:

• Fighting scope creep
• Paired programming

How do we ensure stories get done?

• Scrum/Story Board
• Stand-up meetings – check status
• Switch tasks dynamically
• Ready access to answers
• Ability to re-prioritize the backlog

How do we avoid scope creep?

• Refactor often to keep the code clean
• Story specifications
• Use TDD to minimize scope

Agile Architecture

This session included Architecture with the related topic “Documentation on Agile Teams”

Architecture

Technical debt: price paid for previous actions (e.g. hacks, no unit test, hasty design decisions)

1. Big Picture
2. Think Design
3. Do What Works (and keep it simple)
4. Discipline & Execution

Architecture Meetings

Additional meetings outside the “iterations” used to plan architectural work.

Bit picture + right team => can product good design + refactoring/polishing

Emergent Architecture

Designs made as you implement will converge if the right decisions are made.

Develop vertical slices (thin lines) early in project to exercise all key architectural blocks.

Requires discipline!

Design Patterns & Ubiquitous Language

Should be underpinnings of system design.

Simple Design

Focus on the simplest solution that works now.

Loose coupling between classes. (Tight coupling leads to technical debt, but too much loose coupling can lead to overly generalized code).

Enables future improvements/expansions

Architecture Workflow

Product vs. Project

Product issues focus on long-term success of the product and project issues focus on show term issues typically to keep customers or internal stakeholders happy.

Conflict between these two perspectives often leads to technical debt.

• Must have discipline to write clean, simple code
• Product owner must be able to present a clear view – honestly
• Team must push back and challenge product owner for the best long term outcomes