Tuesday, March 27, 2012

don't let broken stories wreck your team's velocity

Capturing requirements in Agile stories is finicky business. Stories need to be just the right size and shape, have the right bits of detail, point to a clear outcome. They must capture the who, what, and why in a way that speaks unequivocally to the user and to the team. Badly written user stories will slow down your team in any number of ways.

A few recommendations...

Get the right people writing the story.
Even if you've done lots of requirements gathering, or the functionality seems like a no-brainer, don't assume that you have sufficient information to compose stories without stakeholder participation. In fact if at all possible, the stakeholders should do the writing. You are there to ask questions and help clarify.

Without this collaboration, you will end up going into iteration planning with hobgoblins, not real stories. The team then must devote time to figuring out what's actually needed, returning to the stakeholder with lots of questions, rewriting and rejiggering.

And if these half-baked stories sneak through planning and make it onto Kanban, the whole iteration slows down while the team strives to make sense of them.

Be specific.
That sounds elementary, but stories are written all the time with no actual users in mind, only "theoretical" ones. Or the stories themselves are hazy and dreamlike.

Imprecise stories are velocity killers. They waste everybody's time because they're sooooooo open to interpretation. They lead to unnecessary work that nobody asked for, fixes and back-outs of code that never should have happened, and a rebuild (or discard) of the system once you finally do get feedback from real users. 

