Agile 2011 Day 1 Review

Agile 2011It was great enthusiasm that I set off to Salt Lake City last month for Agile 2011. In the lead up I was a reviewer on two stages (Testing & Quality Assurance and Working with Customers), plus I was lucky enough (and apparently the only submitter) to have all three of my original submissions accepted (although conference rules, for good reason, restrict speakers to two sessions). Whilst its a been a month since the conference (I took some time afterwards to spend time on both the east and west coast of the USA), I wanted to ensure that I posted my notes.

Here are the notes from the sessions that I attended on day one.

The Product Partnership: Using Structured Conversations to Deliver Value

Mary Gorman and Ellen Gottesdiener led this tutorial. They started by taking about requirements by collaboration and leading a discussion on things that hinder and help.

From Agile2011

Things that hinder: access to the right people, thinking about the solution rather than what needs to be done, multitasking, people not listening, customer not clear of needs, backlog too big, stories too big, missing product owner

From Agile2011

Things that help: centralised repository, short backlog, story maps, clear business goals, UI mockups part of the story, clear priorities, crisp acceptance criteria

From Agile2011

To set the stage we need:

  • a sponsor, product owner / champion, customer, technology
  • a shared understanding of vision, much like an infinity loop we: discover –> prepare –> deliver
From Agile2011
From Agile2011

They then went on to speak about value:

  • conflicting voices for value – not just from the customer but technology value, we need to listen to all the voices
  • evaluate requirements – value, risk (such as technology risk, team risk, outsourcing risk) and dependencies (dependent on other teams or external vendors and requirements and dependencies where value violates the way we would like to build the system)
  • benefit – IRACIS (increase revenue, avoid cost, improve service) needs to be balanced with cost, time and delivery
  • table stakes – the things we must deliver to stay in business
  • differentiators – point of difference in the marketplace
  • up sell revenue potential
  • foundation for long term savings
  • provides revenue for future
  • frequency of use
  • automate labour intensive tasks
  • no viable manual workaround
  • reduces pain for end-users
From Agile2011

This led to a discussion about backlog:

  • we want to build the most valuable things first
  • two states – credible (it has some kind of value) or buildable (it has been prepared and is sliced, groomed or right size as well as understood well enough to estimate, test and document)
  • incorporate UX into preparation, collaborated workshops
  • slice for value – starts with a glean in someone’s eye, then it gets bigger because we have a bunch of options, so we need to fit based on value to contract the list
From Agile2011

And finally onto requirements:

  • product provides value to users – who will receive value from the product
  • what actions need to be performed – what are set options
  • what is the data (noun) and the type and state of data
  • what are the constraints – policies or controls that need to adhered to, business rules

The example for this tutorial was getting to the Agile 2011 conference. We first ask the question: what do we value.

From Agile2011
    • customer value – convenient parking, staying in conference hotel, cheap flights, etc…
    • business value – people stay at conference hotel, one stop shopping on the website to save aggravation for Agile Alliance as well as attendees
    • user roles – travel explorer – individual attendees (speakers, sponsors, volunteers, attendees) and corporate travel agencies for group travel
From Agile2011
    • actions – hotel information, distance to the venue from home, distance from other hotels
From Agile2011
    • data – link to hotel (official hotel plus local hotels), Salt Lake City information
From Agile2011
    • control options – the business rules, such as when you need register by, etc…
From Agile2011
So we start with the requirement:
I need to: register
User role
  Type options: member*, non-member, group, academic
  State options: active*, inactive
From Agile2011

Then the actions:

Action options
  learn
  pay
  confirm
  communicate
  cancel / transfer
From Agile2011

Then the data:

Data: Fee
  Type options: regular, early bird, super early bird
  State options: available, sold out
Data: Payment
  Type options: credit cards, payment order, check
  State options: paid, pending, not paid

We may also visualize this as a data model or a state diagram

From Agile2011

We then need to look at the business rules and prioritise them.

From Agile2011

Once this is complete we can now we slice for value and write a story. This needs to be the silver bullet / tracer bullet, then you can break down from there. At this point you can write the stories and throw the sheets away. This all leads to:

As a... I need... so I (value)

Requirements leads to examples which leads to tests. We can now link this to given when then:

 Given: pre-condition (state), fixed data
 When: action, business rules, input data
 Then: output data, post condition (state)

It is recommend that you come to these workshops with some pre-planning but be under the agreement that they are draft and often wrong. These could be release or iteration planning workshops.

Now the forgotten heroes, the non-functional requirements:

    • design and implementation constraints – the givens, the parts of your technical infrastructure that are dictated or restricted – worth pausing and discussing if there are any options
From Agile2011
    • interfaces – human, other systems and device interfaces such as messages (you could use a context diagram to illustrate this) – with the diagram you can start discussing the options / choices / possibilities
From Agile2011
    • quality attributes – things like speed, stability, uptime, security, scalability, usability, extensibility, etc…, need to be testable and SMART (specific, measurable, attainable, realistic, time-based) – eg. recover from user error in x clicks, x time
From Agile2011

You can do this at the big view (business process, features, MMF, scenarios), pre-view (user stories, user story maps where you lay out stories left to right, scenarios) or the now view (buildable, scenarios). The granularity will change.

From Agile2011

Plans in an array matrix – the anchor is the action dimension

From Agile2011

Need to have a structured conversation to communicate effectively. Face to face is the most effective and get a shared understanding of the highest value.

Overall, this was an enjoyable session. I really liked the templates for mapping out the requirements (despite the fact that these were essentially just aids for the workshop) as they helped focus the conversation and gave our group something to focus on. Mary and Ellen are currently writing a book based around this content, so I look forward to seeing that in the future.

Coaching Success: Getting People to Take Responsibility & Demonstrate Ownership

Christopher Avery (creator of the Leadership Gift and author of The Early Admissions Game: Joining the Elite, which apparently is 10 years old and still in print) led this extremely packed session, the essence is contained in this publication available here (as well as here).

From Agile2011

We started the workshop by competing in a spaghetti challenge (based on the Marshmallow Challenge) which consisted of the materials of just 10 pieces of spaghetti and a  line of tape. The team I was working with constructed a tower of 35 inches, which ended up being the second tallest in the room.

From Agile2011

There is a pattern in our mind that kicks in every time something goes wrong – creates angst and anxiety – responsibility process – a descriptive model:

  • QUIT – the pressure of responsibility and obligation can lead us to quit, an avoidance move, a lack of completion, active disengagement
  • RESPONSIBILITY – call yourself on obligation so you start looking for solutions – start saying “I get to go to this stupid meeting”, means you have a choice – we were taught that doing stuff we have to do makes us responsible
  • OBLIGATION – I have to go to his stupid meeting have to but don’t want to – leads to resentment
  • SHAME – how could I do this, how could I be so stupid – laying blame on self – premise is the problem, you can’t learn
  • JUSTIFY – it was raining, I dropped my keys – story makes it just – “that’s just the way it is around here…”
  • LAY BLAME – who took my keys? – not a solving position of mind
  • DENIAL

3 keys – descriptive model

  • INTENTION – wanting to get something done, get to RESPONSIBILITY around every problem in your life
  • AWARENESS – be aware of which level you are in
  • CONFRONT – ability to face, taking yourself to the edge of your comfort zone, comfort zone = current capability, confront = expanding capability – every person you know was once a stranger

Example coping mechanisms are: learn to live with it, it worked on my machine, they just don’t get it, it’s the vendors fault, it’s too hard, you’ve been here long enough to know that’s not going to happen, murphys law, we did exactly what they asked for, …

We then did a “Be With” exercise, which was essentially sitting knee to knee with the person next to you, in complete silence,  for 30 seconds, to feel the others anxiety. Ultimately, it’s not the other person that makes you feel bad, it is yourself.

Confront is the angst of confronting yourself. If you want to change something you need to poke it, and observe the change.

Accountability Responsibility:

  • accountability is the number one tool of management – it’s the way we manage commitments between two parties – its outside of us because it is us and someone else
  • responsibility is about how we respond – internal to us, and different for all of us
  • what people are signed up for is greater than what they are responsible for
  • what people are responsible for is greater than what they are accountable for <– We want to be here
  • they are both equal

