Software management

Who cares if you’re doing scrum or not?

Posted on by will

Have you ever heard the question: “Are you doing Scrum? I mean, really doing scrum?” Or: “If I take the Scrum textbook practices, but change one or two things to suit my business, software or people, is that still Scrum?”

At the Agile Lean Europe Unconference in Berlin yesterday there was quite a bit of talk about what Scrum is, and what it actually means to ‘do’ scrum. There was an open space on the topic, where one of the participants said, in response to the above questions: “the answer should be, Who cares?”.

There’s a concept borrowed from Japanese Zen practices called ‘Mu‘. Mu is the third possible answer to a binary (yes/no) question.

“Are taxes good or bad?”

The answer is they are neither good nor bad. The real answer is larger than the context of the question that was asked. The answer is ‘Mu’. What Mu is really saying, is, “un-ask the question”.

Another example: think about a single bit in a read-only memory module in your computer. When the power is off, is the state of the bit 1 or 0? The answer is: it is neither. It is in a Mu-state.

Back to the original topic. “If I change this or that from Scrum, is it still Scrum?” The answer is Mu. It doesn’t matter if it is still scrum or not. What matters is if you are delivering high quality software. If you are measuring that software and iterating. If you avoid waste and decrease time-to-production. If your team is happy, self-organising and efficient. Who cares if it’s “scrum”?

* Note: Robert M. Pirsig speaks about Mu in his amazing 1974 book, “Zen and the art of motorcycle maintenance“.

Software update cycle: faster every day

Posted on by will

My Atari 2600 never got a firmware update. Not a single one. Neither did any of the game cartridges that came with it.

In the early days of software, ‘soft’ware was really just a different kind of hardware. It was built, packaged and shipped exactly once. If you shipped it with a bug, that bug would stay there.

‘Softer’ storage types (tapes, floppy disks, etc) and better distribution allowed software companies to release new versions more often. Many years between major versions became one or two years, but updates to a specific version were uncommon.

The internet shortened the cycle even further – turning one or two years to months for many software products, and allowing automatic updates of existing versions to fix bugs, patch security holes, and so on.

Seamless and fully-integrated update and application management technology, like the App Store for Mac, can bring the cycle down even futher – changing months to weeks between updates.

What happens when the cycle is even shorter? Then you get web products. Sites like WordPress.com or Amazon can push an updates to production servers multiple times per day.

How fast are you?

SCRUM User Stories, Part 2: User value over business value?

Posted on by will

My last post about User Stories and putting the value for the user first in any product decision generated some great discussion on Twitter. As with anything there are some varying views on the topic, and as one example I was pointed to Liz Keogh’s post on user stories.

Liz argues that User Stories should be better named “Stakeholder stories”, as the things you build are addressing the needs of varying groups of stakeholders, only some of which are the end user.

In the creation of any product there are of course many stakeholders who need to be satisfied: the CEO, shareholders, investors, marketing people, the legal department, and so on. In the design of the business, of course the internal stakeholders have the most important requirements. What sort of market are we going into? What segment will we serve? What problem or user need do we attempt to address with this product?

But when you start designing the product that the user will have in their hands, then the user needs to be at the heart of that design solution. Here, the user needs have to come first.

But what about all the stuff that you have to build into products that users don’t want, or even hate? Stuff like CAPTCHAs during registration processes, or advertisements? If the user’s needs come first, why does this stuff exist? To answer this, let’s take a step back and look at where user stories come from.

User Stories are not immaculate conceptions: they don’t just appear out of the blue, but they are thoughtfully created to address needs of the product and the business. On other words, they are derived out of the product vision and the surrounding business model.

If your business model involves monetisation through advertising, then you have a problem to solve: “how can I enable advertising in my product?” It’s clear that the user is not at the heart of the decision to enable advertising, but business models are complex and have to satisfy many stakeholders and solve many problems. At the business strategy level, the end-user is only one of multiple players, and the user doesn’t always come first.

