Tag: kanban

Why I love physical agile boards, part two

I thought of this as I was writing the previous post, but decided that it was important enough that it deserved it’s own discussion.

Another benefit of physical agile boards is that, by their nature, they tend to limit the scope of your planning. To some, this may sound like a bad thing. It is actually one of the most difficult disciplines to maintain in agile development.

One of the things that distinguishes agile development from older development models is that Agile keeps the time horizons close. This is beneficial because the nature of software and systems development is ever changing, and long-term plans are almost always upset by the realities of the industry and of development itself.

Even strong agile teams see opportunities and features that don’t make sense right now, but they know they will want “someday,” The tempting thing in Scrum is to add these into the backlog, so that they aren’t forgotten. In Kanban, they may go into the “not started” column or some other “feature stash” (The Product Owner and I had a secret Trello board called this when I worked on Revel at Adobe). These far-off stories and epics become their own drag on the agile process, slowing down backlog grooming and sprint planning as the backlog becomes less and less manageable and stories get re-added because no one can find anything.

A physical board actually makes it physically difficult to do this kind of faux-waterfall long-term planning. There just isn’t anywhere to put the post-its/cards! The Product Owner may still have their personal feature stash somewhere, but it won’t become a drag on the whole team.

Similarly, the lack of physical space makes it difficult to over-plan the stories that are in front of the team too. When I was doing Scrum as front-line engineering manager, I found it difficult to figure out how many stories we should break down for a sprint in order to not run short. The tendency was always to task out a lot more stories than we needed, just-in-case. The virtual board makes it easy to plan as many stories as you want. In practice, stories have dependencies on each other and if you over-plan, you tend to just write incorrect tasks.

A physical board encourages you to plan just as much as you need, and not much more.

Why I love physical agile boards, part one

After years of exclusively using virtual Scrum and Kanban boards, I am using physical boards again. In the process of adapting, I’m rediscovering many great things about using a physical board. One benefit of a physical board that I didn’t expect is that your stories and tasks tend to be less formal.

Last week there were two stories on two different team’s boards that made me laugh. One was:

20130825-194731.jpg

The other (which I didn’t get a picture of) was “do the thing with the thing“.

A good agile coach would point out that both of these were under-specified and poorly written. A better agile coach would point out that as long as the whole team understood what they meant and there was an agreed-upon definition of done, then the wording doesn’t really matter that much and it is fine for the squad to have an occasional story like that.

Neither of these would have ever appeared on a virtual board. By being on the computer/net, the virtual board has two features that the physical board does not.

One is longevity. “Do the thing with the thing” is fine if it is a story under discussion every morning at standup, and tossed in the trash when it is done. “Do the thing with the thing” would be a cryptic mind-f*ck a few years or even weeks later if someone was reviewing old stories.

Now this longevity element is something that I used to like with the virtual boards, having the history and being able to see how things developed and where they came from. In reality, you don’t really ever have time for that and instead it becomes another digital barnacle that isn’t really that useful.

Another property of a digital board is transparency. Theoretically, anyone in the company can see it. This again, is both a positive and a negative thing.

Having a board that anyone can see means that what your team is doing, will do and have done is available to anyone. Status reports are (theoretically) not necessary. If anyone asks what you’re working on, you can tell him or her to go look at Trello/Pivotal/Jira/etc and bug you if they have any questions.

With a physical board though, they need to come to the team and look at the wall. This means that any misunderstandings can be cleared immediately, and communication is actually improved by, you know, people speaking to each other.

When you are creating stories, tasks and notes on a virtual board, you are writing for an indeterminate audience. You are writing for yourself and your co-workers, but you never know who else will be reading it. If something you write has to make sense to anyone, ever, you will be a lot more guarded in what you say. You will be wary of not only how the story is perceived, but also, how you as the author are perceived. It is the difference between the conversation you have with a coworker over a beer and the item that you post to a blog or twitter.

That consciousness of the potential audience takes all the spontaneity and fun out. The formality makes stand-ups and planning take longer as well.

If you work on a co-located team and are using a virtual board for your agile practice, try going old-school for a while. I’m betting that your stand-ups and planning will go a bit smoother if you know that the stories and tasks that you write are for your team’s eyes-only.

Whatever you do, don’t forget to do the thing with the thing, and while you are at it, unf*ck everything.

[see part two: where I discuss how physical boards help you keep a manageable time horizon to your planning]

moving to scrum: The First Planning Poker

That could have gone a lot better.

