Category Archives: agile

A3 Management and Stock Issues

There are zillions of ways to make an effective A3. I needed to find a way I could understand intuitively, so I could get past trying to figure out the technique and move quickly on to using it for actual hard problems.

This week, Steven introduced us to the A3 management system and specifically the A3 format for delivering recommendations to our customer.

This is based on a Lean book, Managing to Learn (one of many books Steven lugged all the way across the Atlantic not on his Kindle). The deal is, the A3 is a paper size (approx. USA 11×17), and there are two columns with particular formats for presenting the nature of the problem and the proposed recommendation to fix, in a concise and collaborative manner.

As I was struggling to understand the mountain of A3s (all different) that Steven had brought along as examples, I noticed a pattern to them that meant something to me:

  • Harms
  • Significance
  • Inherency
  • Plan
  • Solvency

The A3 fits the outline of a very old-school stock-issues high school policy debate case. Of which I’ve written more than a few. (Cool kids don’t debate this way anymore, I’m told.)

  • Harms: the problem
  • Significance: what is the extent of the problem, and what metrics can be used to assess it before and after?
  • Inherency: what structural or attitudinal factors are reinforcing or worsening the problem?
  • Plan: the recommendation
  • Solvency: how will the recommended action steps resolve the problem, and which metrics will be used to measure success?

And here’s what it might look like in practice:

  • Harms: four teams are developing working software, but their integration and stabilization phases are trainwrecks and they have all come to dread their merges.
  • Significance: Team A has burned a week of their latest two-week iteration just on merging. Many of Team A’s changes from their previous iteration were lost when Team C merged over the top of them, and this will take at least another week to fix. Meanwhile, Team C’s release, which seemed tested and ready, has been delayed by nearly a month fixing bugs discovered after merging.
  • Inherency: the root of the problem is team branches. All four teams are working on the same product, and following a similar release cadence. All four teams easily decompose their work into small increments of working software that they are able to test and release every few days at best, every two weeks at worst. Isolating the teams doesn’t benefit anyone, and has led to the bad habit of isolated test and last-minute merge. No one team or role has responsibility for post-integration testing. Teams can’t easily understand or resolve merge conflicts found after weeks of isolation, so instead they tend to delete the changes they don’t recognize. Minor repairs to their process (many tried and failed already) won’t solve the fundamental problem that needless isolation causes harms. Only a comprehensive new branching strategy will solve.
  • Plan: implement a branch by quality strategy whereby the four teams, who are, after all, all working on a single product which is ultimately totally integrated, do their primary development together in one Dev branch.
  • Solvency: combining team branches into one will actually eliminate most code conflicts, and make any remaining conflicts smaller, simpler, and quicker to resolve. Earlier integration will force a number of additional practice improvements they are currently avoiding, most especially teamwork and coordination upon each checkin. Bugs caused by integration can be detected earlier. The teams will experience pain at first, especially because they have limited automated testing and regression will place new demands on their testers, but it will expose better data about their specific testing priorities, leading to better fixes in the long term. Finally, the early and frequent integrations should instill a sense, currently missing and sorely needed, that they are ultimately all one product team and that their success is measured not by the achievements of any one sub-team but by the value of the finished product.

So there you are. If you were a traditional-style high school policy debater in the USA in the late 1980s and you now want to know a key Lean management practice… yeah, OK, I’m the only one, aren’t I? Well, I’m good to go now.

And that’s my message here. I’m geeking out a bit about my modest debater past, but the real takeaway here is that sometimes I let learning get in the way of my learning. My new A3 trick is probably sub-optimal in lots of ways, but it’s superior to the A3s I wasn’t going to write at all because I didn’t know how.

Advertisements

Vertical slices and SOA

Even the term “vertical slice”, a common stumbling block in agile adoption, kinda implies a large-scale n-tier application. Modern architectures and agile can play nicer together than that!

“Story sizing”, decomposition, vertical slice of functionality, Minimally Marketable Feature (MMF), Minimally Viable Feature (MVF), and my personal least-favorite, Potentially Shippable Product Increment (POS*). I think it’s the biggest hurdle for orgs moving from not-agile to agile. I think many other problems with initial adoption (estimation, timebox sizing) boil down to this one.

Every dev team I see trying to get started with this initially tries exactly the same wrong thing, usually because it’s how they’ve organized their work in their not-agile process before: they want to split things up by architectural layers, and build, let’s say, all of the database and then all of the business layer and then all of the UI.

