Dear all,

  below are final guidelines for submitting your last deliverable. I
appreciate that these have come very late in the term - that will be
taken into account when your submissions are marked, and a 1-day
extension has been added for submission of the Java code & testing
instructions. Note however that the written part of the submission
must still be submitted on Monday.

Your submission should be in two parts: documentation and code. Your
documentation (cover sheet - available from course web-page, revised
use case model, activity diagrams and any other accompanying
documentation for your Java code) should be submitted, as a team, to
the ITO office (room 1502, JCMB) no later than 5pm Monday 10th. Your
Java code and testing instructions should be *emailed* to your tutor
no later than 5pm Tuesday 11th.

When submitting your Java code, your email to the tutor should also
include instructions for how to (i) compile the code into an
executable form, and (ii) perform testing of all use cases. Ideally
your tutorial group should email the code and instructions as one
unit, but separate email submission for each individual team are also
appropriate.

Your email must supply sufficient instruction to permit the tutor to
easily perform at least 2 tests of every use case that has been
implemented. In a nutshell - the easier you make it for your tutor to
verify that the (i) the tests give the expected results, and (ii) that
this is because the code actually works; then the better mark you will
receive. Thus your instructions need to (a) tell your tutor how to
invoke *all* the necessary tests and (b) inform them what the expected
results are. Here are some suggestions, in order of preference, for
how you might do this:

1. Supply a simple "driver" Java test program, which either acts as a
main class to glue the 4 subsystems together or - if you already have
such a main class - invokes it. This driver program may either
generate message calls to test all the necessary use cases, or may
simply accept test input which is passed on as appropriate message
calls to the relevant subsystems. While the driver program should be
as simple as possible, it will still need sufficient documentation
(perhaps simply in the form of code comments) to permit the tutor to
assess it.

2. Supply four simple "driver" Java test programs, one for each
individual subsystem. Other than failing to show that the four
subsystems interface correctly, this is as above.

3. Supply written test specifications,informing how to invoke each
test and what the expected result is, for every use case of the
combined system. A simple specification written in (clear) English is
sufficient. 

4. Supply four sets of written test specifications, one for each
individual subsystem and for every use case in that subsystem.


To summarise: the bottom line for your Java prototype is that you must 
convince your tutor that (a) the code satisfies all necessary tests
and (b) that, in the process, the four subsystems can interface
correctly. The easier you can make it for your tutor to compile the
code, run the tests, verify the results, and assess the accompanying
documentation - then the happier they will be, and the better the mark 
you will receive.

Enjoy, and once it's done - have a Very Merry Christmas

  Corin