CSS 162 Spring 2009 Grading Rubric
The following grading scheme will be used in evaluating your programs:
Correctness: 65%
  
    - Correctness is evaluated by using a set of test cases that
    progress from simple to more complex. Each test case will have a
    certain number of points associated with it, with the total of all
    test cases equal to 65%.
- If your program does not compile, it will receive no
    points.
- If your program compiles, but is not a serious attempt at a
    solution to the assignment (like "Hello, world!"), it will receive
    no points.
- If your program compiles, is a serious attempt to solve the
    problem, but passes no test cases, it may receive a token number
    of points.
Design and Coding Standards: 25%
  Please refer to the "Design and Coding Standards" section of the
  syllabus for requirements.
  
    - Excellent (25 points)
    
- The code adheres to all standards. The code is exceptionally
      well organized and very easy to follow. Comments are complete and
      useful; variables' purposes are clearly communicated by their
      names. Classes and their methods are appropriate; only necessary
      members are public. Etcetera.
    
- Good (20 points)
    
- There may be some minor failures to adhere to standards, for
      instance, indentation may be inconsistent, some lines may be too
      long, or a few variables may have unobvious names or be
      undocumented.
    
- Acceptable (15 points)
    
- There are some moderate violations of the standards. The code
      may be difficult to read in places, or some of the method
      comments may be sketchy. However, the code is still generally
      readable and there is enough commenting, good enough variable
      names, etc. that someone could still figure out what's going on
      without too much difficulty. Classes and methods are still
      generally appropriate, though there may be some violations of
      good design here and there.
    
- Marginal (10 points)
    
- There are major problems with the program's design or coding
      style that would interfere with its reuse or maintenance. File
      or method comments may be sketchy, variable descriptions or
      names may be unenlightening. The code may be poorly
      formatted. Having said that, there is still some value apparent
      in the code, perhaps in its overall decomposition into different
      classes and methods.
    
- Poor (5 points)
    
- Comments are generally missing. The code is difficult to read
      and its design is difficult to follow. Classes may include
      mixtures of different functionalities that don't belong
      together. However, it has at least one redeeming quality that
      could allow someone familiar with what it is supposed to do to
      understand some aspect of it.
    
- Unacceptable (0 points)
    
- The code is poorly designed and organized, with few or no
      useful comments. It is very difficult to read or understand.
 
Documentation: 10%
 
   - Excellent (10 points)
   
- The documentation is well written and includes all required
     elements. It shows a thoughtful and complete analysis of the
     problem. The test report is complete and was used to good effect to
     validate program operation; it accurately matches actual program
     functionality.
   
- Marginal (5 points)
   
- Some major aspect of the documentation is missing or
     sketchy. It may be clear that it was written after the program
     was developed, rather than before. The test report may be
     inadequate, it may not have been used to test the program, or it
     may not match actual program operation to some extent.
   
- Unacceptable (0 points)
   
- The documentation was either not submitted or is largely
     lacking in substance. It may be obvious that it was hurriedly
     written just before the program was submitted. It would not be
     very useful for either understanding what the program is supposed
     to do or what it actually does.