Any time I see a sentence with “do all of… and then all of… and then all of…”, what’s that remind me of? Oh yeah: waterfall. There are reasons we devs cling to this in spite of ourselves. Maybe another post another day.

The thing is, “vertical slices” aren’t satisfying either. Every single team I’ve worked with resists and/or struggles with this for basically the same reason: the users asked us for an epic-sized feature because that’s what they want. They don’t want a slice of a feature, they want a feature. One of the cornerstones of agile is that we’re doing these short iterations in order to get feedback from users. That’s hard to do when they’re inherently unsatisfied with these ugly proto-features they don’t want (and they’re deeply alarmed when someone calls them “potentially shippable”)!

I discovered an interesting thing at one of my customers recently, though. We struggled with “vertical slices” vs. Big Database Up Front for like two days, and only then did I find out how much they’ve worked to transition their legacy LOB apps into a SOA model: collections of beautifully loosely-coupled services and APIs with clean interfaces talking to each other to achieve some nice user-interfaced result.

Wow! This was exactly the hook I needed. Because what is a service or an API if not a neat encapsulation of a small logically-contained bit of functionality? I realized that even the term “vertical slice” implies a traditional n-tier architecture in kind of a large-scale sense. Today’s SOA (is that still what we call it?) has already broken down those giant tiers into little slices. The team didn’t even realize they were already doing it. Each service might have its own little n tiers, but on a much smaller scale. Small is exactly what we need!

My customer got stuck trying to decompose from the epic feature level, still thinking about all the little services they’d need to assemble (plus BDUF) in order to hook up a UI and show a “vertical slice” to the user. They didn’t see their services as value in themselves, but I think the value is right there. APIs don’t have a user interface, but, um, the “I” stands for “interface”. They encapsulate something someone finds useful, and they are independently testable. Better yet, they almost demand automated testing, a practice we already wanted to reinforce. Imagine: at the iteration review, sure, the team should demo UI mockups early and often to get feature-related feedback from users… but can’t they also “demo” individual APIs (that implement underlying business capabilities and algorithms that the users do care about) by reviewing the acceptance criteria for the service and showing off a suite of automated test results to prove that the logic works?

I guess my point is that, as it always has, agile practice goes hand-in-hand with what we know about how to architect high-quality, maintainable software. I was just pleased to understand this in a new (to me) way.

* j/k. But I do hate that term.

Seattle Scrumpocalypse 2012

Are there any conditions in which a Sprint’s timebox can legitimately be extended?  I think I might have found one.

In my Scrum-damentals webcast I’m pretty strict in advising that teams should not extend the timebox of a Sprint, even when things go pear-shaped.  Why not?

You and your team have certain goals as you’re getting ramped up with Scrum:

  • Learn your true velocity based on real-world measurements
  • Improve your estimating and forecasting capabilities through regular feedback
  • Refine your story sizing and task breakdown skills
  • Develop a comprehensive definition of done (e.g. don’t overlook needed work)
  • Over time establish reliable metrics for future forecasting

Extending a Sprint in order to complete all of its deliverables undermines all of those goals.

Besides, there are better alternatives.

  • With the Product Owner’s approval, you can reduce the scope of the Sprint at any time for any reason
  • I personally like a Kanban WIP (work in process) limit to be in place from the start of the Sprint, because if you need to cut scope mid-sprint, it’s a lot nicer to have some completed stories (credit!) and some unstarted stories than all half-finished ones (no credit for any of them!)

This week one of my Scrummy friends presented me with an interesting challenge and got me to reconsider—or rather, refine.

You may have heard that we had a little weather up here in the Northwest.  Being the tech city that we are, nearly everyone (who doesn’t already do this full-time every day) retreated to work from the comfort of their living room and their fleecy pajama pants.  I won’t speculate on what this does to teams’ productivity, but we can safely say that widespread power outages that started on Thursday knocked out all but the most hardcore workaholics (running their laptop on battery, tethered to their 4G smartphone, recharging off the Prius in the driveway, you know the type).

My friend spent his week trying to salvage a Sprint which was scheduled to end on Friday.  He phoned in each day to his daily Scrum.  Standing up isn’t prescribed by Scrum, but lots of teams appreciate the value of a standup and he indeed stood up, pacing the kitchen during the requisite 15 minutes.  They lost time to and were blocked by the storm in various ways that I don’t know all the details of, and on Wednesday he lamented to me that, with all they’d have to cut from scope, they were facing a “failed Sprint” because you “can’t” extend it, not even to account for the weather.

