Archive for the ‘General Business’ Category

h1

Prototyping and Minimal Viable Product

June 9, 2010

Historically, the software industry has been plagued by spectacular failures: massive enterprise developments which fail to meet even the most basic requirements; applications whose feature sets are over-complex and confusing; web portals promising the earth but delivering very little – the list goes on and on.  Countless budgets have been swallowed in the pursuit of the ‘next big thing’, the ‘killer app’ which will change everything.

It’s a tough industry at the best of times, but sometimes we make it tougher by simply aiming to do too much.  We put our heads together around our funky meeting tables and let rip, resulting in huge, complex lists of possible features and requirements.

The sad truth is, though, that we’re not always that great at getting the basics right.  In fact, scrub that, we don’t even know what the basics are.  Why?  Because in our rush to please, we forgot to really work with our users to identify what they really need.  We thought we knew best, and acted accordingly.

Wrong.

In the world of the micro ISV, there’s a strong trend toward keeping things simple and offering limited feature sets which work and serve the majority of users, rather than extended ones which aim to please everyone.  We call this ‘minimal viable product’ (MVP) and in essence it’s all about getting to market quickly at a minimal cost and maximum return on that cost.  It’s typically geared toward getting the first version of a product out there to effectively ‘test’ a marketplace.  And it works.  Rather than commit huge budgets toward building every little feature, a company can save time and money and concentrate on fine-tuning a product and its positioning within a specific market.

So, how does this fit into the software prototyping ecosystem?

That’s an easy one.  MVP is as viable an approach to test the acceptance and suitabililty of a prototyped solution design within an organisation as it is to a commercial product out in the big bad world.  The same rules apply; designers can focus their efforts on creating smaller, simpler prototypes to stimulate discussion with end users.  ‘Edge-case’ functionality is conveniently out of scope, and everyone turns their attention to the core, minimum feature set.  When this happens, we spend much more time really working out how those core features should work.  We quickly identify those features that users need the most.  Need, not want.

In conventional MVP, there is an emphasis on measuring what users do when they use a system.  The real power of MVP is collecting and interpreting this data and feeding it back into the refinement of the system’s design.  Sound familiar?  Of course – it’s simply an ‘in-the-field’ version of what we use software prototypes for: gathering contextual information about what works and what doesn’t before committing to particular aspects of a design.

MVP is, in a way, both a compliment and an alternative to conventional software prototyping – both have their uses and there’s a strong argument to think of MVP as simply ‘live prototyping’.  Either approach can deliver real benefits by saving time and avoiding unnecessary design of flawed or non-viable features.

h1

Who’s gonna do it?

May 18, 2010

Creating great software isn’t easy.  There are loads of hurdles to overcome, and the risk of failure is real.  As I’ve written on many occasions, the best way to succeed is to minimise the risk of failure.  Sounds a bit obvious, doesn’t it?  You’d think so, wouldn’t you?

The problem is that too few people really put in enough effort up-front, which results in significantly higher risks further down the line.  Take, for example, the developer who dives into code before really understanding the requirements.  Perhaps those requirements aren’t immediately obvious.  Maybe there’s disagreement over what needs to be done.  Nevertheless, our intrepid developer wants to “make a start“.  Bad move.

Just like building a house, we need to have some baseline guidelines about what we’re going to do.  A builder won’t start work before he knows what kind of a house he has to build.  A four storey mansion requires a totally different approach to planning compared to a bungalow.  Yet, in software, we’re frequently at the beck and call of clueless management who pressurise developers into starting work without even draft requirements.

You’d think that in this day and age this would be the exception, but you’d be wrong.  I was recently involved in the development phase of a large and complex financial data collection system, whose delivery date was decided before anyone had any concept of the scope or what would be involved.  Worse, the necessarily unrealistic schedule depended upon having workable specs available in good time.  Guess what?  The development was almost complete before the merest hint of requirements documentation materialised.  And it was, basically useless when it did arrive, being as it was incomplete, full of errors and false assumptions.  Remember, kids, bad requirements can be as damaging as no requirements at all

Despite this, we’d had to press on because the management – or should I say lack of management – had clearly no interest in letting its responsibility to manage the project get in the way of those juicy meetings.  Mmmmm… donuts!  So, not only had we useless requirements delivered way too late, we had absentee management of the very worst kind.

Ultimately, today’s article isn’t really meant to be a gripe.  After all, anyone who has been in this game for any length of time will have similar tales to tell.  What I did want to stress was that we, as the hopefully ‘enlightened’ techies, invariably have no choice but to take on the responsibility of pushing through requirements and kicking back against incompetent management.