Where’s the bottleneck?

  • what if you had to reproduce the code, if you had the same team and resources?
  • what percentage would be more efficient the second time?
  • modal is 70%. You would be better because you have solved the problem before. Learning takes time. Essence of agility is to learn and take feedback.

There is lots of feedback in agile practices such as retrospectives, showcases, standups, etc… If you are not going to do anything about it, stop investing in the feedback loop. The fastest way to learn is to take ownership.

Fastest way to elevate responsibility in a group is demonstrate it yourself. If you are saying people around you are not displaying responsibility, then you are just laying blame.

Exercise coaching responsibility. The responsibility process only works when it is self applied! You need to teach it so others can self apply it. Counter not being good enough yet to teach this yet:

  1. Give yourself forgiveness, forgive yourself for being human
  2. Teach this with a light tone. Make yourself the brunt of all the jokes that are below the line
  3. Don’t go into agreement (“but I do have to go into that stupid meeting”) – don’t confuse the facts with the mental position – take time, breathe, count 10 seconds and answer – validates they raised a good question and allows you to respond – ask if you can push back on them a little bit, and ask them to identify where they are on the chart
  4. Make sure you support – need to forgive yourself, let go and move onto a better future

Taking responsibility is owning your power and ability to create, choose and attract.

Responsibility is the design space. What do we want from this? Be clear with what you want and be clear about the consequences. Responsibility gives you power but also potential consequences.

There is a difference between choosing something and avoiding something.

As a coach you get to intervene in situations, so you need to act from a position of responsibility and check where you are coming from (move through the model as quick as you can). Ask yourself if your message is clear and does not sound like blame.

Advice is seldom effective so stop giving advice. You are transferring responsibility from them to you. If it doesn’t work they perceive it as being your fault. Instead:

  1. Resist giving advice. Tell me what you have tried, tell me what you haven’t tried
  2. If you must give advice, give three alternatives so they have to choose, putting responsibility on them. “If I were in your shoes I might consider a…, b…, c… What do you think about those?” One coaching company advises 10 alternatives, so you really think about the responsibility.

Finally, play the “Catch Sinner” game to learn the process:

  • make a score card
  • choose a word for today
  • make 2 columns – “get off of it” and “it got out”
  • throughout the day, everytime you catch yourself in a position of “blame” mark your chart
  • 10 points for the left and 1 point for the right column
  • build tremendous awareness for each word at least for one day

There are a bunch of resources at Christopher’s website, in particular he encouraged us to get a copy of the teaching poster and empowered us to teach the process to our peers.

Overall, I really enjoyed this session, as I had heard good reports from this session when it was help in 2009, and this year it was listed as one of the most popular sessions. The responsibility process is something I would really like to work on personally.

The Agile Manifesto 10th Anniversary Reunion: The Big Park Bench

This was one of the highlights of the conference where 15 of the 17 original authors of the Agile Manifesto got together on a big park bench to discuss the writing of the manifesto.

From Agile2011