Make sure stories represent actual people who can answer questions, help with details, and verify that the team is meeting requirements. Then, make sure they are written so that both the product owner and the team understand what's needed upon the first read.
    Bad: "UI team needs to fix scheduled-payment section." This story is overlarge and clear as cat litter. It also points to...what user? The UI team?

    Much Better: "As a credit union member, I need to see my scheduled-payment history displayed on a single webpage." This story represents a real user. And you don't have to tease it apart to find out what the user is asking for.

    Scale it down.
    Epic stories—in which nothing is done until everything is done—linger in the iteration backlog accumulating bulk, then haltingly heave across the Kanban board leaving wide snail tracks. They obfuscate progress, and the team learns very little about what it can actually accomplish.

    Epic stories have a place: It's in the product backlog. Leave them there, and break out stories small enough to be completed in one iteration.

    Don't forget the exit criteria.
    If a story does not clearly indicate when the work is considered done, you run several risks. You can end up doing too much, exceeding what's required, tying ribbons all over the car engine. Or you can fall short of what's needed. Or you can simply do the wrong thing.

    Defining exit criteria also can help to determine if a story is sized correctly. A long list of criteria indicates that the story should be broken up into smaller ones. Conversely, if stories are too small, exit criteria frequently overlaps.

    Take these three stories:
    "User should be able to select thumbnail of image"  
    "User should be able to select 200-pixel-wide version of image" 
    "User should be able to select 600-pixel-wide version of image" 
    All three involve many of the same tasks to put this functionality in place. So why have they been broken apart? Fragmenting work in this way causes complicated interdependencies between stories and makes it next to impossible to make story-point or time estimates.

    Read some more about user stories.
    Mike Cohn's book User Stories Applied is a good read for any Agile team looking to improve story writing. And here are a few links that I've found useful:

    Monday, February 27, 2012

    agile makes the work transparent

    transparency is undeniably more efficient.

    Developing products on your own with inadequate checks and balances for long stretches of time might seem acceptable, or even cool, for a while -- if you're inexperienced or a cowboy. But in reality, it's a burdensome and buggy process. It's rife with questionable decisions, bad habits, and shortcuts. Egos get tied too closely with methods and products. Change causes pain. Troubleshooting and maintenance becomes a real killer.

    And pity those who inherit the lone wolf's pile of work later on.

    Lean-Agile's systematic approach helps ensure that the entire team is aware of what is being worked on and how the work is progressing. Tracking tools (we use FogBugz to good effect), Kanban boards, incremental unit- and acceptance-testing, daily standups, iteration planning sessions, retrospectives, and vigilant facilitation at each point in the process help to keep team members from straying off course or going underground.

    problems cannot hide.

    Agile's transparency can work so well that it is sometimes misunderstood as the cause of dysfunction and antipatterns. What it is actually doing is uncovering quagmires that have been hiding there all along.

    Shortly into our own Agile implementation, a group of items infested our product backlog and refused to go away. These Zombie Features and Defects made something that we suspected all along abundantly clear: We were spending too much time on certain customizations at the expense of working on far more valuable common-good products and services. It also became apparent in our planning sessions that multiple projects vied with one another for top priority. And of course when several projects are a top priority, none of them are. Lean-Agile gave us the tools to quell priority conflicts and really prioritize -- but I'll say more about that in a future blog post.

    everybody is informed. everybody learns.

    Agile team members must be highly cognizant of one another's work. They have to be involved in planning iterations, evaluating the team's overall progress, stepping in where needed, developing and agreeing on best practices, and testing and vetting one another's contributions. Cross-functional learning is an integral part of the workflow. Team members develop an ever-increasing understanding -- and a deeper appreciation -- of other specialties.

    Finally, as a project manager, I have a good idea of where our team is on all projects, what our capacity is at any given time, and what impediments block our progress.

    Without this, I'd be pushing a river up a ladder in the dark.

    further reading

    Thursday, December 17, 2009

    teeny tiny links can hurt usability

    Consider the following Web site navigation:

    Home | Priorities | Giving | Council | Alumni Efforts | Foundation Challenge

    You might be able to guess that this is the main navigation for an alumni site of some school. But aside from Home, can you formulate a clear idea of where any of these links will lead?

    always crashing in the same car: recurring mistakes and misuses of the web


    Supposing your goal is to join this institution's alumni association. Which of these links would you follow first? Would you follow any at all? And what exactly is a Foundation Challenge, anyway?

    You see this all over the Web: critical navigation distilled down to as few words as possible--preferably a single word. Design teams hold meetings in which everyone struggles to come up with the right word to describe a category of activities, a diverse collection of information, a whole branch of services. It's mind-numbing work, and for a good reason: few single- or two-word descriptions are up to the job. The result is navigation written in a sort of cryptograph that's maybe understandable to people within the organization but that users must decode by pogosticking all around the site.

    This overcondensation of information started with the earliest table-based Web designs, the going mindset at the time being
    1. the zeal to keep page dimensions small enough to be seen in their entirety on very small computer screens

    2. the assumption that users are never willing scroll under any conditions
    The accepted practice was to design Web sites roughly as squares about 600 pixels to a side. Navigation was encased in minute rectangles, stacked in attenuated columns, or paired with distracting and largely useless graphical buttons. Sites of any volume frequently had architectures many layers deep to accommodate the brief amount of signage available in each section.

    Eventually, better equipped and more informed Web design delivered us from these claustrophobic dimensions. But the wording of links seems to be slow in recovering. Navigation still frequently gets squinched into little bitty wafers. One of the worst offenders of this is the nearly universal horizontal top navigation sandwiched just below page banners or conflated with the banner design itself. Aside from often falling prey to banner blindness, this type of navigation frequently allows for nothing but the briefest of signage.

    Contrast this with the findings of Jared Spool et. al., which show that links of around 7-12 words are far more successful at creating a strong scent of information. This wording can, and often does, include associated text, such as "To see previous issues of Dairy Digest, visit our archive."

    Of course, length alone doesn't determine whether links will actually help users make correct navigational choices. It's the wording that must make it abundantly clear what information lies ahead. Wording that instills confidence in the navigating user: Yes! I am heading in the right direction!

    I discovered a fine example of this in the late '90s when I worked on the marketing team in Penn State's Office of Undergraduate Admissions. Our team spent several months gathering marketing data on student's applying to Penn State (and their families) to learn what information worked best for them -- and how best to deliver that information on the Web and in print. At the time, we had a pretty good idea that the phrase "Prospective Students" meant little to them, and our research confirmed this. But what we learned in addition was that widely used "Future Students" also missed the mark. In the end, we found that "Students interested in applying to Penn State" or "Students interested in attending Penn State" spoke to our audience much more clearly, and that's what we used in our materials.

    The next time you find yourself or your design team wording navigation by casting about for le mot juste, entertain these questions:
    • Is the site design imposing too much of a space limit on navigation?
    • Who are we helping by condensing the text of our links down to one or two words?
    • Do we actually know what trigger words work for this audience?
    Granted, sometimes strong scent of information can happen in one or two words within a tiny wafer somewhere near the top of the page. More often, it cannot.

    Tuesday, October 20, 2009

    write 2.0: managing content in a mashup world

    Following are the slides from the presentation I gave today at the Penn State Web Developers Forum on handling content for Web 2.0:




    This presentation is also published at docs.google.com/present/view?id=ddjp8wn9_1271dnxfh2cg.

    managing the collaborative web

    Following are the slides of a presentation I gave yesterday at Penn State in which I share my philosophy and approach to managing collaborative Web environments:



    This presentation also is published at http://docs.google.com/present/view?id=ddjp8wn9_1389hk6r9md3.

    Monday, August 11, 2008

    protect your coldfusion site against sql injection attacks

    As of this writing, a particularly virulent SQL injection spider attack is largely targeting sites running ColdFusion.

    Here's how the attack appears in server logs:


    The code creates a cursor of all the user tables and all the character columns in the database. It then appends a string to each of the columns, making an ungodly mess.

    Mark Kruger's post goes into a great deal of helpful detail about how this spider operates. If you do a Google search on this attack, you will quickly get a feeling for how widespread this is.

    If your site is getting hammered, and you need to buy time while you fix vulnerable code, there are scripts such as this one posted in ColdFusion Developer's Journal on August 8, 2008, which can be modified to thwart this most recent attack thus.

    Be aware that this only buys time. The most effective course is to make sure your queries are protected with cfqueryparam. Ben Forta's primer on cfqueryparam provides a very good start on protecting code from SQL injection scripts. While you're fixing your queries, don't forget the ORDER BY clause, another frequently overlooked vulnerability.

    It can be time consuming checking all your queries if you have a large amount of ColdFusion code to wade through, not to mention nerve-racking if you are doing so while the attacks are rolling in. Fortunately there are tools such as QueryParam Scanner that will peruse your code and return a list of any unprotected queries. Unzip this application and place it in a directory in the Web root of your development server. Go to the application in a Web browser, follow its directions, and you will quickly have a report of any vulnerable queries.

    Friday, June 27, 2008

    how content delegation and web-standards compliancy are reflected in your site stats


    What does it take to be successful on the Web? The answer to that is simple and yet not so simple: Provide relevant information. Make it easy to discover... >>> Read the rest of this guest article on Dr. Terry Etherton's blog at
    blogs.das.psu.edu/tetherton
    .