I gave this a little thought and asked, “didn’t you determine your Sprint backlog based on your team’s capacity?”  Of course, he said.  “If a federal holiday fell in the middle of your Sprint and your entire team missed a day, would you count that against their capacity or would you plan around it?”  Don’t be silly, you wouldn’t count a federal holiday as a team Sprint day any more than you’d count a weekend, he said.  (Neither one of us is the tethering/Prius type.)

“So, if nature drops the equivalent of a federal holiday into the middle of your Sprint, why not move the Sprint around it?  If you move the Sprint end date by one day, aren’t you just keeping the Sprint the same length it was before?  The same duration your team had in mind when it accepted the scope?”

So, in my mind, this is a legitimate reason to change the end date of a Sprint.  I’m not sure it even counts as “extending”—the point is to keep the capacity constant.

I also told him that I don’t remember seeing “failed Sprint” in the Scrum Guide

Finally, if you think a little snow is a bad reason to lose productivity during a Sprint, Seattle sportswriter Art Thiel and I invite you to shut the hell up.

Keep warm, Seattle!  And don’t run your Prius inside!

Scrum for One

My customer is a team of one, which means that by the Scrum Guide he can’t be “doing Scrum”.  Whatever.  Scrum still has a lot to offer in his situation.

"Same procedure as every year, James."

My sächsische (Saxon) friends introduced me to the traditional New Year’s programme Dinner for One, in which elderly Miss Sophie’s loyal manservant James, due to personnel constraints, must attend to every detail of her 90th birthday party himself.

Last month, I visited a customer to perform NWC’s first official Scrum Health Check, a new offering I stole adapted from my colleague Martin’s blog post (“Are you doing Scrum? Really?“).  I sent lots of advance-prep materials and brought a beautifully-crafted checklist that I planned to use to determine their Scrum baseline.  But all that went out the window when I arrived onsite and found that my customer was a Scrum Team of One!

And then I tripped over a tiger

Me: First question.  Do you have Development Team(s) of 6±3?

Customer: Um, no.  There’s one other guy, sometimes, but we had this re-org and he reports to another manager now so… yeah, it’s pretty much just me.

Me: All righty!  Our Scrum Health Check is finished.  You are not doing Scrum.  Now, let’s talk about how you can use Scrum to make your… er, team… most effective in your situation.

And that’s what I’m about with Scrum.  Instead of throwing the entire Scrum Guide out the window, we kept it around and talked all day about the other Scrum practices my customer could use: in particular, we identified an ordered backlog and proper structure and focus for the biweekly Sprint Planning and Reviews/Retrospectives, to provide transparency and improve management buy-in.  These were his most urgent needs and we both agreed that Scrum could help—that’s why he picked it in the first place!

"Well, I'll do my very best!"

I consider myself fortunate to have arrived on the Scrum consulting scene right at the time when Scrum is making changes to become less rigid, less religious, and more widely useful (without diluting the structure that makes it so effective).  It would be a stupid waste (for all of us) to turn my customer away from Scrum just because he isn’t canon.

Scrum Renaissance

Are you sick and tired of rigidity and attitude in the Scrum community?  Me too.  So is Scrum.org.  Let’s get over it together so we can get some work done.

Stuff has been brewing in the Scrum world this autumn, and two big events aligned last month: the Professional Scrum Trainer global meetup followed by the ALM Summit.  I’m not a PST (yet), but the impact of the meetup was unmistakable as fired-up PSTs stormed the Summit and they and Scrum.org rolled out both conversations and official sessions with some of the new messaging around Scrum.

My PST colleague Martin is tackling a number of the substantive changes in his blog (“Are you doing Scrum? Really?” and others).  I think he captures well what I’m most excited about: the new language and the new approach do a lot to undo the rigidity and religious warring around Scrum.

To me, the first big hint of changes to come was when David Starr joined Scrum.org back in July.  In his announcement, he pointed out that he’s “more pragmatist than zealot” and wrote favorably about a long list of practices that many folks in the process community have made out to be “competitors of” or “incompatible with” Scrum for some reason.  I know David’s been involved in the Scrum.org world for a long time, but it struck me as potentially a big deal to have him officially on board.

Bringing a measure of tolerance to the process wars

