WORCESTER POLYTECHNIC INSTITUTE
Computer Science Department

CS4341 ❏ Artificial Intelligence ❏ A'06

Mon, Tue, Thu, Fri - noon - AK 233
Prof. David C. Brown, Fuller Lab 131, (508) 831-5618, dcb at cs.wpi.edu

Version: Wed Sep 6 15:48:04 EDT 2006

PROJECT 1 - A Rule Interpreter - Evaluation Criteria

All projects will be graded out of 100 points for convenience, and will be adjusted later to conform to the class grading scheme already provided to you. Grading will be subtractive. That is, you start with 100 points, and points will be deducted for problems found. This produces lower scores, is harder to grade, but is much fairer and more consistent.

The grading will be divided into consideration of:
* 60 pts  Required       (i.e., what the problem description asked for)
* 10 pts  Presentation   (i.e., style, layout, comments)
* 30 pts  Demonstration  (i.e., the output from the system 
                                -- layout, clarity, completeness, how well tested).


Required:	
        Forward Chaining implementation
        Backward Chaining implementation
	Separate... 
            rules (from file)	
            actions (from file)	
            predicates (from file)	
            WM (from file)		
	Conflict resolution  (e.g., specificity)
            For forward chaining
	Structure of... 
            rules   (e.g., readability)		
	    WM			

	Brief, clear documentation that describes the design of your
	   RI, including the overall architecture, any special algorithms
	   used, and any special data structures used.
        A description of how you've handled rule selection from the
           conflict set.
        A description of how you've handled the predicate- and action-specific
           "translation" (i.e., what restrictions/assumptions).
        A description of your rule language.
        All the test cases in your demonstration with the
          corresponding output that shows that the RI is functioning
          correctly.
        All the code (which must be well commented).

Presentation:

	Liberal comments
	Clear program layout
	Clear ordering of functions in system
	Good naming conventions
	Appropriate use of abstraction (e.g., assistance functions) to raise
	  the level of the code to the level of the problem and away from LISP/Scheme.
	Good problem decomposition
	Good choice of data structures

Demonstration:

        All working & correct.
	How well tested (i.e., enough good tests done?)
	                (e.g., when doesn't it work?)
        Elementary syntactic/semantic checking of rules.
        Both forward and backward chaining working with same rules.
	Layout of output
	Completeness of messages (i.e., can we understand what's happening?)