Some people have a hard time accepting iterative approaches to getting work done. It may be because many of us have an innate desire to finish something — we need to be done. Yet, when we iterate over a work item, it feels like it takes longer to get to done. Here’s a simple example taken from everyday life.
Let’s say you want to clean your entire house or apartment. Cleaning one room at a time seems like a good approach. You’d get a sense of accomplishment after finishing each room. But it’s not efficient. You’d be switching among cleaning products and cleaning tools — constantly wrapping up one task and preparing for the next one. You’d also run the risk of stopping before you ever got to little used areas of your home (which is why you should start with the least used area).
A more efficient and ultimately faster approach is to break up the housecleaning task into iterations where each iteration is focused on a particular cleaning task. For example, your iterations might look like this:
- Pick up all the clutter throughout the house and put items where they belong.
- Prepare for window cleaning and wash all the windows.
- Prepare for furniture dusting and dust all the furniture items as needed.
- Vacuum every room including drapes, upholstered furniture and floors.
- Prepare for floor washing and wash any remaining solid floor surfaces.
The downside is that you won’t get that same sense of satisfaction of being completely ‘done’ with a room until later. The upside is that you’ll finish the entire job sooner. Another upside is that this approach is more readily adaptable to multiple people doing the cleaning. Once step one is completed in a room, someone else can begin step two in that room and so on. The cleaning crew won’t be competing for cleaning items as they would in the one room at a time approach.
Anyway, it’s a simple example intended to make a point. There are many jobs that can be done more efficiently and faster by iterating over the solution space.
Writers Do It
Another great example is the job of writing any lengthy document. It can be a novel, short story, article, specification or presentation. Writers have been doing it for centuries. They don’t plod through documents one section at a time. The efficient process goes something like this:
- Create an outline. Layout the major sections.
- Make a complete pass through the document filling in the quick and simple parts.
- Make another pass adding details and supporting information.
- Make a final pass filling in missing pieces.
- Lastly, check, double check and wordsmith the entire document.
Agile Developers Do It Too
For agile software development, the same rules apply. The iterative process is similar and might look like this:
- Create a structure or foundation for a code module.
- Make a complete pass to get basic functionality working.
- Make another pass to add complex functional elements.
- Make a final pass for error handling and logging.
- Lastly, check everything and integrate the module with the rest of the system.
The precise details will vary depending on your skills, style and confidence. The point is that iterating over the solution space is ultimately a superior way of getting things done. Plodding through any job trying to completely finish one area before moving to the next one is inefficient and costly. You’ll inevitably be forced to go back and adjust something you thought was done.
Embrace the feeling of being ‘done’ when completing each task — not just when the entire job is compete.