If we don’t do it, we can’t really expect anyone else to do it.  Sure, it’s nice when it happens as it ought to, but don’t count on it…

[If you don’t already use one, it’s a good time to think about subscribing to this blog using our RSS feed and a suitable reader]

h1

Pick your battles…

March 24, 2010

Designing software is a bit like fighting a war.  There are battles on many fronts, and as the ‘general’ of your army, it’s important to direct your ‘troops’ where they will have the greatest impact, without leaving a gaping hole in your defences through which the enemy can pass.

In software design, the threats are plentiful: bad management decisions, poorly defined requirements, bad technology choices, scope creep, regulatory change, personnel change, budget cuts, overpromising sales people, lack of time, lack of skill and so on…

As the ‘general’ you know that you cannoy possibly fight every threat all at the same time – you’d end up with many ‘overs’ – over-stretched, over-stressed and over-whelmed!

What’s important is to pick your battles – look for the areas in which small changes can deflect immediate threats.  Look for the ‘low hanging fruit’ – in other words, the things that you can influence now.

If your project doesn’t have clear requirements, work with the business to get some.  If your timescales appear unrealistic, take a step back and re-scope.  If your sales people over-promise, take the time to educate them as to what is and what isn’t achievable.

There will always be battles that you cannot really win – the much wider-ranging changes, such as changing regulation, competitors, the economy – and you need to accept that you can only roll with the punches, come what may.

By picking the battles that you can win, your development project will be better prepared to endure and possibly better placed to actually turn these threats into opportunities.

h1

Reduce Wasted Effort…

February 20, 2010

Far too many software development projects fail to meet deadlines and run over budget.  You’ve possibly seen this first-hand.  In fact, I’d be surprised if anyone working in this industry hadn’t personally experienced at least one development that ended up taking a lot longer and costing a lot more than originally intended.

Watch for ice

Part of the problem is that designs and specifications are commonly put together in a short phase right at the beginning of a project.  Some effort is put into trying to specify the requirements and translate them into a workable design in one swoop.

This is a noble but flawed thing to do.  It almost always fails – and here’s why:

Things change…

things change

Projects can run for weeks, months or even years.  However, such projects don’t exist in vacuums.  They are part of a wider world of business, in which change is an ever-present reality.

By expecting to be able to specify a design up-front, and stick to it right through a development project, we set ourselves up for failure.  Even supposing everything went well, and we missed nothing out from our requirements analysis, the fact is that the world will be a different place in the weeks, months or years it takes to translate those requirements and that design into an actual product or service.

What’s more, if we expect to get our requirements right and then build a single design to turn those requirements into something worthwhile, we’re placing all of our eggs in one very big and rather flimsy basket.  We’re assuming that those requirements are correct, and that they won’t change.  But, inevitably, the requirements will be written by someone who’d rather be out playing golf, and the very busy business stakeholder is really rather too busy to read that requirements specification.  Probably a business analyst is trying to come up with a workable design without having any technical know-how, and in any case they’ve missed a huge chunk out because they didn’t really know how the new widget was going to fit into the existing system.  So, they hide their misunderstanding in a veil of abstract and obtuse language, which is easy to misinterpret and difficult to follow.

To compound all of this, the rather unreliable requirements documentation is then revered as ‘correct’, and management will apply pressure for Real Work to begin.  Which means cracking on with the build phase before anyone has engaged with the end-users to see if the proposed design is going to be up to the job.  Which it probably won’t be.

Fast forward a few weeks or months, and the false assumptions, omissions, bad decisions and flaky designs have become so entangled in the actual fabric of what is being built, that disappointment and failure is a certainty.  As the developers start to question the designs and requirements, it suddenly dawns on everyone that something is not right but nobody knows how to turn this baby around.

Superbaby bib
Effective requirements definition is not a one-shot deal.  It must be treated as an ongoing process, which needs to be shaped by constant feedback from all the right people.  Requirements prototyping, using software prototypes, feedback sessions and constant adjustment, is the answer to ensuring that requirements are up to the job.

By spending a bit more time at all stages, adjusting the design and the requirements to cope with new knowledge and user feedback, we can ensure that there is a much higher likelihood of delivering a quality system which actually does what it needs to do, rather than what was originally proscribed so many months previously.  Expensive development effort is minimised because the design and requirements are clear and unambiguous.

At the end of the day, any additional cost of using requirements prototyping is more than offset by the significant savings by reducing wasted effort.

Try it – you might surprise yourself by how much better your project runs!

h1

Save money: invest in a big display

