Hand marking scheme for Assignment 1
-------------------------------------

There are 8 sections, each out of 2 marks.  Generally, 2 indicates
that the section is fine, 1 indicates a few problems but overall
pretty good, and 0 indicates it's terrible and/or worthless.

Note that hand marking doesn't assess whether the code works or not,
rather, how "good" the code is.  "Good" here means clarity, readability,
extensibility, maintainability, etc.  The machine marking assesses how
correct the code is.



INDENTING
  2/2: Consistent use of indenting to indicate scope throughout the
       code.
  1/2: Generally reasonable indenting, but some poor parts or
       inconsistently applied.
  0/2: Terrible indenting which doesn't aid readability at all.


WHITESPACE AND BRACKETING
  2/2: Consistent use of vertical and horizontal whitespace to group
       sections of code.  Consistent use of any particular bracketing
       style.  Whitespace and bracketing schemes used aid readability.
  1/2: Generally reasonable whitespace and bracketing, but some poor
       parts or inconsistently applied.
  0/2: Whitespace and bracketing completely inconsistent or no help at
       all to readability.


IDENTIFIERS
  2/2: Good, consistent identifier naming scheme applied throughout
       the code.  Identifiers are descriptive and concise, multi-word
       identifier scheme applied consistently.
  1/2: Generally good identifiers, but some identifiers not following
       main scheme (ie. mostly, but not fully, consistent application
       of scheme).
  0/2: Majority of identifiers are terrible and/or no naming scheme
       seems to be applied.


COMMENTS
  2/2: Good, descriptive comments which give insight into the code
       applied consistently and thoroughly where necessary.  Every
       function has a comment describing its task, parameters and
       return values.  Every important variable has a comment
       describing its purpose and/or use.  Complex code and code
       paragraphs should have comments where necessary/appropriate.
  1/2: Comments generally good, but not applied consistently or
       everywhere needed, or some small number of comments aren't
       good.
  0/2: No comments, or comments not good, eg. restating the code,
       confusing, hard to understand, don't make sense, poorly stated.


STRUCTURE
  2/2: Structure reflects high cohesion and low coupling.  It is clear
       that every function performs a single distinct task, parameters
       passed and return value are appropriate, functions not called
       unnecessarily.
  1/2: An attempt at using functions to perform different tasks, but
       each function performs more than one task (eg. another function
       should have been created, but wasn't), or tasks aren't sensibly
       grouped, or functions are called when not necessary (eg. when
       passing a parameter to get the information is be more
       appropriate).
  0/2: No attempt to use functions to perform different tasks.  All
       real code is in one or two main functions.


APPROPRIATE DATA STRUCTURE USE
  2/2: All data structures used are appropriate and suited to the
       tasks they are used for.  (Using vector<char> for symbols is
       okay.)
  1/2: Data structures work, but are not well suited to how they are
       being used.  For example, using a map or list where an array or
       vector is more appropriate, or using an array when a vector is
       more appropriate.
  0/2: Consistent poor choice of data structures - data structures
       used are completely inappropriate and/or don't work.


APPROPRIATE CONTROL STRUCTURE USE
  2/2: All control structures are appropriate to the task.
  1/2: Some control structures not appropriate or well suited to the
       task.  Eg. using a switch or if-else-if ladder when a loop or
       array lookup (perhaps with some special cases) would be better,
       or using a while loop with manual initialisation and increment
       when a for loop is more usual.
  0/2: Control structures consistently poorly chosen and/or used, and
       rarely (if ever) suit the task.


COMPLEXITY
  2/2: Code is as simple as it could be (given choices of data and
       control structures).  Where there exists more than one way to
       do a particular task, the simplest, or least confusing, or
       least surprising way is used.
  1/2: Code is not overly complicated, but some parts are done in
       non-obvious ways.
  0/2: Code is unnecessarily complicated.  Tasks are performed in
       strange, non-obvious ways.