* Does the program compile with no warnings?
  * Is the nominal path through the code clear?
  * Does the code avoid magic numbers?
  * Does the code anticipate divide-by-zero errors?
  * Are type conversion obvious?
  * Does the program avoid overflow problems?
  * Does the code prevent rounding errors?
  * Does the code avoid comparing floating point numbers for equality?
  * Does the code avoid using variables for more than one purpose?
  * Does the code reserve a parachute of memory for cleanup and exit on emergencies?

  * Are the if/else clauses used correctly, not reversed?
  * Does the normal case follow the if rather than the else?
  * Are complicated tests encapsuled in boolean functions calls?
  * Are the most common cases tested first?

  * Have you used structures instead of single variables to manipulate groups of related data?
  * Have you considered creating a class as an alternative for using a structure?
  * Are access routines used instead of global data?, if not, why?
  * Are related access routines at the same abstraction level?

  * Are pointer operations isoleted in routines?
  * Does the code validate pointers before using them?
  * Are pointers set to null after they're freed?
  * **Does the program allocate enough memory so it can shutdown gracefully if it runs out of memory?
  * Are pointers used only as a last resort, when no other method is available?