Sunday, March 11, 2012

11 Self-organizing Teams Teaching Themselves Agile at the Same Time

In a previous post I talked about how I came to learn that I could teach Agile to lots of people at the same time. In writing that post I realized that it was a great illustration of self-organization. That realization was in the forefront of my mind as I ran the session "Hands On Agile Immersion" on March 10th at Agile and Beyond 2012 .

Although I've trained large groups of people on Agile many times over the last few years, it never occurred to me to create a video of the experience. This time, I decided to do it to illustrate large-scale self-organization in action. There were eleven separate teams with no appointed leader.

All I did was set up the learning environment, provide the materials, and give just a few instructions for each activity. The participants did all of the learning/teaching as a self-organized team on their own.

In the span of only an hour and a half, all 11 teams taught themselves the basics of 9 Agile practices as follows:

  • Form cross functional, collocated teams
  • Pick a software product to "build"
  • Write 12 User Stories for that product
  • Put the stories into a backlog ordered by business value with the help of a Product Owner
  • Estimate the stories in story points using Planning Poker
  • Plan a release using 2 iterations worth of stories
  • Do all of the above as independent self-organized teams

The teams did self-organization so well, I was able to do capture lots of video clips of the session and only had to answer 4 or 5 questions about the mechanics during the whole 90 minutes of the session.

As always, one of the favorite things that people learned was "Planning Poker," an Agile estimation technique involving special playing cards. I told people I didn't need them back and I also gave away all of my extras. I brought 48 decks and they were all gone at the end of the session. Not even a single card was left behind!

A short video (4:10) of the session is available on YouTube .

Some folks from Macomb Community College made their own video (3:58). The "Hands on Agile Immersion" part goes from 1:25 until the end.

Friday, March 02, 2012

Agile is a Game

While attending a presentation at Agile New England last night on “Gamestorming” by Todd Lombardo I was reminded that Agile is a game. That may seem a bit uncomfortable for something that is done as a professional activity, but it is actually a very good thing from a business perspective. After all, what is a game? A game is an activity that is governed by a set of rules, has a goal, has a scorekeeping system, and is fun to do.

The Rules of the Game
Nobody really likes rules, but what is the first thing you ask when you are about to play a new game? You ask “what are the rules?” You want to make sure you understand all of the rules and that people are “playing fair.” When these two conditions are met it is a lot easier to learn how to get good at the game and have fun.

The rules in Agile are deceptively simple. They are things like "iterations should be no more than 4 weeks" and "all iterations should be shippable." Following the rules mostly involves unlearning years of what you will later realize were bad habits.

The best part of the rules in Agile is that they are so clear. Don't ask me what the rules are in traditional development. I have no idea and I played that game professionally for more than twenty years!

Winning the Game
The next question you ask when learning a game is “how do I win?” This is the goal of the game. It is important to know what the goal is so that you can work within the rules to achieve the goal.
In all of this, it is important to know how to keep score because it is usually how you know how close you are to your goal.

There are aspects of software development that make it difficult to know the actual score, which is the amount of value produced. Value is a lagging indicator which you don’t really know until after somebody has used what you have provided and given you back something in return. Most of the ways of “keeping score” within Agile, such as burn up and velocity, are really only a proxy for the real score (value produced), but they are still important to know and monitor.

The Fun of Playing
You may wonder what “fun” has to do with a professional activity. Well, I don’t know about you but if I have my choice between working in a “fun” environment or a not-fun environment, I’ll pick the fun environment every time. Another way to look at fun is “doing something that is satisfying.” I believe that most people want to gain satisfaction from their work and that usually comes from feeling that you have provided something of value that benefits others in some way. In my experience, high job satisfaction corresponds directly to personal productivity.

The game of Agile development is simple to learn and to play, at least in comparison to traditional development. As a result, it is much easier to reach the goal and provide a high degree of job satisfaction. In my book, that’s a win-win.

