Alternative bug classification

Any tester in his life is faced with a darkness of bugs. Sometimes there are so many of them that I want to at least somehow group them and highlight some rules for finding them, and this requires classification. Russian-language resources suggest classifying bugs by their severity, priority , size, location and frequency of occurrence.

Turning over the materials on the classifications of bugs, it seems that the optimal list is in this classification (below my amateur translation) by type:

• Comment - inadequate / incorrect comment in the code;
• Compilation error - incorrect interpretation of the wording or validation in the code;
• Data error - incorrect organization / updating of data;
• Database error - an error in the database schema / design;
• Missing design - design undocumented solutions that, because of this, do not meet the requirements;
• Inappropriate design - missing clarifications, inaccurate or incomplete description of the design;
• The wrong design is the wrong, sloppy design;
• Incomprehensible design - design solutions incomprehensible to the user / reviewer. Use of ambiguous words;
• Missed boundary conditions - boundary conditions are incorrect / not set;
• Interface errors - internal / external error that is displayed in the interface, incorrect parameters, alignment, position of objects or windows;
• Logical errors - missing, insufficient, inappropriate, ambiguous functionality of the source code;
• Message error - missing or incorrect error message in the source code;
• Navigation error - navigation incorrectly written in the code;
• Performance error - refers to code performance / optimality;
• Missing requirements - explicit / implicit requirements are missing or not documented;
• Inadequate requirements - requirements that need to be improved;
• Wrong requirements - the description of the requirements is incorrect or incomplete;
• Ambiguous requirements - requirements incomprehensible to the reviewer (includes ambiguous words - as, by type, perhaps it can be, etc .;
• Sequence or time error - an error that occurs when an incorrect sequence in the code or incorrect / missed timeouts;
• Standards - non-compliance with standards, requirements;
• System errors - errors of the OS, hardware, lack of memory;
• Errors of test plans, test cases - incorrect, ambiguous, insufficient, duplicate, unfinished test cases and scripts;
• Typographical errors - grammatical, syntactic and other errors in the documentation and code;
• Variable declaration errors - incorrect declaration or use of variables, code mismatch.

But, from my point of view, even this large classification can be grouped and simplified a little. There is also a controversial point: a code mistake is considered a logical error, although there are some errors in software products that make user journey an illogical process. That is, the logic of the product itself is not generally considered as a source of bugs.

In general, I propose to consider bugs in my own alternative classification into groups:

1. Logical - errors that violate the logic of using the functional. These can be code errors, errors in the logic of using the application, and violations of the logical display of data, and functional descriptions;
2. Technical - all errors in code, architecture, etc .;
3. Combined - errors that include several groups;
4. Localized - errors that depend on the environment (for example, from the browser or OS);
5. Design - everything related to UI, usability;
6. Relationships - violation of the relationships between elements, back-end and front-end (these may be mapping errors on sites, incorrectly configured keys in databases, object mismatch;
7. Documentation - errors of any documents.

Thus, combining this classification with the above classification by type, we get the following scheme:



I will be glad to listen to all considerations, comments and criticism on this material in order to bring the classification to mind. In the subsequent materials I can dwell on each group separately with examples.

Thank you for attention!