How Do Bugs Come Into Our Ways?

It’s impossible to build the perfect software. What is achievable in reality is to add the more value we can in what we’re building by knowing what the reasons for the most common causes of software failures are. That way you can eradicate them from the root.

Everybody in software development talks about bugs, but have you ever thought about why bugs come into our ways? Whether we are developers, QA’s, designers, PMs or technical leaders our main aim is to provide quality in what we’re building and strive for bug-free products. That is an impossible goal.

In this blog post, I want to point out the most common reasons why we keep getting bugs in the software we build.

Before going into details I would like to clarify that all these reasons may apply to early stages of product development, not necessarily in production. They could be at design, development, testing or production.

Whatever the stage is, it is still worth knowing why bugs appear and be very vigilant to prevent bugs from happening. This, once again, is not possible to achieve 100%.

Constant Turnovers 

Human resources rotation has a big impact on the quality of any kind of project. Having constant personnel rotation leads to new joinees having to sync with everything from the very beginning, therefore making their progress slower and programming errors more likely. 

Poor Code Documentation 

Not all organizations encourage their developers to document the code and it’s tough for other developers to try to catch up. It leads to a lot of mistakes. Documenting your code saves your developers’ lives.

Requirements Change Constantly 

When customers are constantly changing requirements, it has critical consequences. From developers becoming less enthusiastic to even intentionally provoking bugs on the software. Imagine a team that is finishing building all the features required, and all of a sudden those requirements change.

If the requirements are constantly changing and we don’t keep documenting our test cases, we’re not going to perform good enough on whatever we are testing.  Also, even if the requirements don’t change at all, we’re still doing our job wrong if we aren’t documenting.

Poor test cases documentation

Test cases documentation has a big role in software development these days, especially if requirements are constantly changing or if new features keep coming up. If we don’t make proper documentation, we could lead to QA’s to perform inadequate testing on features.

We could literally leak bugs on production thinking that was the expected behavior. A bug is not only a functional error but also a misunderstanding of expected behaviors.

Misunderstanding requirements

Misunderstandings requirements between stakeholders and developer teams can cause several problems, such as defects in development and a totally different product than what was expected.

Raising any questions about requirements and specifics early on is going to prevent any nasty surprises near the end of the process, once is too late to do anything about it.

Miscommunication

Communication is the key to success in everything. Projects tend to have several team members in different units, such as stakeholders, designers, developers, QA, engineers, etc.

It is crucial to keep a very high degree of communication at and between all levels of the organization.

Complex Software

When the complexity of a software development project increases (which it is very likely to happen sooner or later), it leads to programming errors, especially when the code base is large and the people in the project are not aware of every facet of the application.

When building complex software, is recommended to document every requirement and user story in order to be able to test and cover the most important scenarios when it comes to customer value.

Third-Party Services

There will be times in which our business needs will require third-party services to provide a very specific service in the product we are building. Therefore, we make our product dependant on the stability and reliability of these third parties. 

I’ve come across several issues caused by this; from the third party, the server shut down, to the very simple action of changing the domain name and not communicating that to the people using the service. Additionally, it is important that the person in charge of acquiring the service really knows when the service will expire. Sometimes teams forget to pay the service in advance, leading to a big impact in their users and systems.

CONCLUSIONS

We should keep in mind that there is no perfect software anywhere and it is impossible to achieve that. We can, however, prevent some unexpected bad stuff from happening if we are aware of how bugs come into our ways.

Thanks for reading!

Oh, before saying goodbye, please share this on Twitter so your peers will know about How Do Bugs Come Into Our Ways: