Why Do Defects Occur and What Can We Do About Them?
We all say that we must ‘learn from our mistakes’ but how can we do this? One way, in the realm of software development, is software defect categorization. For many dev teams, after days and weeks of working on a game-changing feature/update, just when you’re about to deploy to the product stage, you discover a huge defect in the software. As software testers, we want to find the defects, but for the organization, the most important thing is what caused the defects in the first place?
To better understand root causes of defects from different perspectives, we interviewed several software engineers and product managers. With a deeper understanding of where they come from, our hope is that dev teams can take appropriate preventive and corrective actions to minimize the occurrence of these defects. From our research, the most common reason for software problems were:
Does this tree swing meme seem familiar to you? Yes, miscommunication, lack of communication, or erroneous communication are major factors contributing to defects in software development. The product managers may have an idea of what the product/feature should look like and how it should behave, but if not communicated properly to the developers and the QA, the end product might not be as expected. Therefore, a robust communications system between all involved stakeholders is essential in reducing software defects during development. For example, having tools to enhance the collaboration experience, frequent status updates, and keeping a centralized documentation with all the product specs are good practices.
- Inadequate and incomplete requirements
Many times, critical requirements are discovered late in the software development cycle, which translates into unexpected behaviors from the end users. While miscommunication can play a big part in this, more often than not, other factors contribute. For example, on some projects where there’s no single product owner to coordinate across multiple teams, important information can slip through the cracks. On top of establishing good communication practices, assigning a lead to hold him/her accountable for the entire project can be an effective way to minimize the risk of having incomplete requirements.
- Programming errors in the implementation phase
Human beings are not perfect, we are prone to make mistakes. Hence, there are always some level of defects in the source code. However, in many organizations, developers are encouraged to “hurry up” to meet tight schedules, overlooking good coding practices in the process. Additionally, it is tough to maintain and modify code that is badly written or poorly documented. In this case, having proper “tools” to catch code defects pre-production will better ensure quality product.
- Deadlines and prioritizations
Properly estimating development schedules can be a challenge. This often manifests itself in software development with tight schedules and unreasonable deadlines. Many times, developers choose to compromise software quality in order to meet delivery deadlines. In this case, even with proper “tools”, it’s not enough to catch those code defects. In this case, a QA team can help determine prioritization and communicate swiftly to the development team what major bugs need proper attention so they are resolved in a timely manner.
- Software complexity and technology evolution
As technologies evolve, software gets updated, new features are added, new APIs incorporated, or new programming languages utilized. Just take iOS as an example. As soon as Apple releases a new version, it may introduce unexpected behavior to your existing features. This also happens if you heavily rely on third-party libraries/APIs that could change unexpectedly. In many cases, defects arise out of different versions from 3rd parties not being totally compatible. Thus, integration testing with end-to-end scenarios thoroughly covered is required to maintain a quality user experience. Troubleshooting software problems and being aware of technology updates, will help you better understand the root cause and identify a solution.
In this blog, we’ve described from our perspective, the top 5 reasons that software engineers and product managers encounter defects in their day to day work. Categorizing reasons for software defects provides management with important information. Knowing where and why defects are occurring allows for knowledge based decisions to address shortfalls in processes, practices, and people. Delivering a successful product and achieving great software quality is not only about the code quality, or only about the testing coverage, but also about good communication, firming up incomplete requirements, avoiding unreasonable deadlines and inadequate prioritization. Developing and delivering quality software takes a team effort, with all the stakeholders: the PM, the SD and the QA, working together in order to deliver a successful product.