If I had a penny for everytime I hear someone tell me that they'll wait for version 3.0 of any Microsoft software that we release before using it, ... (you know the rest).
That said, let me try to explain why software is perceived to be useful or good after version 3.0. (This is my personal take, so until someone provides me with scientific proof otherwise, I'll stick with this).
First off, we all agree and we all understand, that there is no such thing as a perfect piece of software. (Don't give me that "Hello, World" app crap). Useful or good software is far from perfect, both in terms of features and stability. A properly written, thoroughly tested program can still yield bugs. Let's say for conversation sake, that you did actually build a piece of software that has NO / ZERO bugs (a practical impossibility), users have different needs and wants. Some might want this feature, others do not. So, nobody can build perfect software.
You can summarize it into 3 distinct stages I call Ship, Fix and Mature. This is essentially the first three stages in the life of a new piece of software. Let me explain what I mean.
So let's say you did build a piece of software intended for use by the broad consumer, and your software is complete and tested to your best ability. Bug and feature triage consumes the team who has to rush to ship the product on time. You release it to the world to a large number of eager customers.
Version 1.0 - Ship
Now your software is being used by many people in different environments and needs, some users will encounter issues, that comes in the form of bugs ("wytf isn't this confounded software working") and feature requests ("why can't it do this? or do that?"). You and your team rushes to prioritize fixes/bugs and to ensure those get fixed first leaving the feature requests to a later "version".
You release patches to fix critical issues and start working on the request features. Once complete, you release it as ...
Version 2.0 - Fix
Customers download it, buy it, copy it and play with it. Feeling is better, software works as it should and some feature requests have been added.
Up to this point, apart from the first release, there isn't any new innovation. Just compliance.
With all the big issues in control and customers appeased, the team sits back and learns from the experience and starts to brainstorm on features that never occured because they haven't learned how their software affects customers, works in a myriad of environments and changing needs. This is also a time where really cool features are thought about and old features revived.
Team comes out with a set of amazing features to improve the software. Implements it and releases
Version 3.0 - Mature.
Customers find new features fantastic, useful additions, make tasks more productive, easier to use etc. Customers are indeed impressed at this point. (it won't be at least another cycle of 3 versions before the Good Enough mentality steps in).
Most popular case in point, Windows.
- Windows 1.0 was built as a first foray into the GUI world. Severely limited number of features, had bugs and didn't work as plan.
- Windows 2.0, was basically Windows 1.0 made right. Still unusable. If you're like me, I stayed in DOS at this time.
- Windows 3.0 / 3.11. This was basically the version that told the world, that GUI on the PC works. Start learning how to use the mouse.
Another case, .NET Framework.
- .NET Framework 1.0 was necessary but bug ridden. It proved a point that managed code was the way to go.
- .NET Framework 1.1 fixed many issues esp. with regards to security and performance
- .NET Framework 2.0 was a godsend.
Another, Biztalk Server.
- Biztalk Server 2000, proof of concept. Great technology. Unscalable.
- Biztalk Server 2002, delivered customer features, simpler management, still difficult to create orchestration
- Biztalk Server 2004. Fantastic release with integration into Visual Studio and .NET.
Even applies to hardware,
- Ipod 1G (interesting), 2G (this thing works) 3G (Bam! now with USB)
- Ipod Mini (cool)- Shuffle (yeah cool) - Nano (wow)
I'm sure you can find a lot more cases out there that has a similar growing pain. Nowadays, developers change their versioning to ensure that when they release their software as version 1.0, it would have matured, through the use of CTP / Alpha builds, Beta and Release Candidates (RC), or variants of that same concept. They've also changed how software is built by building small and constantly fixing and adding new features in bite sized chunks. It always makes for a mature and very stable product.
My advice to tech companies, be persistent. Don't give up until you've tried it 3 times.