Alternative bug classification

Any tester faces in his life with the darkness of bugs. Sometimes there are so many of them that I want to somehow group them together and highlight some rules for finding them, and this requires a classification. Russian-language resources offer to classify bugs by their seriousness, priority , size, location and frequency of occurrence.

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

• Comment - inadequate / incorrect comment in the code;
• Compilation error - misinterpretation of wording or validation in code;
• Data error - wrong data organization / update;
• 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;
• Wrong design - wrong, sloppy design;
• Incomprehensible design - design solutions that are incomprehensible to the user / reviewer. The use of ambiguous words;
• Missing Boundary Conditions — Boundary conditions are incorrect / not specified;
• Interface errors - internal / external error that is displayed in the interface, incorrect parameters, alignment, position of objects or a window;
• Logical errors - missing, insufficient, inappropriate, ambiguous functionality of the source code;
• Error message - the absence 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 omitted or not documented;
• Inadequate requirements - requirements that need refinement;
• Incorrect requirements - the description of the requirements is not correct or not complete;
• Ambiguous requirements - incomprehensible to the reviewer requirements (includes ambiguous words - how, by type, perhaps, may be, etc .;
• Error sequence or time - an error that occurs when the wrong sequence in the code or wrong / 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 - grammar, syntax 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 slightly simplified. There is also a controversial point: a code error is considered a logical error, although there are some errors in software products that make a user journey an illogical process. That is, the logic of the product itself is not considered at all as a source of bugs.

In general, I propose to consider the bugs in their own alternative classification by groups:
')

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

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



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

Thank you for attention!