Checklist: Implementation
This checklist provides questions to verify that the implementation is created in a consistent and complete manner.
Relationships
Related Elements
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 you may be able to address some items to only 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 for 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 these criteria should be done in real time so that quality is ensured up front as they are writing the code.

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 the exception occurred.

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?
  • Can you test the expected behavior at the unit level?
  • Is the code written in a way that all paths can be exercised?
Is the implementation correct?
  • Does the implementation pass all of 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 intention of the developer?
  • Does the code adhere to the Coding 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, and so forth.
  • Are the names of the variables easy to understand? Do they describe the purpose of the variable?
  • Are all of the comments necessary to be able to understand the associated code? Comments should enhance the understanding of the code rather than merely repeat 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.

OpenUP Copyright.

OpenUP/DSDM Copyright.