Cooperative Play vs Competitive Play
One last point on this subject is that Agile development is both a team game and a competitive game. It is a team game within your organization and it is a competitive game that your organization plays in the marketplace. Now, get out there and win, win, win!

Learn the rules of the game: Boston, March 20th, Agile Whole Team Training .

Sunday, February 26, 2012

Software Development Nirvana vs Hotfixes

The purpose of software development is not actually the development of software. If one could accomplish the same result that software development provides without developing any software, then that is what people would do. The purpose of developing software is to provide value to the user of that software. Ideally, the user could get new value from their software as soon as they realized that they needed it or as soon as somebody discovered something new that could be added that would deliver new value. But in the real world it takes time to deliver something new.

Development Efficiency vs Market Efficiency
The value of any particular feature erodes over time. If you take 2 years to develop a whole bunch of great new features and they were all developed really efficiently, that’s great, but what if the value of most of those features has eroded away during the time it took you to do it? You may have gained development efficiency, but you’ve lost market efficiency. Development efficiency is important because cost needs to be less than revenues or you’ll eventually go out of business. But market efficiency generally trumps development efficiency because revenue is so closely tied to delivery time. That is, the faster you can deliver something that people value, the faster you will get the return on that investment. Equally valuable is failing fast; learning that you are headed in the wrong direction and finding a new and more valuable tact to take.

Look at it this way. Which would you rather do? Option 1: plan to deliver 12 features in a year and “efficiently” deliver them in a year but only 4 of the features are a hit with customers. Option 2: have a flexible plan, make changes all year long, and deliver just 10 features in that same year, but 6 of the features are a hit with customers? Also consider that in option 2 the quality is higher. Hopefully, you picked option 2 and voted for market efficiency over development efficiency.

Software Development Nirvana
Based on this, I would say that software development nirvana would be 1 developer, 1 tester, and 1 user documentation writer producing changes and delivering them as fast as they possibly can. And of course the customer(s) are sending money to the team just as fast as that team delivers the software. I realize you may have questions about quality, architecture, and just how fast a customer can take changes. And of course we will want to be able to replicate what this small team does on a larger scale. Let’s park those thoughts for now and just consider that it is hard to imagine a more effective team than the one described here.

Hotfixes to the Rescue?!
It turns out that there is something that all development teams do that mimics this description of Nirvana. It is something that is done very quickly, gets whatever resources are needed, and is done because it is absolutely the highest value producing activity that the organization can do at the time that it is done. That’s right, a hotfix!

Why do you do a hotfix? Because if you don’t somebody somewhere will be losing a great deal of value. That value may be revenues, customer satisfaction, or something else of value. In any case, you do a hotfix because it produces the most possible value to your organization compared to anything else you could do at that moment. It may not seem like value, but negating a negative value is a positive value.

A good deal of my Agile thinking stems from this one observation: if the process used to resolve a hotfix is the best way to produce the highest value as fast as possible, then why don’t we do that with all of the software we produce all the time? One caveat is that most hotfix processes cut corners in order to go fast, but what if there was a way to do hotfixes without cutting corners? 

Read: "One Piece Flow", an intentional version of hotfixes.

Check out our free webinar "Panning for User Story Gold"
Date: March 6th at 1pm ET.
Description: "Putting User Stories into business value order is a key tennet of Agile, but that's just the first step. There's much more value to be extracted from your user stories using specific story splitting techniques combined with reducing cycle time. By splitting user stories you can separate the gold from the dirt as well as reduce the cost of implementation. This session will cover a variety of methods for splitting user stories and reducing cycle time including the "create/read/update/delete" method, the acceptance test method, the split by value method, frequent grooming, Kanban flow, and software tool support."

One Piece Flow

One piece flow is a concept from Lean and is the key to succeeding with Agile. One piece flow is exactly what is done when producing a hotfix. The only difference is that one piece flow is an intentional practice rather than something done in reaction to a critical problem.

