- One of the things that a lot
of agile teams get tripped up
on is this idea of delivering high value working software.
Remember that the Manifesto's Principle 7 says
that working software
is the primary measure of progress.
But how's it possible
to deliver working software every few weeks?
To do that, you need to deliver small,
fully-functional features of the product
to the customer in iterations or sprints.
Let's think about developing a simple website.
We just want a web form
that captures the customer's contact information
and stores it in a database.
If you think about it,
that's a whole project,
and there are several possible milestones.
For the first milestone,
you need to create the database.
Then you might need to develop
the software that connects the form to the database.
Finally, you have to create the form
that captures the information.
You might also need extra code
to make sure that you have the correct data in the forms.
So if you're looking at the website as a project,
then you can imagine it having a lot of milestones.
But an agile team doesn't think
about software as a project.
Instead, it thinks of it as a product
that has prioritized value
that you deliver to the customer in short sprints.
So you're not trying to tackle everything at once.
Remember, we're not multitasking.
Instead, you're zeroing in
on high value features to deliver.
So you might have a simple webpage
that just captures the customer's first name
and email address.
The key thing to keep in mind
is that this form would be fully working software.
That means that if you submitted your first name
and email address,
that this simple website would check
to make sure it's right,
capture your name and address to a database,
and regularly back up the data.
Now not many customers would accept this
as a fully working product.
But they could.
That's why when you're working on an agile team,
you want to only show the customer working software.
Some teams make the mistake
of showing the customer PowerPoint presentations
or wire frames, but these are really just fictions,
they're not working software the customer can use.
Ideally, at the end of every sprint,
the customer could put the software
into production and end the development.
They shouldn't have to wait
for deployment, testing,
or other ways to finalize the product.
The team should always be building working software.
Now there's a lot of reasons why agile teams do this.
But one of the most important
is that these teams find that working software
is the best way to communicate progress.
It keeps the customer from asking questions
like, when can we ship this?
Every time they see the software,
it's potentially shippable.
Another reason is that it reinforces
the agile team's commitment to work
on the highest value features.
It means that the features
that will be used the most will be the first ones
that are finished.