I had originally prepared the product backlog with stories that were way too large. I think that I was confusing the role of the Scrum Product Owner and the XP Customer a bit. I was worried about “being polluted.” After reviewing the Scrum planning process again, I realized that I really needed to break up the top priority stories. I took the top dozen and broke them up into around 40 smaller stories. Some I left for the team to break up as an exercise. I needed input from the team leads to break up a few of the stories, so I left them as epics. There were a few stories that defied division. These were large design tasks. We have to interface with a couple other teams and get some customer feedback, so we need to have some initial designs to present that are somewhat comprehensive. I knew that this would be difficult to incorporate in an Agile process, but it is a part of our work and I wanted to try and assimilate it. We also had some carry-over work from the previous release and some open-ended consulting that we needed to account for in our estimations. The carry-over work was interrupt-based, basically bugs found by other teams that we would need to turn around quickly. To incorporate this into the planning, I created a story at upmost priority to account for this possible work.

Given the distributed nature of the team, I decided to do the planning poker on-line. I booked some video conference rooms, but also a phone conference. Since physical cards would not work for us, we used Adobe Connect (‘natch) with a polling pod for each person to put in their card choice. I figured that most of the team would hang out in their offices and dial in to the meeting, but everyone came to the conference rooms and that actually worked really well.

I’d budgeted about 2 hours for Planning Poker. I figured that this would give us time to get into the process and go through a few sprints worth of stories. Turns out that my estimating skills on planning poker needs some work itself.

The hard-to-estimate high priority stories derailed us for a long time. Especially the open-ended consulting and bug fixing tasks. The team got stuck on estimating an unknown. It took a lot of time and a lot of frustration, but we finally reached a rough consensus and moved on to the difficult-to-split design tasks. We tried a zillion ways to split them up or come up with better estimates. In the end they got a high estimate and were tabled to the sprint planning meeting. In retrospect, even though these stories were the highest priority, I probably should have started us on the concrete tasks and come back to these later in the session. For a team’s first planning session these were some pretty tough tasks to work through.

Once we got past these tasks, it got a bit better, but it was still difficult. The team got too caught up in the details of each story, unable to make an estimate before digging deep. If there was uncertainty, we got really deep in the weeds. The 2 minute timer didn’t help. The more concrete stories that needed to be broken up took a lot more time than I expected too. Members of the team kept wanting to discuss details on each story. The scrum master and I kept trying to bring us back to the sprit of estimation, but it was a slog. After almost three hours, we had only gotten through a dozen stories, not even enough to get us through our first sprint. I’m going to look for better ways to explain the spirit and intent of Agile estimation to the team. It is difficult to grasp sometimes for detail-oriented folks.

Even though we were short of estimated stories, we went ahead with our first planning meetings anyway. One team was able to take on stories and create tasks and estimates from them. They may be a bit short of work, but they made some progress. The other team had difficulty pulling stories given the paucity of choices.

We learned some useful things today. We separated the teams to do the sprint planning, pulling from the backlog. The teams were in separate video conference rooms. I and the scrum master moved between them. We realized afterwards that we really need to have both teams together to figure out how the stories would be divided and then the teams should have separated to create their tasks and do their estimations. I was also too eager to jump into the poker session itself,  and I didn’t spend enough time going through the backlog with the team and discussing my priorities. We’ll fix these issues next time.

We’ll do a second planning poker session tomorrow. Before then, I’ll take in the new stories we created in the backlog, make sure that they are prioritized correctly, and try to break up some more of the stories so that we don’t have to spend time doing that in the poker session.

I knew the first planning poker session was going to be a bit rocky as we felt our way through the process, but for me it was brutal. I know that as we gain experience it will get progressively easier and so I’m more worried about the team’s morale right now than I am concerned about the process. We’ll see how it goes.

On one hand, our super short sprints play to our advantage as it lets us try stuff out in a sprint without a huge commitment. On the other hand, it makes breaking stories up into sprint-sized chunks really difficult. It feels a bit like we’ve jumped into the deep end because of this. We’re open to making a lot of changes, but we’re hoping to keep a consistent sprint length through the cycle since modifying the duration of our sprints will make it difficult to establish a rhythm. Again, we’ll see how it goes.

Converting from agile-mumble to Scrum: the introduction

I’ve been a convert to Agile for almost a decade now. I was first exposed to it when I was working at a start-up called Bootleg Networks as a Development Lead (don’t bother looking it up, it is long lost to time). I’d just come from six years at Microsoft where Waterfall was the only methodology and it was followed religiously. I’d seen all the worst aspects of Waterfall and seen nearly none of the best, but I wasn’t up on any other methodology besides Ad-hoc (also known as “play it by ear”). We’d hired Carmine Mangione as our software architect and he came in spouting all this stuff about “Agile” and “XP.” While I was definitely ready to try a different style of development, it all sounded a bit unstructured to me. Carmine convinced me to try eXtreme Programming, promising that if it didn’t work, we’d drop it. We bought a stack of Kent Beck’s book for the team and jumped into it. I went from Development Lead to XP Coach and quickly became a convert.

