grades

We're thinking of introducing a grading system that will help us
identify problem areas in the compiler.   The grades will also help us
set priorities for work.

Modules are graded (typically by their authors, at least initially)
along three axes: quality, importance, and urgency.


Quality

  A  Excellent code and documentation.  Should be used as an example
     for others.  We expect to have very few `A' modules.

  B  Good work, could be improved, but acceptable indefinitely as is.
     We hope most of our modules will be `B' modules.

  C  Needs improvement.  Can function correctly or close to correctly,
     but should be refactored.

  D  Barely adequate.  Ugly code, missing or bad documentation.

  E  Broken.  Major functionality is broken or missing


Importance

  It's not obvious to me how to gauge importance, but one possibility
  is to look at the number of client modules that would be affect by a
  change. 

    Central      A major data structure or interface that affects a large
                 part of the compiler.  E.g., AST, flow graph, etc.
    
    Subsystem    Module affects a number of other modules in its
                 subsystem, but not outside.
  
    Peripheral   Few other modules are affected.


Urgency

    Immediate    Needs attention right away, because a problem is
                 preventing forward progress.

    Soon         Should be attended to soon.

    Later        Should be dealt with, but at a lower priority.