There are four main concepts in “one piece flow.” Each story is done as if it was the only thing in the release, each aspect of developing a user story happens in rapid succession, there is as much done in parallel as possible, and each team member focuses on a single user story at a time. The result of one piece flow is that the time between when the team first starts working on a user story and when they can ship it fully developed, tested, and documented is very short. The timeframe is generally on the order of a week at most and usually days.

In one piece flow, when development starts on a story, QA should be creating test cases for that story (story testing) at the same time. When development is done, QA should then automate the test cases and make sure they all pass. At the same time, the user documentation is written. One last step that must be completed prior to considering the story done is that all of the artifacts connected to that story such as source code changes, documentation updates, new test cases, etc must be integrated into the source code mainline.

Ideally, when following one piece flow, you would have done everything required to release the product to validate that the story really is done. That’s generally an impossible goal when just getting started with Agile, but it is a goal to keep in mind as you go. When working on stories, try to adhere to the principle of one piece flow to the greatest extent possible. As you read on you will find additional practices which simplify and reinforce the practice of one piece flow.

One last point. It may sound from the name that you can only work on one story at a time when following one piece flow. But really it means that for any story that is being worked on, it is progressing as fast as it possibly can without anybody that is working on it switching between multiple tasks. Another way to look at it is that the team should only be working on more than one story if the second story can be worked on without affecting the total time it will take to complete the first story. Likewise, the team should only be working on three stories if it won’t affect the total time it will take to complete the first two stories on an individual basis, and so on. A good rule of thumb is to only be working on as many stories simultaneously as you have developers on the team.

Friday, February 24, 2012

Burning Down Hours is Anti-Agile Because Working Software is the Primary Measure of Progress

A burn-down chart can use anything for the units, such as hours or points, but originally Scrum's burn-down chart tracked hours of work remaining in the iteration. Many people still use an hours-based burn-down chart as their primary measure of progress during an iteration. That’s a useful tool, but it is similar to tracking yardage in an (American) football game. It measures activity, but not accomplishment. After all, what percentage of a touchdown is 30 yards?
Working Software is the Primary Measure of Progress
One of the principles from the Agile Manifesto is "Working software is the primary measure of progress". But burning down hours is measuring and reinforcing progress against a plan without any requirement to have working software until the end of the iteration. That's pretty much the same as not having to have working software until the end of a waterfall release! This is one of the reasons that many people have moved away from burning down hours or supplemented it with other tools, such as burning up story points.
Burning Up Points to the Rescue
The Burn-up by points chart is one of the very best tools in Agile. It brings together many of the best aspects of Agile all in one place and gives you an instant heads up as to how you are really doing. The way a points-based burn-up chart works is simple.

For the iteration you are about to commence, total up the story points in all of the stories you have targeted for that iteration. Let’s say it made up of two 5 point stories, two 3 point stories, one 2 point story and two 1 point stories. That’s a total of 20 story points. Make a chart with an X axis that represents all of the days in the iteration from the first day to the last day from left to right. Let’s say it is 10 days. The Y axis represents the number of story points completed and in this case would go from 0 to 20 story points.

At the end of each day you tally up the story points associated with all of the stories that meet your definition of “done” and record the total on the chart. For instance, if you completed a 1 point story on the first day, nothing on the second day, and a 2 point story on the second day, your chart would have a 1 point bar for the first day, a 1 point bar for the second day, and a 3 point bar for the third day.

A points-based burn-up chart lets you see graphically day-by-day how much progress you are making towards your goal. It only records accomplishment, not activity, and allows you to see if you are on track or getting behind. To me, this is exactly what is meant by "Working software is the primary measure of progress."