We achieved a ton of stuff using XP at Bootleg very quickly with a relatively small team. That short stint really changed my mind on how professional software development could be done. Ever since then, I have found ways to incorporate as many aspects of agile methodologies into any place I’ve worked.

I ended up back at Microsoft a couple years later. The situation there had changed quite a bit. While most of the company was still doing waterfall, more developers were aware of Agile and were curious about it (even if their managers weren’t). I took on a risky new project. It was fixing an ancient set of code written originally by Microsoft, but completely eroded over the years by a series of contractors. It was a mess: full of bugs. Customers didn’t like it. Rather than try to fix it, I convinced them to let me and a small team rewrite it from scratch to clean it up and get the new functionality needed. Program Management was skeptical, Quality Engineering was dead-set against it. I put my neck out and promised that we’d bring it in on-time with a high-level of quality that would be instantly verifiable with a battery of developer-written unit tests. We got some initial buy in and we went to work. We followed as much of XP as we could with an undersized (4 person) development team. Needless to say, we got it done and it shipped as part of WinCE 5.0.

I left Microsoft to join Adobe and was really happy to see that Agile was not only acknowledged, but embraced across many groups in the company. There were many different flavors being used, including several custom ones. Scrum was fairly common though.

I was certainly aware of Scrum, but didn’t have too high an opinion of it. Everything I’d read and heard about it made it seem like it had nearly no process or structure. Looking at how different teams “followed” scrum practices, it seemed like it was just an excuse for Cowboy Coding with a tiny amount of coordination involved. It seemed like a parody of Agile to me at first.

At Adobe, I was lucky enough to be able to build a completely new team. For various reasons, the team ended up being split between two different offices. While I wanted us to follow an Agile methodology, after a lot of research, I couldn’t identify one that would really work for us wholesale. Instead, I took the pieces that made sense and incorporated them as I could. We ended up with a unique process that subsumed bits of Rational (short sprints at first, longer sprints in the middle and short sprints again at the end; co-located functional teams), XP (test-driven development, occasional paired programming, be able to deliver at the end of each milestone, constant refactoring and narrow focus) and Scrum (demo-able at end of each sprint). That was the goal process. Of course, we didn’t always get there. We were pretty open and made a lot of changes along the way to incorporate new best practices and dump the parts that didn’t work. This evolving process worked fairly well and we have had three successful product cycles over several years using it.

For all the good of our existing cobbled-together development framework, we were always finding the seams, the edges that didn’t quite meet. There were other issues too. Having co-located functional teams meant that each team had good velocity, but it also meant that cross-site communication was always a problem and it made collaboration difficult as well. The team was getting too silo’d in my opinion. I wanted to really mix things up for our next cycle and try something totally new.

Over time, I’d gotten over my initial knee-jerk reaction to Scrum as I encountered more teams using it in a more deliberate and successful way. One weakness I still saw was the difficulty of using Scrum in non-co-located teams, but I met teams that came up with ways to manage this.

I decided that we would try Scrum for our next cycle. If it worked for us we would continue to use it for future cycles. If it didn’t, we would incorporate whatever worked for us back into our old process. Luckily, Adobe has a full-time Scrum trainer in the company. We did our scrum training a couple weeks ago, and we start our first Sprint tomorrow.

I’ve decided to document this on my blog for a few reasons:

  • It is something about Software Engineering that I can write about without fear of divulging corporate secrets
  • It might be interesting for other folks in similar circumstances
  • It is too long to tweet 🙂

My plan is to document our transition as much as I think might be interesting to others. Our situation is a little different from most since we are transitioning from a different Agile process to Scrum instead of from a non-Agile process. My team is also somewhat unusual since most of our clients are internal to the company who each use a different methodology (most Scrum, but some waterfall and some other Agile), but we also deliver our technology straight to Adobe’s customers on both long and short cycles. So we have a lot of impedance matches to account for. Some things may need to wait until the cycle is over for fear of disclosing too much, but by focusing on the process, I hope to be pretty open.

I’m not going to go too far into the mechanics of Scrum here since there are a zillion better places for that and because I’m still learning it myself. If I use a term you aren’t aware of and you can’t find a good answer on Google, ask me in the comments and I’ll try to answer it for you.

A bit on the details: My team doesn’t have a “Product Manager,” so I will be taking on the role of Product Owner even though I am the Engineering Manager. I’m not planning to act as a Scrum Master, that role will be taken by the QE manager of the team. If I have some free cycles I can use for development, I will act as a Scrum Team member, but I will not participate in Planning Poker as an estimator. We will have two scrum teams, each team incorporating developers and QEs from both of our sites. We’re going to do short sprints so that we can make changes quickly to our process.

I hope to create a little series here if I have time to keep it up to date.

Stay tuned.