There were heaps for great stories but here are some of the snippets I took away:

  • started with XP Immersion
  • at the XP Leadership meeting, rejected idea of creating a group
  • Bob Martin and Martin Fowler sketched out an idea for the Lightweight Methods conference
  • Jim Highsmith noted that there us nothing about it that he would change and would not get back together with these people to do it!
  • Ward Cunningham would change the colour balance of the background image
  • Brian Marick noted that individuals and interactions can often be a beat up for people who appreciate tools
  • Jim Highsmith commented when asked about the next 10 years that agilists don’t predict!
  • they never expected that something written in a couple of afternoons would be this big
  • Brian Marick recalled that the stated objective of the meeting was a manifesto and it seemed miraculous that they left with a good framework . Bob Martin was just surprised that he has been to one meeting that worked!
  • Martin Fowler did not want to call it agile, he wanted a wackier name
  • Agile Manifesto nailed it as a baseline – they might have added “we really mean it” or “we are not kidding”!
  • when you gel with a team you get what can be summed up in 3 words: high quality work
  • great teams change people lives. “The manifesto changed our lives, and probably yours too”
  • many people who may have survived under waterfall may not survive much longer under agile, as it is flushing out bad practices
  • other potential names for agile were: adaptive, hummingbird, lean (used already), PPP, a bunch of acronyms, did not want a word they would have to wear pink tights and a tutu to explain!
  • Agile was a coincidence – people following lean in the 1990’s were saying agile is the future, which was good because agile has a meaning in the business world
  • the most argued item on the manifesto – iteration timeframe, executes terminology
  • the principles were harder to arrive at
  • biggest disappointment – everyone wants to be agile but too few people want to do it (when they wrote it they really meant it), the scrumbut
  • biggest success – uses outside of software (for example Pragmatic Programmer publishing), wanted teams to be able work freely in a way they wanted to work
  • need a revolution in middle management and need a similar framework for agility
  • Agile is not the “not-waterfall” – it’s about teams and delivering software
  • Agile stands as a beacon of hope, for it to disappear would mean the evil empire has won
  • in software, we still need to ask how do we do a better job?
  • an Agile process of inspect and adapt is what makes lean companies great
  • Jim Highsmith particularly called out Jeff Smith, the CEO of Suncorp Business Services as being someone who got promoted from CIO to CEO through the success of Agile
  • consider lean inside the same heritage as agile
From Agile2011
From Agile2011
From Agile2011

A reunion site has been setup in conjunction with this event.

Podcast

Finally, I recorded a short audio podcast for The Agile Revolution wrapping up Day 1 of the conference.

Agile 2009 Day 1 Review

Agile 2009Once again I was extremely lucky to get two talks accepted at Agile 2009 (with Paul King) and the support from Suncorp to send me along to speak. Whilst its a been quite a number of weeks since the conference, I wanted to ensure that I posted my notes and comments. This year, being my second attendance, I found the hallway discussions all the more valuable and had many awesome conversations with friends made last year as well as new friends just met. Added to this, Chicago exceeded my expectations as the host city.

Once again, the number of simultaneous sessions made the decisions extremely difficult on what to attend.

The sessions I attended on day 1 were as follows:

Using the Agile Testing Quadrants to Plan Your Testing Efforts

This session on the testing stage was delivered by Janet Gregory, one of the authors of Agile Testing. The slides are available on the Agile 2009 site.

Testers should be part of release planning and think about:

  • scope
  • test infrastructure and test tools / automation
  • how much documentation, is it too much, can I extract it from somewhere

Iteration planning:

  • plan for done, acceptance tests
  • priorities of stories, which stories to do first, connect with developers
  • budget for defects unless you are a high performing team

Need to acceptance test the feature, not just the story.

We then did a collaboration tools exercise, and some of the tools used by the audience were:

  • desk check / show me – when a developer thinks they have finished coding, get together and take a look
  • wikis, conference calls, GreenHopper, etc
  • daily standup – share when things are done, if you find them ineffective
  • project cards – used for story management and documenting conditions for acceptance
  • sticky notes and pens for a co-located team
  • demonstration every week or end of every iteration
  • FIT tool, used for demos
  • walking and talking
  • pairing
  • generated artefacts from the CI server
  • instant messaging
  • puzzle / chocolates on desk to encourage talk, “free to developers if they come and ask a question”
  • rolling desks on wheels, so they can switch configuration
  • rolling whiteboards
  • JIT (Just In Time) meetings as required
  • mind mapping software that hooks up to Jira
  • retrospectives
  • team review story and write tests together
  • nobody said “email”!, no email!
  • recorded chat room, so conversation is recorded

Waterfall test pyramid, upside down, very unstable – Functional Tests –> API Tests –> Unit Tests (heavy functional tests based on GUI, very few unit tests).

Automated test pyramid (Mike Cohn) – unit tests / component tests are the base layer, require testable code that we can hook into below the GUI at API layer, GUI tests are most brittle because UI changes so do as few of these as possible, right at the top you might need a handful of manual tests.

