Testing : Why are there so many software bugs?

Generally speaking, there are bugs in Software because of unclear
requirements, software complexity, programming errors, changes in
requirements, errors made in bug tracking, time pressure, poorly
documented code and/or bugs in tools used in software development. •
There are unclear software requirements because there is
miscommunication as to what the software should or shouldn't do. •
Software complexity. All of the followings contribute to the
exponential growth in software and system complexity: Windows
interfaces, client-
server and distributed applications, data communications, enormous
relational databases and the sheer size of applications. • Programming
errors occur because programmers and software engineers, like everyone
else, can make mistakes.

• As to changing requirements, in some fast-changing business
environments, continuously modified requirements are a fact of life.
Sometimes customers do not understand the effects of changes, or
understand them but request them anyway. And the changes require
redesign of the software, rescheduling of resources and some of the
work already completed have to be redone or discarded and hardware
requirements can be effected, too.
• Bug tracking can result in errors because the complexity of keeping
track of changes can result in errors, too.
• Time pressures can cause problems, because scheduling of software
projects is not easy and it often requires a lot of guesswork and when
deadlines loom and the crunch comes, mistakes will be made.
• Code documentation is tough to maintain and it is also tough to modify
code that is poorly documented. The result is bugs. Sometimes there is
no incentive for programmers and software engineers to document their
code and write clearly documented, understandable code. Sometimes
developers get kudos for quickly turning out code, or programmers and
software engineers feel they have job security if everyone can
understand the code they write, or they believe if the code was hard
to write, it should be hard to read.
• Software development tools , including visual tools, class
libraries, compilers, scripting tools, can introduce their own bugs.
Other times the tools are poorly documented, which can create
additional bugs.