This chapter is from the book

What Does "Done" Look Like?

After we have a specific description of what the finished software will be,
we can compare our creation with it and really know when the product is
done.

There are two types of descriptions. We can create a very complete and
detailed physical description of the actual product, or we can describe the
reaction we'd like the end user to have. In building architecture, for
example, blueprints fill the first requirement. When planning a movie or
creating a new restaurant, however, we focus our description on the feelings
we'd like our clients to experience. For software-based products, we must
necessarily use a blend of the two.

Unfortunately, most software products never have a description.
Instead, all they have is a shopping list of features. A shopping bag filled
with flour, sugar, milk, and eggs is not the same thing as a cake. It's
only a cake when all the steps of the recipe have been followed, and the result
looks, smells, and tastes substantially like the known characteristics of a
cake.

Having the proper ingredients but lacking any knowledge of cakes or how to
bake, the ersatz cook will putter endlessly in the kitchen with only
indeterminate results. If we demand that the cake be ready by 6 o'clock,
the conscientious cook will certainly bring us a platter at the appointed hour.
But will the concoction be a cake? All we know is that it is on time, but its
success will be a mystery.

In most conventional construction jobs, we know we're done because we
have a clear understanding of what a "done" job looks like. We know
that the building is completed because it looks and works just like the
blueprints say it should look and work. If the deadline for construction is June
1, the arrival of June doesn't necessarily mean that the building is done.
The relative completeness of the building can only be measured by examining the
actual building in comparison to the plans.

Without blueprints, software builders don't really have a firm grasp on
what makes the product "done," so they pick a likely date for
completion, and when that day arrives they declare it done. It is June 1;
therefore, the product is completed. "Ship it!" they say, and the
deadline becomes the sole definition of project completion.

The programmers and businesspeople are neither stupid nor foolish, so the
product won't be in complete denial of reality. It will have a robust set
of features, it will run well, and it won't crash. The product will work
reasonably well when operated by people who care deeply that it works
well. It might even have been subjected to usability testing, in which strangers
are asked to operate it under the scrutiny of usability professionals1. But,
although these precautions are only reasonable, they are insufficient to answer
the fundamental question: Will it succeed?

1Usability professionals are not interaction designers. I discuss this
difference in detail in Chapter 12, "Desperately Seeking
Usability."

Parkinson's Law

Managers know that software development follows Parkinson's Law: Work
will expand to fill the time allotted to it. If you are in the software
business, perhaps you are familiar with a corollary to Parkinson called the
Ninety-Ninety Rule, attributed to Tom Cargill of Bell Labs: "The first 90%
of the code accounts for the first 90% of the development time. The remaining
10% of the code accounts for the other 90% of the development time." This
self-deprecating rule says that when the engineers have written 90% of the code,
they still don't know where they are! Management knows full well
that the programmers won't hit their stated ship dates, regardless of what
dates it specifies. The developers work best under pressure, and management uses
the delivery date as the pressure-delivery vehicle.

In the 1980s and 1990s, Royal Farros was the vice president of development
for T/Maker, a small but influential software company. He says, "A lot of
us set deadlines that we knew were impossible, enough so to qualify for
one of those Parkinson's Law corollaries. 'The time it will take to
finish a programming project is twice as long as the time you've allotted
for it.' I had a strong belief that if you set a deadline for, say,
six months, it would take a year. So, if you had to have something in two years,
set the deadline for one year. Bonehead sandbagging, but it always
worked."

When software entrepreneur Ridgely Evers was with Intuit, working on the
creation of QuickBooks, he experienced the same problem. "The first release
of QuickBooks was supposed to be a nine-month project. We were correct in
estimating that the development period would be the same as a gestation period,
but we picked the wrong species: It took almost two-and-a-half years, the
gestation period for the elephant."

Software architect Scott McGregor points out that Gresham's
Lawthat bad currency drives out goodis also relevant here. If there
are two currencies, people will hoard the good one and try to spend the bad one.
Eventually, only the bad currency circulates. Similarly, bad schedule estimates
drive out good ones. If everybody makes bogus but rosy predictions, the one
manager giving realistic but longer estimates will appear to be a heel-dragger
and will be pressured to revise his estimates downward.

Some development projects have deadlines that are unreasonable by virtue of
their arbitrariness. Most rational managers still choose deadlines that, while
reachable, are only reachable by virtue of extreme sacrifice. Sort of like the
pilot saying, "We're gonna make Chicago on time, but only if we
jettison all our baggage!" I've seen product managers sacrifice not
only design, but testing, function, features, integration, documentation, and
reality. Most product managers that I have worked with would rather ship a
failure on time than risk going late.

The Product That Never Ships

This preference is often due to every software development manager's
deepest fear: that after having become late, the product will never ship at all.
Stories of products never shipping are not apocryphal. The project goes late,
first by one year, then two years, then is euthanized in its third year by a
vengeful upper management or board of directors. This explains the rabid
adherence to deadlines, even at the expense of a viable product.

For example, in the late 1990s, at the much-publicized start-up company
Worlds, Inc., many intelligent, capable people worked on the creation of a
virtual, online world where people's avatars could wander about and engage
other avatars in real-time conversation. The product was never fully defined or
described, and after tens of millions of investment capital was spent, the
directors mercifully pulled the plug.

In the early 1990s, another start-up company, Nomadic Computing, spent about
$15 million creating a new product for mobile businesspeople. Unfortunately, no
one at the company was quite sure what its product was. They knew their market,
and most of the program's functions, but weren't clear on their
users' goals. Like mad sculptors chipping away at a huge block of marble
hoping to discover a statue inside, the developers wrote immense quantities of
useless code that was all eventually thrown away, along with money, time,
reputations, and careers. The saddest waste, though, was the lost opportunity
for creating software that really was wanted.

Even Microsoft isn't immune from such wild goose chases. Its first
attempt at creating a database product in the late 1980s consumed many
person-years of effort before Bill Gates mercifully shut it down. Its premature
death sent a shock wave through the development community. Its successor,
Access, was a completely new effort, staffed and managed by all new people.