In October, we got more evidence from Scrum.org that change was coming: “Scrum is Open for Modification and Extension“.  A coder might initially say “open to extension, closed to modification”, so it’s interesting to think about why they didn’t.  It’s gutsy for Scrum.org to put itself out there as willing to change the framework itself in response to community feedback.  Modification is formalized, which means it does not seem to be an invitation for immature teams to pick and choose and throw out and make up practices willy-nilly and call them “Scrum”.  I’m interested to see where that goes.

It had a good run

That brings us to the really big news: the death of Scrum But.

I have no doubt that Scrum But, as a concept, was intended to be helpful. I know this because I just finished co-authoring a slide deck built entirely around Scrum Buts: why your rationales are legitimate reactions to the difficulties of Scrum practice and should be heeded, and why a more thorough understanding of Scrum principles is almost always a better solution than a Scrum violation.  I am certain I was trying to be helpful.

Seriously, in the space of two weeks I went from “the trouble with your Scrum But deck is that you keep refusing to spell it with two Ts” to “you’re gonna have to throw out that Scrum But deck”.  Two weeks!  Is this a Renaissance or a Revolution?!

Scrum But is dead.  Long live the Scrum Curve!

The Scrum Curve: no buts about it

I stole this from Martin because it’s awesome and it’s a much more useful way to illustrate the point that matters: Scrum isn’t a boolean, it’s a continuum.  Teams may be doing Scrum to greater or lesser degrees.  Yes!  There is room for variability in practices that we can still call Scrum!  Now, instead of clucking (get it?) at teams for being “Scrum But”, we can help them refine and improve their Scrumminess to improve their performance. Instead of all or nothing, we can fully support incremental adoption and growth over time, including extension practices (like from Kanban) that working together take teams to Scrumfinity and beyond.

Update: It’s a good day for a Renaissance!  By delightful coincidence, Scrum.org rolled out their new front page today.  I’m excited to be engaged with what’s coming next!

Just look what they found space for!

ALM Summit: devgrrrl Evolution

I’m working on a blog post wrap-up of the 2011 ALM Summit experience, so today I did a little bit of white-glove research in the archives.

I can’t find archaeological evidence of my attendance at what was then still called p&p summit in 2006, but I know I was there because that’s where Peter Provost & Michael Puleio gave their “Agile Talk on Agility” which blew my mind and changed the way I do software and public speaking and made me a loyal Summiteer for life.

I did, however, find some real treasures: my p&p 2009 and 2007 (!) adventures in liveblogging.  They’re essentially my scribbled notes, so a lot of the actual content is completely unintelligible now, even to me, but they provide a window into my growth as an attendee and as a professional in this field.

Even at the time I was writing them, I knew perfectly well that those blog posts were an outlet for my insecurities as a dev and a #devgrrrl, so you’ll see lots of that in there (see also the posts in between, from TechEd 2008).  If you read them in chronological order, I think you’ll see a growing level of experience and confidence.

I switched to livetweeting the rebranded #almsummit in 2010.  By then, I was fully aware that the great value I get out of conferences isn’t the received wisdom from a speaker in a lecture hall and never has been and I’m not sorry.  (See also: my college, with an average class size < 20 and a high degree of informal access to faculty.)  In 2006, 2007 and 2009, it was clear that I learned more by talking with colleagues about the previous hour during the 15-minute coffee breaks than I did in the hour itself.  That’s why I always worked so hard to recruit a good group to come with me.  The other big change in 2010 was that I quit being afraid of the broader community, and I put myself out there to engage with them.  Maybe the interactivity of the Summit’s little Twitterverse helped: I started to see that highly skilled professionals struggle with the same issues as I do, or even struggle with issues my team had already, in our way, solved.  I even got retweeted!  In other words, I might have something to contribute!

Plus, I was thrilled to witness the impact of the community’s livetweeting on the entire 2010 Summit.  We stopped talking about Agile in a waterfall way (top-down, planned in advance) and started actually putting Agile Talk About Agility into practice (self-organizing, continuous feedback)!  It was like our collective lightbulb moment!  And, as Agile techniques are wont to do, it left me feeling smart and empowered.  I can do this!

The other big event in 2010, not recorded anywhere, was my chance meeting with Linda from Northwest Cadence during one of the aforementioned coffee breaks.  We hit it off, which set some slow-moving wheels in motion throughout 2011 and landed me where I am today.  It’s a good thing I’m not (too) afraid of the ALM community any more, because I’m up to my neck in it!

Stay tuned to the Northwest Cadence blog, where I’ll talk more about making the transition from acolyte to Platinum Sponsor at this year’s Summit…