Won't The Chart be Empty Until the End of the Iteration?
At first you may think that the chart will show that you are behind for most of the iteration and catch up only at the end when QA is able to start testing and marking stories as done, but whenever the chart shows something other than a steady march to the end of the iteration, here are some of the questions you should be asking:
  • Are our user stories too big? Is that preventing QA from getting involved earlier?
  • Are people working on too many stories at once?
  • Are we unable to produce a stable build for QA to test?
  • Are developers producing a bunch of problems and then going on to the next story instead of helping QA resolve the problem?
  • Should the developers drop what they are doing and lend a hand writing automated tests?
Using a points-based burn-up chart gives everybody, from team to manager to the organization as a whole, an instantly understandable picture of the health of the project and team. It simplifies the life of the manager because if it indicates a problem anybody can stand up and say “hey team, we’re messing up, what are we going to do about it team?”

A burn-up chart reinforces the following ideas:
  • Use story points for estimation, it enables whole-team thinking such as this whole-team metric.
  • Make stories as small as possible to get them done as fast as possible to keep the focus on accomplishment rather than activity
  • Have as co-located and as cross-functional a team as possible to enable the fastest possible turn-around time on stories
  • Enable the team to work as a team and to manage more things on their own
Unlike Burning Down Hours,  Burning up by Points is Fully Automatic!
You may not be ready to give up burning down hours yet, but there's no reason you can't use both. And most Agile Project Management tools, such as Rally , Version One, and Jira will generate a points-based burn-up chart for you automatically.

There's one more reason you may want to consider moving from burning down hours to burning up points, assuming your user stories are small enough in general and you are mostly getting stories done all the way through the iteration. In my experience, team members don't really like having to enter their hours remaining for their tasks every day, often forget to do it, and it keeps the focus on activity rather than accomplishment. Also, the only manual step required is to mark the story done, which helps to make the whole process much smoother.

[Excerpted from my free eBook "Do It Yourself Agile Kickstart". ]

Saturday, February 18, 2012

How I Discovered That Agile Can be Taught to 200 People at a Time

I was speaking to some fellow Agilists at an event recently about an Agile training course that I do that can accommodate up to 200 people at a time and they were pretty skeptical that it could be done. Later, I realized my path to creating the course might make an interesting story as well as be a good illustration of the power of self-organized teams. This is that story.

Marvin Toll Creates the First Bridge to Large Scale Training
At some point before the first Agile and Beyond conference, which was held in March of 2010, I was contacted by Marvin Toll and asked to present at the conference. He wanted to know which topics I could present on and I sent him my list.

Marvin chose "Hands on Agile" which had a title and an abstract, but no content. I just had an idea for a small hands-on workshop that might help people better understand what Agile is all about. I agreed to do it and took the first of many serendipitous steps.

You Want Me to Do This for How Many People?!
Luckily I was able to drawn on some material that I had already created for various Agile-related presentations. But then the second unexpected thing happened. One of the conference organizers sent me an e-mail letting me know that I should expect upwards of 100 people to attend my session and possibly many more. I had forgotten to let them know that I was planning on an intimate workshop of about 20 people. Now what was I going to do? I never would have set out to do a hands-on session for more than 20 people, let alone 100 or more!

I realized that all of the hands-on activities were structured around co-located whole teams. Everybody would be split up into teams with one team per table. Assuming that the instructions were easy to follow, each team would work together to figure out and perform the exercise.

I also realized that the question was, did I really believe in self-organized teams or not? Was it possible for just one person to keep over 100 people on track doing self-directed exercises? In the end I either believed in Agile or I didn't and if it worked out it would be another good example of how self-organization works and if it didn't I would learn some important lessons.

The Big Day Arrives
The day of the event I felt as prepared as I could be, but I really didn't know what to expect. Just before the session was about to begin I discovered that the sample user stories that I had so carefully prepared as handouts for each team were missing and I didn't have time to create new ones. And then I discovered that the easels and stickies for each table weren't set up for each table as I had requested and weren't even in the room! I was starting to get knots in my stomach. What would I do now?

