What’s the difference between ‘iterative’ and ‘incremental’ software development?
I know a lot of agile software development teams call their blocks of development time ‘iterations’ instead of ‘sprints’. Does that mean they’re doing iterative software development?
You’ve probably seen the Mona Lisa analogy by Jeff Paton that visually tries to show the difference between the two development approaches:
But which is better?
Well, if for some (very likely) reason (lack of money, changed business conditions, change in management) we had to stop after iteration/increment one or two, which approach would yield a better outcome?
Incremental development gives us a painting of half a lady whereas iterative development gives us an outline of a lady, but both paintings really wouldn’t belong in The Louvre. Perhaps we could have just painted a smaller painting?
This is where I think the Mona Lisa art analogy falls apart. A work of art, like a book, but unlike a piece of software, has a pretty clear definition of done. An artist knows when their piece of art is done: not a single stroke more, not a single stroke less.
But I’ve never worked on a piece of software that was considered done: there’s always more functionality to add/remove/fix.
If we can recognize that software is never done, all we need to do it work out how to get it to where we want it to be (for now).
“We shall not cease from exploration, and the end of all our exploring will be to arrive where we started and know the place for the first time.”~ T.S. Eliot
If we are driven by time to market we should internally iterate just enough so we can release ‘increments’ fast and often, and iterate/release again and again.
If we are driven by user experience, we should internally iterate a lot to get things right, release increments only when necessary, and iterate again.
Both approaches are about iterating. Both are also about incrementing. The difference is how soon we release after how many times we iterate.
Compare the beginnings of the two dominant mobile operating systems. Google went for time to market with Android, they released an unpolished, yet feature rich, operating system quickly and made it better by iterating/incrementing again and again over time. Apple took the opposite approach: they released iOS with highly polished features relatively slowly (it took three major iOS releases to get MMS and copy & paste!) but focused on getting things right from the start.
Both approaches are different but neither are wrong: they highlight the differences between Apple and Google and their approach to developing software.
We can’t build anything without iterating to some degree: no code is written perfectly the second that it is typed or committed. Even if it looks like a company is incrementally building their software: they’re iteratively building it inside.
We can’t release anything without incrementing to some degree: no matter how small a release is, it’s still an incremental change over the last release. Some increments are bigger because they’ve already been internally iterated upon more, some are smaller as they’re less developed and will evolve over time.
So, we develop software iteratively and release incrementally in various sizes over time.