So you have this problem: you have to enable advertising. How do you solve it? Do you slap a full-screen takeover banner for some random personal hygiene product on your start screen? Probably not. Do you enable Google AdWords to show advertisements relevant to the content in a meaningful way? Getting warmer. Do you study the user’s interaction on the page to determine where the advertisements should be placed and how they should be visually displayed to ensure that users understand what is a sponsored link and what is your own content, to avoid frustration and confusion from the end user and maximise the meaning and value they get when they interact with the advertising? Better still.

What is at the heart of each of these decisions? The user. This is where the user comes first – in the design of the solution to the problem. In the User Story.

User-centric design doesn’t absolve you (regrettably) of the need to be aware of the business context or the constraints of your business or industry: it merely proposes that the user is at the heart of how you solve your product problems and how you work with the constraints. Keeping the user at the centre of your user stories by insisting they start with “As a User…” helps you stay focussed on the people who will be interacting with the stuff you’re building.

SCRUM User Stories: As a User, NOT As a Manager

Posted on by will

The success or failure of a piece of software, or any product for that matter, is how well its users are satisfied, and how well it solves their needs. In the world of web software, adding functionality is rarely the differentiating factor that will lead to the winning product. More likely the winner is the product that solves the user’s problem in the simplest, easiest and most delightful way.

In other words, product design is all about the user: solving their needs the best way possible. Every single line of code you write should help the user solve their needs better and easier…

… which is why I am often confused when I see user stories like “As a product owner, I want…” or “As a manager, I want…” Or worse still: “As a data centre, I want…”

Who ever asked a data centre what it wants?

User stories start with “As a user…” for a reason: the process of writing a clear sentence that starts with “As a user” forces you, with each product decision you make, to consider and understand how what you are about to do allows you to solve the user’s needs in a better, more efficient way. If you can’t do that, then you have to question why you are adding this user story at all.

Avoid stories that start with anything other than “As a user”. That’s why they’re called User stories. If you can’t work out what a user gets out of the deal, it probably isn’t worth it.

Move fast

Posted on by will

The world moves fast. Your competitors move fast with it.

Users move fast, too. Users are more fickle than ever before. This month’s UK WIRED magazine rated Twitter as “tired”. This for a service that’s only five years old with a still-growing userbase. Ouch!

In the world of web products, building and releasing beautiful and delightful products and user experiences is only half of the battle. The other half is winning (and keeping) your userbase. Your product could have a net promoter score of +80, but if it still only has 10 users, is it really successful? If you build it, they won’t necessarily come.

Users want stability and reliability. Once they have settled in to a product that solves a particular need, it’s that much harder to get their attention to yours. At the same time, and perhaps contradictorily (who said human beings were simple?), users also crave the new. New updates, new versions, new features. News, blogs and social channels thrive on the new.

The web has sped up business dramatically and continues to speed up software product innovation. It’s a race to the bottom – at some point we won’t be able to go much quicker – but we’re not at the end of that race just yet. The strategy to compete in this space, I think, has two major components:

1. Work fast. Build fast, iterate fast: improve fast.
2. Be ready for when we hit the bottom. When we can’t go faster, on what track will the next race be run? Which race can you win?

Important note: fast doesn’t mean chaotic and unplanned.

User testing: an input to innovation, not a source of it

Posted on by will

Benz “Velo” model (1894)

It’s hard to imagine a life without cars. Before the automobile was invented getting around was a costly and particularly time-consuming business. That quick drive to the hardware store that takes 15 minutes in the car might have taken several hours on horseback, or an entire day in a horse-drawn carriage. Looking back, it’s hard to imagine how anyone was motivated to move anywhere at all. (In fact, most people didn’t… before the automobile, and particularly before rail, it wasn’t uncommon for people to spend their whole lives in the town they were born in.)

So if you could go back roughly 130 years and show someone the automobile, they would love it, right? If you asked someone the question, “is this product something you would buy and use?” the answer would be a resounding “Yes!”. Right?

Well… not really. When the first automobiles rolled onto the streets in the late 1800’s, they were met with skepticism and fear. People (and horses) were terrified by the noise, and people just couldn’t understand why anyone would need to go so far or why they would be in such a hurry. In other words, the automobile was an invention for a problem no-one had. Or, to be potentially more precise, a problem they didn’t yet know they had.