I found one of the organizers and asked about my materials. Ten minutes later, all of the easels and stickies were at the front of the room and it was time to start. Approximately 150 people were all staring at me expectantly in 17 teams of 9. Necessity really is the mother of invention. After going through the preliminaries, which included explaining the role of a Scrum Master and having the room form into cross-function teams, two ideas came to me. First, I realized that I had 17 Scrum Masters that had materialized as a result of self-organization. I had them come up and get all of the needed materials for their teams and it looked like I had always meant to do that.

The second idea turned out to be one of the key reasons that the training is so much fun. Rather than use the pre-created user stories that I no longer had, I had each team pick a software project on their own. The only requirement was that it be something that the whole team thought would be fun and had nothing to do with anything they were currently working on. Two examples of projects: an on-line recipe creation website and a death ray. Apparently, one of the teams was made up of military contractors.

The Rest of the Story
After a successful debut, I've since repeated it at Agile and Beyond 2011 and will be doing it again at Agile and Beyond 2012 in March. Because it went so smoothly the first time with 150 people, I'm confident it will scale up to at least 200 people with a single instructor. I plan to test that theory in the near future. I also turned it into a full day training course which was offered all over the US last year. A brand new full day version, called Agile Whole Team Training is now available through Valtivity via public courses starting in Boston on March 20th and is also available privately on site or off site.

Friday, February 17, 2012

Exciting New Agile Training Option - Train Your Whole Organization!

Agile training is pretty expensive and generally targeted towards Scrum Masters. If you have a lot of people you want to train, it makes sense to just send the Scrum Masters. But now there is another option. Valtivity is proud to announce its new Agile Whole Team Training program. This course is being delivered in cities near you, starting with Boston, and can also be delivered as a private course either on site or off site.

Agile Whole Team Training allows you to train everybody in your organization (up to 200 people at a time) for the same price as just training the Scrum masters! Not only that, but people will only be away from their work for a single day.

This is a unique one day course which introduces Agile to the whole team and is also a great team-building opportunity. It is for anybody involved in development: management, product managers, business analysts, designers, developers, testers, DBAs, technical writers, project managers, etc. You'll form into cross-functional teams, pick your own software product to "build", and do hands-on exercises as a team. Bring an existing team or join a team during training.

Learn more about this new Agile training option here .

Wednesday, February 15, 2012

Panning for User Story Gold: Increase business value and reduce costs

Putting User Stories into business value order is a key tennet of Agile, but that's just the first step. There's much more value to be extracted from your user stories using specific story splitting techniques combined with reducing cycle time. By splitting user stories you can separate the gold from the dirt as well as reduce the cost of implementation.

Come check out my webinar on splitting user stories on March 6th at 1PM EST. The session will cover a variety of methods for splitting user stories and reducing cycle time including the "create/read/update/delete" method, the acceptance test method, the split by value method, frequent grooming, Kanban flow, and software tool support.

Thursday, January 26, 2012

Announcing Valtivity!

You may have noticed that I haven't been very active here in a while. Over the last year I've been spending more time doing Agile presentations than blogging. Well, that's about to change. I've just started a new company, called "Valtivity". I will now be devoting my time to Agile full time which means that I'll not only be doing presentations, but also blogging in tandem with focusing on Agile training and coaching. Need to get started with Agile or move to the next step in your Agile journey? Check us out at Valtivity .

Valtivity enables companies with a software development component to find and implement their ideal way of working that maximizes value to the company and its employees and allows them to find and serve new market opportunities faster. Valtivity does this by using unique training and coaching methods to rapidly teach the latest Lean and Agile techniques.

For the curious, Valtivity is short for "Valuable Activity." It comes from Lean's focus on activities that provide value.

Valtivity will be hosting its very first Webinar, "Agile - A Focus on Value" on Feb 1st at 1pm EST. Register now!

Wednesday, January 04, 2012

Here's a little Agile Humor for you. I recognize a couple of these. :)

What Agile Teams Should Avoid in 2012

This comes from my friends over at SmartBear