Many of you have had questions about how the final project will be
graded.  Here is an "official word" summary:

* Correctness: We will test your program on 10-20 files that you have
not seen.  You will lose points for each test on which your program
does something unreasonable (crashes, produces no output, produces
garbage, etc.)  The test cases will attempt to cover a wide range of
difficulty, along the lines of the "stages" described in the handout.

Even if your program does something reasonable for all the tests, you
can still lose points for not following the specifications.  For
example, if you mishandle method declarations, then you will lose
points, but we will take off "over all" for this, rather than for each
test case that has a method in it.  (But if for example your program
crashes on a method declaration, then you will lose points twice --
once for each crash and once for mishandling a method).

Best advice: Have a program that always does something reasonable.
Then re-read the handout carefully to make sure you are following all
of the specifications.

Correctness will account for just over half of the grade.

* Big-Picture Style: We will look at your code.  Here's what we want to see:
   + Good organization of data structures.  Information nicely divided between
     classes and good comments describing where everything fits in the big 
     picture.
   + Parsing code that is readable, well-commented, well-organized, and the 
     logical result of understanding and interpreting the grammar.
   + HTML-generation code that is straightforward and based on your data 
     structures.
   + A general ability to read your code without you present and understand 
     what's going on without getting a headache.

This will account for about one fifth of the grade.

* Little-Picture Style: Similar to the style sections on your previous 
assignments.  Some things never change. :)

This will account for about one tenth of the grade.

* Efficiency: Do not tune your code to run a little bit faster.  We
don't care about that.  But we do care that you don't do things in
unreasonably inefficient ways.  The algorithms for this assignment are
very simple, so we expect their efficiency to be correspondingly
simple.  For example, if you want to print out n methods, then we
expect that your data structures and algorithms do this in time
proportional to n.  If you take time proportional to n-squared (or
worse) then you will lose some points.

In short, if you do everything reasonably, then you will get all of
the efficiency points.  We expect this to happen.  But if you keep
typing until you get something that works and don't really understand
what your algorithm is doing, then you run the risk of doing something
inefficiently.

This will account for the remaining part of the grade.

* Web pages: You will receive full credit for pages as "plain vanilla"
as the Pizza.html on the course webpage.  Projects with "really cool"
HTML generation may receive a few bonus points.  However, doing the
extra credit will give you much more grade-wise and experience-wise
than tweaking your web pages.

* Extra Credit: First of all, extra credit is extra.  Your grade will
not be hurt because someone else does the extra credit.  We have not
determined exactly how much the extra credit can affect your grade,
but it will be something reasonable.

Advice: The extra credit is a fairly straightforward extension of the
assignment.  Doing it should be rewarding, both intellectually and
otherwise.  But get the assignment in good shape (per the above)
first.  We will be fairly stingy on giving any extra credit to a
project that has problems with some of the basics.

Dan Grossman, CS211 TA