February 18, 2010

Today’s article is a bit of a diversion, but it’s something that I see time and again which unquestionably hurts the productivity of anyone who uses a computer professionally.

Many companies wax lyrical about the need to operate more effectively and do a lot of pondering on matters of productivity and efficiency.  They sometimes pay top dollar to external consultants who come in and analyse this, measure that and recommend changes to processes, systems and so forth.

All of this can be really worthwhile but in my opinion the benefits gained on an organisational level are usually easily bettered by a small change for every computer user.

What am I talking about?  Display size (or, more specifically, resolution)

Big curved monitor

Far too many companies ‘go cheap’ by providing their users with small, inexpensive monitors – say, 19″ os a typical example these days.  These small monitors might well have been considered ‘luxurious’ by the standards of the Windows 3.1 days, but those days are gone now and our increased reliance on windowing systems has raised the bar and companies need to understand that they need to move with the times.

Take, for example, a small software house I spent some time at a year back.  They were doing some fairly cool things with the latest tech, and there were some really good developers working there.  However, each was hamstrung with the sort of budget display that meant that even when an application was maximised, the actual ‘workspace’ was tiny after the various toolbars and panels took their cut.

Even assuming that these budget displays were completely free to the company, their cost was far higher than that of a pair of 24″ displays would have been, or even a 30″ display.  The low resolution meant that developers were frustrated and had to keep shuffling things around to make enough space to accomplish anything.

Let’s look at the ‘mid-range’ compromise of a 24″ display.  That will provide a desktop of typically 1920×1200 resolution, as compared to a typical 19″ offering 1280×800 or similar.  In numerical terms, the 24″ display has around 2.3Mp to the 1Mp of the 19″ display.  In other words, its ‘screen real-estate’ is over twice as capacious as in the smaller display.

What this translates to is the ability to see more code, or more of that spreadsheet, or the opportunity to place two Word documents side-by-side for comparison purposes, or the option to have an email client open and visible at the same time as the web browser, and so on.

Every time a user is forced to reorganise windows on the screen to cope with limited screen real-estate, they waste valuable time and it can snap them out of ‘the zone’ of real productivity.  These context switches will, over the course of a day, a week or a month, have a cumulative negative effect on that user’s ability to perform.  Lower performance is opportunity lost; opportunity lost is money wasted.

I don’t feel the need to wheel out complicated equations or calculations to justify this stance; it should be obvious to anyone who has ever done anything on a modern computer.  However, lest I disappoint, if we assume that (over the long term) a restrictive display reduces productivity by even 5%, bear in mind that 5% of most any professional computer user’s salary buys several 24″ displays!

On top of that, a larger display gives that user a more enjoyable computing workflow experience, reduces mistakes due to excessive context switching and reduces the need to reduce font sizes so as to make it all fit.

Any company which skimps on decent displays for its employees is needlessly wasting money – and that’s a fact.

h1

Distracted by Shiny Things

January 11, 2010

This blog likes to talk about ways to improve your chances of delivering a successful software project.  One of our mantras is the use of software prototyping, but a recent conversation got me questioning whether building a software prototype might end up creating its own problems.

“Whoa!” I hear you cry.  Take a second to pick yourself up the floor; calling prototyping a liability on a site hosted at softwareprototyping.net might seem like a rather chilly day in hell.  And you’d probably be right, but I try to present the upsides and the downsides with a (relatively) impartial hat on.  Or at least that’s the plan.

So, software prototyping creating its own problems?  Surely some mistake?

Well, to answer the question: generally, no, software prototyping is usually a highly effective way of steering the early stages of a software project, therefore increasing your chances of success.

However, if we widen our brief and consider requirements prototyping – i.e. the use of prototyping techniques as a core part of the analysis and specification of a new system – we hit across a small problem.

This is illustrated best with the story of Jeff*, at the time a divisional director in a large financial organisation.

I was involved in the design of a considerably wide-scoped prototype.
Using the techniques of requirements prototyping, I was able to bring in feedback from users, stakeholders and technical analysts to help shape the design.  This was going rather well; hard work but with each revision showing real progress towards a killer design.  Along the way, however, Jeff started to sniff around in an example of classic hit-and-run micromanagement.

Despite concentrating on building up the shape of user journeys, exploring the effectiveness of our interface and so forth, Jeff really wanted us to devote our time to ‘making it look just fantastic‘.  Which, unfortunately, involved endless fiddly adjustment to such things as the precise placement of fields, the exact colour of text, whether this image looked professional enough and so on.  All very interesting, but somewhat missing the point of the prototyping process.  All this served to do was divert significant time and effort into polishing the finest details of a prototype whose main purpose lay elsewhere.