If you had shown concept drawings of the automobile to a focus group in 1885, or a working prototype to a user testing group, you might have walked away thinking that you’d be better off working on putting a clock radio* in your range of horse-drawn carriages.

The point is, you can’t expect users to know what they want. Innovation doesn’t come from asking a customer focus group “what products do you want that haven’t been invented yet?”

The iPad was a solution to a problem that no-one really had. Companies and products that innovate are successful because they can predict user behaviour before the users go anywhere near it. They are also good at convincing (selling) users that they have problems that their products can solve. No-one had a standing-motorised-transport-problem before the Segway was invented, but the company behind the gyroscopically controlled contraptions still managed to ship over 50,000 units by 2009.

We recently ran some early user testing on a product concept that we are working on. Based on the results, some members of our team were hugely disheartened: most of our test users, when asked if they could imagine them getting major value out of one of our concept’s major use cases, said “no”. Some thought we should go back to the drawing board. I think they missed the point…

User testing is one input to product design; one of many. Getting the input and responses of potential users early in the design process is crucial; however to make the results really meaningful you need to interpret them in relation to the test user’s context… and sometimes I think you just need to take the responses with a grain of salt. You also, I think, need to understand that innovation often comes from having the courage to challenge users on what they think they need and what problems they have.

* I’m of course aware that there were no clock radios in 1885. The first transistor radio wasn’t invented until 1954 by Sony in Japan. Call it poetic licence.

Release it: now

Posted on by will

Release your software to real users as early as possible.

Building software for years without ever releasing any of it is like working in a kitchen and letting the food go cold and mouldy before serving it up.

Building software is a collaborative process – not just amongst you and your colleagues – or between you and your partners – but between you and your users. Feedback from real users helps you guide the future of your product and your immediate investments. It helps you prioritise and optimise. Making product decisions without real user feedback is quite often, I think, guesswork. Yes, it’s (hopefully) educated guesswork – but it’s guesswork all the same.

You can learn a lot from user testing and user research prior to release – and there’s no way you would want to skip these steps – but nothing can replace the feedback you get when real people use your product, with real use cases, under real load.

If you see that you’ve been sitting on the latest version of your product for months without any of it hitting a user, or if you find yourself wanting to squeeze “just one more feature” in before you drop the release, then stop and think: can I give my users meaningful, measurable value with this release? If so, then release it. Now!

Tracking software bugs: keep the important ones; drop the rest

Posted on by will

In ancient neolithic farming communities, the size of the average tribe or village was about 150 people. That’s also about the size of most military units dating back to Roman antiquity and earlier, and it’s a number that features frequently in a variety of social antropological examples. It turns out, as Robin Dunbar popularised with his research from the early nineties, that 150 is about the number of individuals a single person can maintain a stable social relationship – that is, where you know who each of the people are, and how they relate to all the other people in the ‘network’. Malcom Gladwell talks about this extensively in his book Tipping Point.

The same is true, I think, for bugs in a software system. We have the ability to understand, process and relate to a relatively small and definitely finite backlist of bugs. I don’t know if 150 is exactly the number – and it would probably depend on the product and the type of bugs – but I think it’s close enough.

Many software projects have the tendency to track hundreds or even thousands of defects in long, long lists, maintained and even driven by complicated tools. Having so many bugs open makes it very difficult to see what’s truly important. With 800 bugs in the system, answering the question “what’s important today?” is hard.

You also need to deal with the fact that a large portion of these bugs won’t ever get fixed. They just won’t. Not because we don’t want to – at least not exclusively – but because a team can only fix so many bugs at a time. With such a large bug backlog the world around you changes quicker than you can fix all the defects, so many of them will end up being invalid or no longer relevant long before they could have been actually fixed. So was it worth tracking them in the first place?