Agile testing quadrants change the way you think about testing – use to classify tests, what the purpose of the test is (why are we ariting these tests), tests will cross boundaries.

Agile testing quadrant – can be used as a collaboration tool (developers will understand how they can help), emphasizes the whole team approach (no “pass this to the QA team”, whole team is responsible for testing), use to defne doneness (use for planning, what needs to be done, has estimate allowed for the amount of testing we wish to complete).

Quadrant 1 – technology facing tests that support the team, TDD supports the design of the team, tester has feeling of comfort

  • unit tests test the developer intent, individual tests on a method, small chunks of code, fast feedback mechanism, code is doing what it should do
  • TDD tests internal code quality, if developers test correctly it flows all the way through and makes easier to test functionally
  • base for regression suite, if you are going to spend any time on automation, “put it here”, return on investment is better the lower you go in the pyramid

Quadrant 2 – where the acceptances tests live, supporting the team in natural language, helping the team deliver better software, use paper prototypes to talk to customers rather than big GUI, acceptance test upfront helps define the story, use examples to elicit requirements (easiest way to get clarification from the customer, always ask “not sure what you mean” or “give me an example”, pair testing (ask for feedback as soon as possible)

  • the examples can become your tests, write upfront and ensure that developer makes them pass when they develop code, use tools such as Fit / Fitnesse, Cucumber, Ruby / Watir
  • examples help customer achieve advance clarity, focus on external quality (facing the business), want the tests to spark a conversation with the developers
  • BDD use of given (preconditions), when, then as opposed to tabular formats in Fitnesse, useful for workflows
  • Janet polled the room and only about a dozen people in the room give their acceptance tests to the developers prior to the story being developed
  • if no automation tool, write up a manual sheet, give it to the developers and have a conversation before the card starts

Quadrant 3 – user acceptance testing, critiquing the product, getting the customer to look at the system

  • exploratory testing – time box these sessions to reassess about how far you wish to go, following instincts and smells with a purpose, touring (eg. the money tour) as defined by James Whittaker and James Bach (in the book Exploratory Software Testing), this is where you find majority of bugs so testers should spend the majority of their time here (which is why you need a good base of automated tests)
  • collaboration testing – forge a relationship with the developers so you know what they are developing,
  • remember your context to determine how much testing is enough (eg. mission critical software vs an internal application)
  • attack stories using different personas – Brian Marick likes to create evil personas (eg “pathological evil millionaire”) or use impatient internet user vs grandma who clicks every link on the internet

Quadrant 4 – non functional tests (should be part of every story (eg. is there a security or performance aspect), ility testing, security testing, recovery, data migration, infrastructure testing, do as much as possible upfront although sometimes you will need environments that will not be available to the end

  • non functional requirements may be higher than fucntional (eg Air Canada seat sale might need critical performance)

Test plan matrix – big picture of testing against functions for release, usually on a big whiteboard, use colours (stickies) to show progress, benefit is in the planning in what we need to do testing wise but also appeases management because they like to see progress, gives idea of where you are going

Can use a lightweight plan, put risks on a white page, 35 of the 37 pages of the IEEE test plan are static, so put that information somewhere else

Test coverage – think about it so the team knows when the testing is done, burn down chart will be enough if you test story by story, when thinking risk ensure you include the customer (they may have different opinion of risk

Summary:

  • think big picture – developer following a GPS only needs to know next 2 weeks, but tester is a navigator and needs the map
  • include the whole team in planning and test planner
  • use the quadrants as a checklist (put them on the wall)
  • consider the simplest thing, especially in relation to documentation
  • think about metrics – one man team might be good enough to just know they passed
  • visible, simple, valuable

Janet also mentioned the following throughout the session:

I also stumbled across a related blog post on this session at: http://agile2009.blogspot.com/2009/08/agile-testing-quadrants.html

What Does an Agile Coach Do?

This session was delivered by Liz Sedley & Rachel Davies, authors of the new book Agile Coaching. The slides are available on the Agile 2009 site.

This was a hands-on workshop and involved some good discussions on how to deal with different coaching scnarios.

Zen & the Art of Software Quality

This session was delivered by the legendary Jim Highsmith. The slides are available on the Agile 2009 site.

  • “There Is No More Normal” – John Chambers, Cisco CEO, Business Week, 2009
  • business strategy needs to be more adapting to change than performing to plans
  • mixed messages – be flexible but conform to a plan – dilemma faced by many agile teams
  • Artful Making” – Rob Austin – describes $125 million software failure
  • 1994 there was 82% software failures, 68% in 2009 (success defined as on time, on budget, all specified features) – Standish is measuring the wrong thing, not a good measure
  • cancellation of a project should not be a failure, it is a good thing
  • current environment – schedule is more important than value
  • Beyond Budgeting” – Hope/Fraser – not a good book, but good ideas
  • Measuring & Managing Performance in Organisations” – Austin – all measurements are dysfunctional, get a different outcome than you expected
  • if budget 100 and you achieve 100, better than budget is 120 and you achieve 110 – which would a performance management system reward (the 100, even though latter is better achievement)
  • beyond budgeting – make people accountable for customer outcomes, create high performance climate based on relative success amongst others
  • trust, honesty and intentions are better than measurements
  • performance tends to improve while people figure out the system, but under pressure people focus on measurement goals rather than outcomes
  • earned value (time + cost) has nothing to do with value, does not have anything to do with what is delivered to the customer
  • we need to move from scope/cost/quality to value/quality/constrants (scope/cost/schedule)
  • core benefit from agile has been value and quality
  • everybody comes to work to do good quality, but never well defined
  • Zen & The Art of Motorcycle Maintenance” – Pirsig – quality ideas
  • is quality objective or in the eye of a beholder, people have different ideas
  • need extrinsic quality (value) and intrinsic quality (so you can deliver quality tomorrow)
  • Applied Software Measurement” – Capers Jones  – 95% defect removal rate the sweet point for quality
  • experience is doubling staff quadruples the number of defects – BMC were able to kick this trend using agile
  • difficult errors take time to find – longer the worse quality of the code
  • first year of product release the quality might be OK, but then adding new features more important than fixing software debt, over time the cost of change increases and accumulated technical debt harder to fix, but the more debt the higher the pressure to deliver
  • strategies – do nothing, replace (high cost/risk), incremental refactoring, commitment to innovate – best way but hard to sell politically – downward cycle from vicous cycle to a virtuous cycle (55% said easier to support agile developed products)
  • productivity in features you don’t do, 64% of software features never used, what if we put 25% of that money into refactoring or leaning agile
  • agile value curve – if doing high value first we can ask the quation do we have enough to release the product?
  • need to reduce the margincal value of our stories
  • if you don’t have time to estimate value, you don’t have time to estimate cost
  • philosophy – value is an allocation not a calculation (cost is a calculation), so use value points and allocate from the top down – value points need more thought than ranking – additional information when you look at 25 story point card worth only 2 value points, also demonstrates that value is important, should be able to do this fairly quickly
  • value and priority are different – a low value card high on priority might be a guide, pick a cap for the value
  • value points like story points are value
  • story point is calculation of cost, value point is allocation of revenue
  • Intel has 17 standard measures of value, help to determine as a guide
  • value in Chinese means smart/fast
  • value – is product releasable – always ask the business owner or product manager that question – example that a product could be released when it was 20% complete
  • parking lot diagram – empasizes capabilities we are delivering to customer in their own language, show progress and value deliverd by number of stories done / done
  • Gantt chart shows task complete to a schedule
  • questions – can we release, what is value-cost ratio (do we need to continue or do something else that is higher value), what is product quality, are we within acceptable constraints
  • how do you determine if you are in a technical debt hole – using qualitative measures in your code
  • ask the queston – do you know why it takes 3 months to make a change, explain the technical debt curve, start to show people that quality matter (eg. automated testing becomes a time accelerator)

Ice Breaker & Freshers Fair

The Fresher’s Fair at the Ice Breaker had a number of great groups including Kanban, Usability and CITCON. I stumbled across the following poster that was a long way from home…

Agile 2009 CITCON Brisbane