1. Is the intent of all units or processes documented?
2. Is the unit design, including the data flow, control flow, and interfaces, clearly represented?
3. Has the overall function of the unit been described?
1. Have the specifications for all units in the program set been provided?
2. Have all the acceptance criteria been described?
3. Have the algorithms (e.g., in PDL) used to implement this unit been specified?
4. Have all the calls made by this unit been listed?
5. Has the history of inherited designs been documented along with known risks?
1. Does the documentation follow project and/or JPL standards?
2. Has the unit design been created using the required methodology and tools?
1. Are data elements named and used consistently throughout the unit and unit interfaces?
2. Are the designs of all interfaces consistent with each other and with the SIS-2 and SSD-1?
3. Does the detailed design, together with the architectural design, fully describe the "as-built" system?
1. Is there logic missing?
2. Are literals used where a constant data name should be used?
3. Are all conditions handled (greater-than, equal-to, less-than-zero, switch/case)?
4. Are branches correctly stated (the logic is not reversed)?
1. Are all the declared data blocks actually used?
2. Have all the data structures local to the unit been specified?
3. Do all routines that modify data (or files) shared with other routines access that shared data (or files) according to a correct data sharing protocol (e.g., mutual exclusion via semaphores)?
4. Are all logical units, event flags, and synchronization flags defined and initialized?
5. Are all variables, pointers, and constants defined and initialized?
1. Does this design implement the specified algorithm?
2. Will this design fulfill its specified requirement and purpose?
1. Do argument lists match in number, type, and order?
2. Are all inputs and outputs properly defined and checked?
3. Has the order of passed parameters been clearly described?
4. Has the mechanism for passing parameters been identified?
5. Are constants and variables passed across an interface treated as such in the unit's design (e.g., a constant should not be altered within a subroutine)?
6. Have all the parameters and control flags passed to and returned by the unit been described?
7. Have the parameters been specified in terms of unit of measure, range of values, accuracy, and precision?
8. Is the shared data areas mapped consistently by all routines that access them?
1. Is the expansion ratio of code to design documentation less than 10:1?
2. Are all required module attributes defined?
3. Has sufficient detail been included to develop and maintain the code?
1. Does this unit have high internal cohesion and low external coupling (i.e., changes to this unit do not have any unforeseen effects within the unit and have minimal effect on other units)?
2. Has the complexity of this design been minimized?
3. Does the header meet project standards (e.g., purpose, author, environment, nonstandard features used, development history, input and output parameters, files used, data structures used, units invoking this one, units invoked by
this one, and explanatory notes)?
4. Does the unit exhibit clarity, readability, and modifiability to meet maintenance requirements?
1. Do processes have time windows?
2. Have all the constraints, such as processing time and size, for this unit been specified?
1. Are default values used for initialization and are they correct?
2. Are boundary checks performed on memory accesses (i.e., arrays, data structures, pointers, etc.) to insure that only the intended memory locations are being altered?
3. Is error checking on inputs, outputs, interfaces, and results performed?
4. Are meaningful messages issued for all error conditions?
5. Do return codes for particular situations match the global definition of the return code as documented?
6. Are undesired events considered?
1. Can each unit be tested, demonstrated, analyzed, or inspected to show that they satisfy requirements?
2. Does the design contain checkpoints to aid in testing (e.g., conditionally compiled code, data assertion tests)?
3. Can all logic be tested?
4. Have test drivers, test data sets, and test results for this unit been described?
1. Are all parts of the design traced back to the requirements?
2. Can all design decisions be traced back to trade studies?
3. Have all the detailed requirements for each unit been specified?
4. Have the unit requirements been traced to the Software Specification Document (SSD-1)? Have the SSD-1 specifications been traced to the unit requirements?
5. Has a reference to the code or the code itself been included?