Software development blogger Gojko Adzic thinks we should do away with bug tracking completely. I don’t think I would go so far: I think recording bugs in some kind of tool is necessary to see the major open problems with the software, allow scheduling of fixes and provides an important communication channel especially with offsite or offshore teams. I don’t think, however, that it is valuable or efficient to record every one of 1001 defects that were ever discovered.

Just like the stone-age farming villages, I think a team has the ability to deal with about 150 open defects at a time. Any more is just noise, and is probably going to cost (read: waste) you a lot of time in adminstration and error management that you won’t get a meaningful return on. What if you kept a record of the top 150 defects, and just dropped the rest? Just don’t record them?

The natural question to ask at this point is rightly “what are the top defects?”. The word ‘top’ is all about priority, and priority is a very context sensitive thing. Priority is relative to the vision of the product, the maturity of the software, the type of users and other product related factors; but priority is also relative to the priority of the other defects in the system. If your payment system is dropping payments or sending cash to the wrong accounts, then that layout issue on the invoice page is not going to be so important. But if the payments are processed perfectly and the layout problem is the only blemish, then it’s ‘top’ priority, relative to the other open issues.

Here’s a proposal: Define a minimum bar for defects; one that keeps your bug count at about 150. As the highest priority items are cleared up, then the priority of the next ones increases relatively – so you raise the bar in terms of which defects can be added. If your bug list grows over 150 (hopefully it doesn’t!) then drop the bar to stop recording stuff that you don’t have time or headspace to care about.

If you don’t care about it, then just drop it. If part of you cares but you have a hundred other more important things, then drop it too. Spending effort and time recording stuff that you’re team is not able to deal with just creates noise, consumes effort and makes it hard to see what’s important.

Darwin and the theory of software evolution

Posted on by will
Bower bird

Female bower birds prefer males with colourful blue tail feathers and an impressive nest filled with lots of blue ornaments. To a bower bird, the brightness and quality of your tail, as well as your ability to gather a stunning assortment of blue nest decorations, indicates how healthy and strong you are, and how likely your genes are to produce equally strong and healthy offspring. In other words, a bigger tail and a cooler house equals more sex, which equals more children. Your genes live on.

Generation after generation the strongest genes survive, the weakest ones are killed off, and the species evolves – better and better. It’s survival of the fittest. Or, perhaps even more apt, survival of the most effective.

Good software product development tends to emulate Darwin’s evolution. Software is built, released, used and measured. The successful features, the heavily used features, the most often talked about features receive more development, more design, more attention; the least used are left alone, watered down or removed entirely. Survival of the most effective.

On the web we have the powerful ability to accelerate the evolution. We can release software updates multiple times per day. Design – code – release – measure – rinse. Repeat. Techniques such as A/B testing accelerate it even more: which is more effective? Text link or graphical link? Blue feathers or green feathers? Big nest or bigger nest? Survival of the most effective.

For the male bower bird, just as for software products, the audience (user) is critical. Every decision the bower bird makes will be judged by the female. It doesn’t matter if the nest is made of wire instead of twigs, or if the bower produced a new nest creation framework. The female bower doesn’t care; that’s not what she makes her decision based on.

Is your product evolving? Who is your audience, and who are you making your product decisions for? Are they the same?

Be like water

Posted on by will
Flowing water

I remember reading about a concept from Taoism called Wei Wu Wei. Roughly translated it means “action without action”, or “effortless action”. In the same way that running water naturally and effortlessly flows around obstacles, so should our actions be thoughtful and mindful, but effortless.

Bruce Lee, when describing his martial art Jeet Kune Do, said:

“Be like water making its way through cracks. Do not be assertive, but adjust to the object, and you shall find a way round or through it. If nothing within you stays rigid, outward things will disclose themselves.”

Software development process is like this: like water. The path from concept to released software is a flowing stream, and as product creators it is our responsibility to ensure that it can flow easily and effortlessly.

Your product development process can either help the stream flow, or it can create dams. A broken development server, for example, is a dam. A bureaucratic and document-heavy change management process is a dam. Dams create tension and confusion. Dams create waste.

Focus on avoiding wasteful process. Tear down dams.

Be like water.