CSS 162 Spring 2009 Grading Rubric
The following grading scheme will be used in evaluating your programs:
- 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
- If your program compiles, but is not a serious attempt at a
solution to the assignment (like "Hello, world!"), it will receive
- If your program compiles, is a serious attempt to solve the
problem, but passes no test cases, it may receive a token number
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
- 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.
- 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
- 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.