Common Quality Enumeration

This pattern identifies situations where a literal value is hard-coded in the application via the Write action, transported throughout the application along the sequence composed of ActionElements with DataRelations, some of which being part of named callable and method control elements, and ultimately used in the remote resource management action; the transport sequence is composed of assignment operations as updates to the value would not be considered as hard-coded (literal) any more.

The software contains an excessive amount of code that has been commented out.

The software allocates memory for a data element, but it does not release the associated memory at a later time.

This pattern identifies situations where the class element executes the control element to destroy itself. As an example of self-destruction control element in C++, the 'delete this' control element.

The software creates an immutable text string using string concatenation operations.

The software uses a data element that has an excessively large number of sub-elements with non-primitive data types (i.e., aggregated objects).

The software accesses a data resource without using a connection pooling capability.

This pattern identifies situations where the floating value 1 and floating value 2 of storable or member data elements of float types, are tested for equality with regular comparison operators in the comparison control element.

This pattern identifies situations where the storable element or member element is declared with the datatype in the Create action, then updated with a value that is cast via the type cast action into the second datatype, which is incompatible with the first one.

A named-callable or method control element has a signature that supports a variable number of parameters.

The software contains a serializable data element that does not have an associated serialization method.

The software uses a storable data element that does not have all of the associated control elements that are necessary to support comparison.

This pattern identifies situations where the application uses deployed component from the platform deployed component list, yet uses control elements from the list of low-level resource management API.

The software contains a serializable, storable data element, but the data element contains item elements that are not serializable.

This pattern identifies situations where the static member element is declared as static but its parent class element is not a singleton class, that is, a class element that can be used only once in the 'to' association of a Create action; it does not take into account final static fields.

The software contains a storable or member data element that is not initialized before it is used.

This pattern identifies situations where the storable data element or member data element contains the child pointer data element but has no dedicated copy operation or copy constructor element.

A named callable control element or method control element performs an action that reads, writes, or manages access to a data or platform resource, but it does not check the return parameter from the action.

The software accesses a data element but does not later invoke its associated finalize method.

This pattern identifies situations where the application uses the cryptographic deployed component while it is not part of the list of vetted cryptographic deployed components. As an example, FIPS 140-2 features a list of validated implementations.

Data Encapsulation

The software performs a data query with a large number of joins and sub-queries on a large data table.

The software contains a data query against an SQL table or view that is configured in a way that does not utilize an index and may cause sequential searches to be performed.

The software contains an index range scan for a data resource, but the scan can cover a large number of rows.

The software uses a data table that contains a large number of indices.

This pattern identifies situations where the named callable control element or method control element contains the catch unit which declares to catch the exception parameter whose datatype is part of the list of overly broad exception datatypes. With Java, an example is {'java.lang.Exception'}.

This pattern identifies situations where the named callable control element or method control element throws with the Throws action the exception parameter whose datatype is part of the list of overly broad exception datatypes. In Java, one example from this list is {'java.lang.Exception'}.

An invokable code block contains an exception handling block that is empty.

A named callable control element or method control element performs an action that reads, writes, or manages access to a data or platform resource, but it does not check the return parameter from the action.

The software contains a storable or member data element that is not initialized before it is used.

This pattern identifies situations where the named callable control element or method control element features the execution path whose entry element is found again in the path, while it has no path whatsoever to not return to itself and exit the recursion.

Recursion

This pattern identifies situations where an external value is entered into the application through the user interface ReadsUI action, transformed throughout the application along the sequence composed of ActionElements with DataRelations relations, some of which being part of named callable and method control elements, and ultimately used in the loop condition statement; none of the callable or method control element of the transformation sequence being a range check control element

The software architecture contains too many - or too few - horizontal layers.

The code at one architectural layer invokes code that resides at a deeper layer than the adjacent layer, i.e., the call skips at least one layer.

The software uses the same control element across multiple architectural layers.

This pattern identifies situations where two buffer storable elements or member elements are allocated with specific sizes in the source buffer allocation statement and target buffer allocation statement, transformed within the application via transformation sequences composed of ActionElements with DataRelations relations, some of which being part of named callable and method control elements, then ultimately used by the application to move the content of the first buffer onto the content of the second buffer through the move buffer statement, while the size of the first buffer is greater than the size of the second buffer.

This pattern identifies situations where an external value is entered into the application through the user interface ReadsUI action, transformed throughout the application along the sequence composed of ActionElements with DataRelations relations, some of which being part of named callable and method control elements, and ultimately used as an index element to access a storable or member data element in the buffer Read or Write access action; none of the callable or method control element of the transformation sequence being a range check with regards to the 'Buffer' buffer that whose maximum size was defined in the buffer creation action.

This pattern identifies situations where the named callable control element or method control element has a Fan-Out value that is too large, based on its number of references to other objects within the application which exceeds the threshold value; the application determines the scope of the search for the referenced objects. Default value for threshold value is 5.

The software contains modules with circular dependencies.

A source code file has too many lines of code.

This pattern identifies situations where the storable element or member element is declared with the numerical datatype in the Create action, then updated with a value which is cast via the type cast action into the second numerical datatype, which is incompatible with the first one.

Cache Maintenance

Resource Identification Control

Resource Lifecycle

Resource Monitoring

Inheritance and Polymorphism

The software contains a named callable or method control element that is not reachable by other code, i.e. is dead code.

The software has two or more invokable control elements that contain the same code.