Software defects are the major causes for increasing the software development cost and failure to meet the deadline. Usually organizations strive for the excellent quality software, but unfortunately, the results deviate sharply from the perception.
Reality about Software Defects
Defects can never be eliminated completely, but companies with the excellent development processes are able to make this 99% defect free.
Usually the defect removal rate for high quality conscious and excellent process model companies is 80-85%. Quality of the software is directly associated with the defect rate. Therefore, producing the quality software involves effectively defect management and removal procedures. The defect rate can directly affect your company, your reputation, and the revenue you generate.
Detect Early Remove easily | Software Defects
Defect identification and the removal process are generally applicable to the all phases of development but the cost of removing the defect increases as the development progresses. Generally, the defects that are identified at the early stages, i.e., requirement gathering phase, analysis and design phases are easy to remove. Defect removal at the testing phase cost more than at the analysis and design. Defects that are identified after the release cost high and also are embarrassing for the organization. Therefore, for a company to have a good reputation, must focus on the best technique of defect identification at the early stages of development.
Six Major Software Quality Defect Origins
Defect control can be effectively implemented if the proper pre-cautions are taken at the most critical phases of the development cycle. The six major causes of defect injection are described in the following section. For developing the quality software and effectively meeting the deadline, the key is to develop the less defective software. Some of the software quality defect, origins are listed that have been identified in the survey of CMMI level five, company. Depending on the working style and the development life cycle, these origins may vary but most of them will be same, as some defect origin phases are part of every development cycle.
1. Requirements Phase/ Requirement Defects
The defect injection is started at the very first phase, the requirement-gathering phase. Gathering the incomplete requirements, ambiguity in the requirements and the requirements that require more advance technology that is not affordable for a low project budget are the major causes of the requirement defects.
Types of Requirement Defects
Defects of commission
Most common, requirement defect is errors of commission; this states that something wrong is done. This is the most common in the requirement defects e.g., user manual is frequently found in the usage instructions where the command sequence in the user manual differs from what software is really performing.
Defects of Omission
Second, requirement defect is the errors of omission. This state that something left out by accident, e.g., the Y2K problem.
Defects of clarity and ambiguity
Third requirements defect is about clarity and ambiguity. This requirement defect is the result for language used for requirement. The defect is produced when the written requirements are interpreted wrong. The remedy for this is to use the other languages i.e. Z, COL etc than English.
Defects of speed and Capacity
Forth and the last requirement defect is error of speed and capacity. This is related to the performance issues found in the requirement documents. For example, call to the processing speed that exceeds the capacity of device or hardware.
2. Design phase | Software Defect injection during Design Phase
Improper project design is the cause of software defect. The design defects are injected due to improper and poor linkage to the other related and functional modules. As a result, different routines are being called than the expected ones, and this leads the application to perform the action in incorrect manner, results to failure to complete the requirement.
3. Source code | defect injection during development phase
Improper source code results to meet the expected behavior at runtime. Usually the syntax errors are removed at the application build, but improper pre-cautions taken to handle the dynamic memory results in serious application crash or application errors that degraded the user experience.
4. User manual and the training material, cause for the Software Defects
User manual is the key on which the end-user relay to perform the particular action. Poor user manual design and improper instructions given in the manual leads to the defects.
5. Bad Fixes and the poor defect repairs
Bad repairs made by the development team, to fix the identified bug inject more bugs in the software. Effective bug analysis, before fixing it helps reduces the chances of failure.
6. Defective test-cases use by the application
Failure to identify the defects at the testing phase of the life cycle, results in shipment of defective product, and these defects are usually identified by the client or the end user. The strongly written test cases overcome this situation.
Reade more about software defect cure and prevention
Six major origins for the software defect have been listed above; further how to prevent and fix the identified defects may be explored here.