On reflection, and in Jeff’s defence, it was pretty clear that he believed in making everything look as slick and professional as possible.  He knew that the project could gain support from his superiors only if the prototype gave the illusion of completeness, and so in a way he was right to push for consistency and professionalism in the appearance.

Our failing (as a project) was in letting him do this at far too early a stage.  After all, we hadn’t decided if we were going with User Details Capture Journey A, B, C or D at that point, so polishing them all to a high gloss was always going to be overkill.

What I learned from this was that the production of any tangible output – be it a paper design or a full interactive prototype – invites attention from those who don’t understand its role, its place.  Even though they may be senior, important people, they may not be important to the project itself.

Sometimes, these people get distracted by shiny things, colours, minor details.  This isn’t a problem if they remain as observers or on the fringes of the project, but can be a serious risk if they attempt to push their way into the proceedings.  As prototyping practitioners, such people really slow down the responsiveness of the prototyping process and dilute the benefits of prototyping.  In other words, these people cause more harm than good.

The skill is recognising these people and finding a way to either educate them to the purpose of the prototype or reducing their involvement/exposure to the team.  If they really must have their fully polished, ‘slick’ design ideas visualised, then at least explain to them that it simply isn’t realistic to do this over the entire prototype.  Offer to ‘polish’ up a portion of the prototype once the fundamentals are stable.  In other words, don’t wallpaper the living room until you’ve finished building the walls…

As a final word, don’t take this article as a negative reflection on the use of software prototyping techniques – there are far more benefits than drawbacks…

* name changed to save on blushes and prospective lawsuits…

Here are some links to other articles which might be of some interest if you want to know when software prototyping is appropriate:

h1

Involve important people (part 2)

December 11, 2009

A few weeks ago, I wrote the first in a series of short articles about who needs to be involved in the software design process if it’s to have an increased chance of succeeding.  We covered involving users then, but they are only part of the overall picture.

This article looks at the stakeholders – those people who have vested interests in the success of the project. 

Pictire of a business baby

To them, they may have been given the responsibility to see a project through to delivery and beyond; they may be in charge of teams of users and therefore their own productivity and effectiveness is impacted by that of those users.  Get it wrong, and their bottom line is threatened.  Understandably, they’ll want to get involved and keep an eye on the progress of the project.

In today’s troubled financial climate, you can guarantee that stakeholders’ bosses will be keeping a close eye on things too; the decision to proceed with a new software project is often made from fairly senior levels.  Support from senior execs doesn’t grow on trees, so when you do get it, you can’t take it for granted.  They’ll expect something in return, and that price is invariably success. 

Stakeholder management is, of course, a science and an art unto itself, so I won’t cover that here, but it’s worth taking the time to scope where their individual priorities lie.  Some will be looking for a direct impact – software that enables their team to do better, say – and others will look to gains by association with a successful project.  Some may have competing priorities, or hidden agendas, and it’s certainly no bad idea to tread cautiously when involving these people.  Even if all is well, there is always a real danger of ‘too many cooks spoiling the broth’.

One project I worked on suffered from just this problem.  It was a large-scale system-integration which aimed to provide a consistent interface to a number of systems both old and new.  That in itself was fine and a challenge to relish.  However, every system within scope (and a few out of scope) came with its own set of stakeholders, many of whom would try to force their ideas upon the overall design without necessarily considering its impact to the others.  A difficult thing to manage, but software requirements prototyping helped by giving the freedom to build quick mock-ups to test ideas out and influence the stakeholders to reject the occasionally inconsistent, flawed or even wacky suggestion.

This said, stakeholders hold responsibility and accountability within the project, and they will want to be involved.  Do so, and they will provide domain and contextual knowledge which would be difficult to obtain any other way.  They will also invariably be involved in the eventual sign-off of any design, so by involving them throughout the design process, they will already have a better understanding of, and buy-in to, the eventual design.

h1

Adding magic

November 18, 2009

Picture of a magic wandDesigning interactive software systems is a fantastic opportunity not only meet the objectives of your customer, but improve the day-to-day experience of the end users.  This responsibility doesn’t come lightly; get it wrong and you run can just as easily frustrate and irritate those users, and even a mediocre system will become a hated system over time. 

What we need to do is to try to think as a user does, see a system as a user sees it and consider the bigger picture of that user’s working day.  How does this system fit in with the other things they do.  Do they want to be able to use this system concurrently with another system?  Will we need to work with a non-maximised screen layout in mind?  How much assistance in using a system is enough?  How much is too much? 

The list of considerations is seemingly endless, but by thinking about these things we achieve something very important indeed: we start seeing a system from a user’s perspective.  In other words, we start to really appreciate just how a system will fit in with the workflow of our users, in the context of their everyday tasks.  In essence, we start considering that system’s place in the ecosystem of a user’s day.

We have, then, our opportunity to add value beyond the delivery of ‘a system’.  We can deliver ‘a solution’ that integrates into workflow more effectively, and delivers real benefit through the combination of increased productivity, ease of use, interoperability with other systems and so on.

What we have is the opportunity to really improve, to ‘add magic’ to that user’s day.  Let’s not waste that opportunity by rushing our software out the door…

[why not subscribe to this blog via RSS? It’s a great way to ensure you don’t miss a single post]

h1

The power of small teams

November 16, 2009

One of the most recurring questions that crops up in software development is ‘what size of software team is optimal?’ It’s a tricky question and consensus seems as far away as ever.

Picture of figures lifting a piece of a puzzleThere is a school of thought which suggests that smaller teams are considerably more effective, per person, than larger ones. The theory goes that the overhead required to organise and manage a smaller team is proportionately lower than that of a larger team. As team numbers increase, in fact, this overhead appears to increase exponentially.

Why should this be? Well, there are a number of factors, including:

  • Communication
    The more people need to know, the greater the time spent propagating information and ideas, and the larger the risk of those ideas being misunderstood;
  • Diversity
    Generally a good thing, in an effective software team it can be difficult to ‘carry’ anyone whose skill-set and experience doesn’t closely match to the tasks in hand. Diversity is nice, but when there’s a job to do it’s better to have a few specialists than many generalists;
  • Division of tasks
    Splitting larger tasks into smaller ones makes sense but it requires careful planning and resourcing, and runs an increased risk of ‘compartmentalisation’ of knowledge;
  • Personality issues
    The greater the number of participants, the larger the likelihood of conflicts, fallings-out and so on. Also, more people mean that people have smaller individual stakes in the outcome of the project and may feel that their contributions are less valuable;
  • Environmental issues
    It is always trickier to locate a larger team together due to space constraints so larger teams may end up having to be split into two or more physical locations. This creates difficulties with communication, co-operation and dilutes the sense of ‘belonging’ that a smaller team located in one place would have.

In fact, a smaller team can be considerably more efficient than a larger team for a majority of software projects. And this is after taking into consideration the fact that a smaller team will have fewer ‘man days’ available within a fixed period. With the right people on board, a smaller team can be twice as productive per person as in a larger team, due to the considerably lower organisational overhead.

So, who are the ‘right people’?

There is a strong body of evidence to show that the very best individuals can be five or ten times as productive as even averagely competent individuals, when given the opportunity to release that productivity. This opportunity occurs only when the structure of the team permits rather than obstructs performance.

In other words, the team is small enough so that communication is direct and timely, meetings are short and only when required and management’s role is less one of fighting the bureaucracy and ‘red tape’ and more one of enablement and facilitation. The interaction between team members, playing to individuals’ strengths, promotes a synergy that is very rare in larger teams.

A smaller team, composed of talented individuals who have sizeable responsibility, enthusiasm and whose workflow is not impeded by the overhead of larger team issues, can achieve great things.

Innovation always has been driven by a person or a small team that has the luxury of thinking of a new idea and pursuing it. There are no counter examples.”
– Eric Schmidt, Google.

The power of small teams is in achieving great things with minimal waste – and in this sense our original question ‘what size of software team is optimal’ might be answered as follows:

The optimal software team size is as small as one can get away with whilst still achieving the goals.

I know this doesn’t really commit to a particular number, and of course everything is dependent on the quality of the people in the team, the scope of the work to be carried out, the environment in which that work needs to be carried out and countless other factors, but if we had to be drawn on a number, we’d say that the very best software teams are composed of less than ten individuals in total. Generally speaking, of course…

h1

Involve important people (part 1)

November 14, 2009

It’s far too easy to forget to involve the most important people in your software design: the people who will use it.

Your important users
Your users are at the front-line; you should try to involve them in the design phase, so that their needs are acknowledged and their ideas considered and perhaps incorporated into your design.

Use software prototyping to give them interactive designs they can try out for themselves and see what works for them and what doesn’t. Listen to their suggestions and preferences. Value their opinions.

They will love to be involved, as they have a personal stake in the success of your design. Do it well, it will enrich their working lives; do it poorly and they may never forgive you.