Agile Best Practice: Start with the Empty

A co-worker on an agile project was showing me a feature he was perfecting, and it was looking pretty good with features to add and remove various settings as per the design.   I wanted to try it.  He said “sorry, the create function is not implemented yet.”   It got me thinking….

Start any development project with the function to create an empty record.

Nothing symbolizes Agile development better than that advice.  We all understand the “minimum viable product” which is the first version that you would ask a user to use.  Agile development within the team works on an even finer scale.   Ideally, the developer creates the smallest increment in functionality, makes it work, tests it, gets it to customer release quality, and pushes it to all the others on the team.

So ideally, every button you add, you add that one button, you make that button work, you test it, and you push it to the rest of the team before adding another button.  What you try to avoid, is creating a whole bunch of things at once.  Don’t create all the button controls at once, and then make them all work.  What you do create, should be finished to the point of actually being able to use it.

In the conversation in question above, the developer had added some records to the database manually: database hacking.  This is not evil in itself, but worth thinking about from an agile perspective.  In this case the project will need a button to create this structure.  The simplest case is creating an empty record, or whatever the absolutely minimal record is.  It may not sound very interesting to have a button that creates an empty record, but you are going to need it anyway.  And you are going to need a test for the create empty record case.  Once finished, tested, and pushed to the rest of the team, they too can create empty records.  You can’t use anything else until you have the create button, so from he point of view of getting to “release quality” nothing can be tested until you can create an empty record.

So a button to create an empty record is the logical starting point, but there is more to this idea:  you should not spend time creating more functionality until you have completed and checked this in.  With Agile, you want to avoid large check-ins of any kind.  Always do exactly one step at a time.  Implement the smallest increment you can, and check it in.  Implement the next increment, and check it in.  Don’t wait and implement a lot of things.  Lots of uncompleted things is technical debt.  Most importantly, don’t spend time perfecting advanced functionality, when the basic required function is not there yet.

But really?  Every button?  My practical guideline is to check in once a day.  Pick an increment in functionality that you can start and finish in one day.  Maybe that is actually an entire screen with five buttons.  Get it running.  Test it.  Make sure it is implemented to customer release quality.  And check it in.  Every day.

You may think that your small increment is useless to the others, and it sort of is, but we do it to force ourselves to keep the quality high, and to eliminate technical debt.  While the create empty record button may not seem that useful — no matter how small the increment — it is not technical debt as long as it works and represent a real function that the final end user will actually need.

Start any development project with the function to create an empty record.  Develop, test, and commit that to the project, before doing anything else.

Advertisements
This entry was posted in Agile, Software and tagged , , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s