Checklist: Implementation

This checklist provides questions to verify that the implementation is created in a consistent and complete manner.

Relationships

Related Elements	Refactoring Development Implementation

Main Description

The items in this checklist represent good practices for creating a high-quality implementation. Try to address every item to the greatest extent possible to create the best implementation. It may not be possible to address every item, and some items may only be able to be addressed to a limited extent. In these cases, be sure that there are good reasons for only partially addressing an item, or not addressing an item at all.

This checklist is not something that should be considered only at heavyweight code reviews. Each developer should keep the quality criteria embodied in these check items in mind while coding. When developers work together, the review against this criteria should be done in real-time so that quality is ensured up front as the code is being written.

Appropriate divergence from the quality criteria described here could be worthy of a comment in the implementation so that developers examining the code in the future know why it was done.

Check Items

Does the implementation conform to the architecture and design?

Is the implementation structured as specified in the design?

Are all of the functions in the design implemented?

Are all of the interfaces in the design implemented according to their specifications?

Does the implementation adhere to all design and architectural constraints?

Is the implementation testable?

Is all the expected behavior able to be tested at the unit level?

Is the code written such that all paths can be exercised?

Is the implementation correct?

Does the implementation pass all the developer tests?

Does the implementation support the acceptance criteria of the test cases?

Is all code executable (no dead code areas)?

Is the implementation understandable?

Does the implementation clearly state the intent of the developer?

Does the code adhere to the Code Guidelines? If a set of Coding Guidelines has not been identified, the code should be checked for a variety of consistency issues such as naming conventions, indentation, spacing, etc.

Are the variable names easy to understand? Do they describe the purpose of the variable?

Are all the comments necessary to understand the associated code? Comments should enhance the understanding of the code rather than repeating it.

Are all comments correct?

Does the implementation match the documentation?

Is there no redundancy?

Is there no redundancy in the implementation? (identify candidates for refactoring)

This program and the accompanying materials are made available under the
Eclipse Public License v1.0 which accompanies this distribution.