While there is a lot of sloppy programmers out there, these are not the only ones that have trouble finishing something. Some programmers strive for perfection in the software they create, and in the process end up spending precious time.
Anything less than perfection feels like it is a waste for such programmers. It is like they cannot move from a task until all possible features have been implemented…
Even if this seems unlikely, a few people operate with a similar mindset: trying to do everything that the software possibly could is similar to strive for perfection.
A simple example of this type of attitude towards programming is designing classes that have all possible methods that a client will ever need. The list of user cases continues to grow, and gets to the point when it becomes unmanageable. Classes that have all possible responsibilities is another symptom of this disease.
Is not that perfection, or completeness, is bad. The problem is the cost of having “perfect” software.
Software is different from physical materials. While a machine can be designed to look perfect (such as the designs that Apple strives to do), requiring the same from a piece of software would add a lot of functionality that is not essential.
A theoretically perfect software would have a virtually infinite number of features capable of satisfying every need of its users — even if it is targeted to a specific area. Think of this as an example of combinatorial explosion, or fractal design: the more detail you try to put into an application, the more features it needs to have.
However, from all these features, one can only implement a few in finite time.
There is also a more insidious reason. As the number of features in your application grows, so grows the amount of code you need to implement them. This has two side effects:
- First, you can make more mistakes just because of the enormous surface area for them to appear. This is the classical case of bloat, where more and more features make it difficult to properly maintain the application.
- Second, as the code size increases, your program also becomes sluggish. Eventually, a program with a large number of features is slower and buggier than a more nimble version.
The next time you design an application, think twice about the essential features. Don’t try to make it perfect, make it functional. Your users will thank you.