First of all, a quick note about the grading of assignment 4. Due to a bug
in the grading script, the functionality scores were reported as "N out of
50" when in fact the score is out of 40. I corrected this on most of the
assignments I graded, but I may have missed a few. Don't worry- whether
your grader made that correction or not, your final score should not be
affected, and will be calculated as though the functionality score were
out of 40.

A few more general thoughts about assignment 4:

The transition to Java seems to have led to a resurgence in lines of more
than 80 characters. I'm not sure why- the 80-character restriction is
still in full effect, and if anything, Java is easier than Rex to fit
within that restriction. If you're still losing points for this, please
get it taken care of- there's no sense losing a point or two for something
so trivial.

One useful technique: if you have a println() statement which is going to
exceed the line limit, split it into one or more print() statements (which
do not put an end-of-line at the end), followed by a println() statement.

The scores on this assignment seem to be lower than past assignments. I
hope this is just a consequence of the transition to a new language. One
problem that a lot of people had was that one or more of their classes did
not compile. Please, if at all possible, make sure your code
compiles. Even if it doesn't work, compilation gets you one point, and if
your code is even partway there, you may pass a few of the simple
tests. However, if your code does not compile, it is impossible for you to
get any points at all for that portion of the assignment. Compile errors
are comparatively easy to track down, so please try to get your work that
far, if no farther.

I've gotten a number of questions about typecasting, so here's a quick
rundown of the idea of typecasting: Typecasting does not actually change
what an object is. If an object is created as a DCell, it is and will
always be fundamentally a DCell. It may temporarily behave as a QCell or
an Object, but it can always go back to being a DCell. The problem is
that it is not always straightforward to make these changes.

Transitions "up" the inheritance tree are automatic. A DCell actually is a
kind of QCell (and, in turn, a kind of Object). Consequently, anywhere the
language accepts a QCell, it will automatically accept a DCell. This does
not require any typecasting, because a DCell can _always_ be treated as a
QCell.

The problem comes when you try to go the other way- back down the
inheritance tree. Once a DCell has been converted to a QCell, the compiler
essentially does not remember that it was originally a DCell- it sees it
only as a QCell. Since not all QCells are DCells, a QCell cannot be
automatically be converted to a DCell- you, the programmer, have to assure
the compiler that what you are giving it really is a DCell, even though it
doesn't look like one. That is what typecasting is.

Note also: The syntax for casting a data member is, for example,
((DCell)D.back), not D.((DCell)back)