Underpants Gnomes in Kanban

… or, no good joke goes unpunished

Kanban offers a lot of potential for targeted, specific, incremental change, but you will need to have or create a problem-solving culture to avoid stalling out.

Earlier this year I made the wisecrack around the office that my problem with Kanban is, it feels too much to me like the Underpants Gnomes:

  1. Visualize work
  2. ???
  3. Process improvement!

Northwest Cadence just got cheekier. You're welcome.

Steven, who thinks I’m funny, ran with it just a bit.

Last night at the ALM Summit, we had a great breakout (“Open Space“) session at which some serious agile luminaries held forth on the theories underpinning both Scrum and Kanban and process improvement in general.  Steven outed me and my joke, so now I think the heat’s on.  Can I unpack this idea and turn it into real learnings, or was it just a cheap shot?

Well, let’s put the obvious out there first.  Although Kanban does literally mean just “visual card” or “visual board”, Kanban in the context of software development process improvement doesn’t just say visualize work.  That’s only the first step.  There are supposed to be other steps after that.  Right?

Aren’t there?

This is where, for me, we start to run into issues.  I’m not being theoretical or cheeky here.  In my former organization, my team ran Scrum (-but) for 2.5 years; another nearby team made the decision from the executive level to implement “Lean-Kanban” instead.  They expressly agreed with something I’ve heard Kanban proponents advance as a strength: unlike Scrum, they could adopt Kanban without changing any of their existing process.  (They seemed awfully excited about that.)

They got great, in-depth training (which they kindly invited me to sit in on).  The following week, huge Kanban boards went up to visualize their entire portfolio.  The first thing they “learned” (unnecessary quotes because everybody on the team already knew it) was that they were massively overloaded: at least three times more work underway than they could possibly complete on time.

When a 12-person team’s Kanban board fills all the walls, floor-to-ceiling, of a 40-seat conference room, it’s covered in 3×3 post-its, and each team member needs four to six laminated South Park avatars to identify all the work they’re doing at any one time, they don’t need a high-priced consultant to tell them where the dysfunction—sorry, “opportunity”—is.

And how’d they address the dysfunction?  As far as I know, they didn’t.

Why not?  Honestly, I don’t know.  Kanban calls for teams to limit work in process (WIP) and it’s a fairly obvious next step in this case, in some form.  I know they learned about limiting WIP, because I was in their training classes.  It was easy for my friends on the dev and BA teams to blame upper management and stakeholders for failing to act, but I don’t know if they really fought for WIP limits or just rolled over.  I’m certain no one at any level sought out or embraced the pain of significant change.

A year and a half later, the Kanban-wallpaper was still up, and the team still said they were “doing Kanban”.  At a local Lean-Kanban conference, I got a chance to sit down with some of them during a break and asked how the process was going for them.

“It’d be fine if the BAs would quit dragging us developers into their ATDD meetings.  It takes up all our time and we can’t get enough code written.”

“Hey!  What do you expect when you’re so slow delivering code that we have nothing to UAT?  We don’t have anything else to do but work on future requirements.”

I gather that they still haven’t implemented WIP limits, at least not properly, and they’re not managing their queues in or out.  We’re sitting at a Kanban conference and these attendees are still near the point of food fighting because they’ve decided the dysfunction is each other instead of their process.

And that’s why I think the Underpants Gnomes are not just a one-liner in Kanban, but a real risk that should be taken seriously and planned for.  What happens when…

  • the team doesn’t know how to find the root cause of a dysfunction?
  • the team can’t agree on what the dysfunctions even are?
  • the team identifies a dysfunction, but doesn’t know how to solve it?
  • the team tries to solve a dysfunction but just replaces it with another?
  • the team’s organizational culture doesn’t support problem-solving?
  • the team isn’t empowered to make the changes they think are needed?

A team full of highly motivated problem-solvers with great communication and teamwork skills will probably get good results with Kanban, but honestly aren’t they all too busy building carbon-nanotube space elevators while curing cancer?  Or writing the book on process improvement?  Seriously, teams that natively possess awesome diagnosis and problem-solving skills, are they even having this conversation?

... and it's a Big Visible Display, too!

The rest of us need to pay attention to the Underpants Gnomes when we’re getting started in Kanban.

What’s your plan for Phase 2? Can you do it on your own or do you need help getting there?

Note: if you are/were on the team I’m talking about and I’ve gotten any of the story wrong, please send me additions or corrections or perspectives so I can update!