Overview

This course features several homework assignments, as listed on the assignments page.

• Unless otherwise stated:
• collaboration IS NOT allowed on programming assignments.
• you may use language references to determine relevant Java syntax and semantics. Since Java syntax and libraries are standardized, we will consider this to be "general knowledge", and you need not cite reference sources.
• you may consult only the textbook and the Java API references for information regarding algorithms. All non-syntax consultations (including the textbook and Java references) require formal citation within the related program or exercise.
• You always may consult the instructor regarding questions on labs or assignments (at least if the instructor is in his office with the door open).
• Programs (source code, compilation, and output) are to be submitted in the format below.

Submitting Programs

In turning in any programs for the course, please follow these directions:

1. The first seven or more lines of any Java file should be comments containing your name, your mailbox number, the class section, an identification of assignment being solved, and a description of the contents of the file. For example (from Basics.java):

    
         /*************************************************************************
          * Jerod Weinman  
          * Box: SCIE
          * CSC 207.01
          * Assignment 1: Java Basics
          * Basics: Definitions of several basic functions for numerical predicates 
          * and some array operations.
          ************************************************************************/
       

2. A comment is required for every definition of a Java method, stating in English what that program unit is supposed to do. Complete Javadoc-grade documentation is not necessary for every method, but is encouraged.
3. Obtain a nicely formatted listing of your source code using the enscript(1) command:
   enscript -Ejava -2 -r --color -p prettysource.ps Source.java ...
   where prettysource.ps is the name of the file in which you want the formatted source code stored (enscript(1) generates a PostScript file, hence the ".ps" extension.) If your work involves several Java files, list the primary program first, then list any supplementary files. Multiple source files can be placed in one call to enscript(1). You may also use a wildcard such as *.java. Be sure not to include any compiled class files.
4. If you have multiple Java source files, create an archive of them for electronic submission. For example,
   tar cf sources.tar Source.java ...
   where sources.tar is the name of the archive file you want your program source files stored in. You may list as many source files on line as you wish, or even use a wildcard (*.java) You may also add an entire directory to an archive by including the directory name without a trailing "/" in the list of files. If you do this to include the entire directory, please be sure you do not include any class files, etc.
5. Create a transcript of your program's compilation and testing/output runs using the script(1) command:
   1. In a terminal window, start recording output to a file called transcript with the command:
      script transcript
   2. Compile your classes with javac (or make or ant) as appropriate.
   3. Run your program with appropriate test cases to check its correctness.
   4. Run your program with on any other demonstrations as necessary.
   5. When your runs are complete, stop the script session by typing Ctrl-D.
   6. Convert the recorded text file to a nice, printable PostScript file using enscript(1):
      enscript -2 -r -p transcript.ps transcript
      where transcript is the name of the recording file you created above, and the ".ps" file is the printable version enscript(1) creates.
6. Concatenate and print your program listing and transcript, i.e.,
   cat prettysource.ps transcript.ps | lpr -Pprinter
   where printer is the name of the printer you want to send the output to.

7. Include a separate, TYPED statement that argues why your program is correct, based upon the evidence from your tests. No hand-written statements will be accepted.

   You may use a word processor to format such statements, or you may use a simple text file. You may easily incorporate a text file into your submission by including it in the transcript. Between 5.d and 5.e,

   cat statement.txt

8. You or one group member (if collaborative) should submit:
   1. your printed work at the beginning of class on the day it is due, AND
   2. an electronic version of the source file archive (source.tar from 4 above) online via PioneerWeb by the beginning of class.
   The late policy applies to both portions of the submission jointly (e.g., if one portion is late both are considered late.)

Notes on Grading

Testing

Requirements

Since every programming task should yield readable and carefully tested code, the grading of all programs for this course will begin with the following algorithm (expressed in Java format):

    if (  (no_comments)
       || (no_evidence_of_compilation)
       || (no_tests)
       || (no_commentary_on_correctness))
    return (no_grade);
  

When a program is submitted according to the format specified above, it should be understood that the transcript reflects a complete session of compilation and running of the accompanying source code. With this understanding, editing of any script file is strictly forbidden and raises questions of academic dishonesty. According to College policy, any evidence of academic dishonesty must be turned over to the Committee on Academic Standing for action.

Style

Because code maintainability is an important part of development, your assignments will be graded in part on style, as well as correctness. After all, if I cannot understand your code (or it takes me too long to), I cannot give it a grade regarding its correctness.

Some style matters I care about that you may want to consider:

1. Indentation/whitespace that helps delineate code blocks. (Most editors will help you with this.)
2. Helpful comments on blocks of code or particularly complicated expressions.
3. Functions that are reasonably small. (A very good guideline I try to follow is getting an entire function to fit on one screen; this makes interpreting a function's action more readable by forcing you to break it down into named steps that can be seen at once. It also promotes easier debugging and unit testing.)
4. Code lines that are no wider than 80 characters. This makes them easier to read both on screen and on paper. (See #1 in this list.)