Course Grading:
  This 1 credit course is graded on a credit (CR) / no credit (N) basis and
  may not be taken for a letter grade. A grade of CR gives you credit
  towards a degree but doesn't have any gradepoints associated with it to be
  figured into your gradepoint average calculation. A grade of N does not
  award any credit. Final grades are based on the following:
  
    - Lecture Attendance:
 Make sure to sign the attendance sheet at each lecture.
- 90% Programs:
        five (5) programming assignments with program 1 - program 4 worth 20%
        of your final grade and program 5 worth 10%.
- 10% Homework:
 one (1) homework assignment worth 10%
Students meeting BOTH of the following requirements will
  receive credit (CR) for the course:
  
    - attendance of at least 11 of the 14 lectures
- a cumulative score of 70% or better on the assignments
If you miss more than 3 lectures, then for each lecture missed (beyond 3),
  the cumulative score on the assignments required to earn credit for the class
  is increased by 5 points.  For example, if you attend 10 of the 14 lectures,
  credit will be given if your cumulative score on the assignments is 75% or
  better.
  Scores for attendance and assignments are reported through the
  Learn@UW
  System.
 
  
  Programming Assignments:
  There will be five (5) programming assignments.
  Accounts are provided on the CS lab computers for you to do your
  programming work.  See the CS Computer Labs
  page for more information.
  Links to programming assignment pages:
  
  Policies for Programming Assignments:
  
    - Collaboration:
        Programs can be done in pairs but you must follow the
        rules below.
- Questions:
        are to be posted on Piazza,
	a free tool that we're using to manage questions. Before posting a
        question, please search the assignment pages for an answer and also
        search Piazza to ensure your question hasn't already been asked.
- Late Programs: 
        see late policy specified below.
- Grading:
        See assignment grading information below.
 
Late Policy:
  Starting with assignment p3, all assigments will lose 10 points per day late, regardless of the reason.  There are no exceptions to this policy. You must email the instructor directly when you have completed your assignment in order to have your work graded.
 
How to Submit Assignments Electronically:
  Programs are turned in electronically for your convenience and to save
  paper. You can submit your work at any time prior to the due date. The
  last section on each assignment page lists what to turn in. All assignments
  are to be submitted as plain text files containing source code for programs.
Handin Directories:
  A directory will be created for you to use to electronically submit
  your work. 
  
/p/course/cs368-kuemmel/handin/<YOUR_CS_ACCOUNT_NAME>
  Where <YOUR_CS_ACCOUNT_NAME> is the login name that
  was assigned to you to access your computer science account. This is your
   main "handin" directory in which is found subdirectories:
  
    - in for submission of  programs,
- p1 for graded program 1,
- p2 for graded program 2,
- p3 for graded program 3,
- p4 for graded program 4,
- p5 for graded program 5,
You will always turn your programs into the in directory.
Steps for Submitting Files:
  You may submit your files multiple times.  You may re-submit a
  file, by overwriting the one already in your handin directory. You do
  not have permission to delete files from your handin directories, and
  neither do the course TAs. This ensures that accidental deletion of your
  work cannot be done. If you want a file removed, email the course
  instructor specifying your login name and the name(s) of the file(s) you
  want removed.
  After the due date and time, your submission is moved to the corresponding
  assignment subdirectory, for example, program 1 is moved to p1.
  You have permission to
  read from from these assignment subdirectories except while we are grading.
  You will need to submit your work to your CS handin directory either from a
  CS lab computer or remotely from the your computer.
  Linux Lab Computers If your work was done on the lab computers or you've already
  copied your work onto a lab computer you will follow these steps. Assume you're
  turning in your first program:
  
    - Log into one of the CS lab computers (with your cs login)
- Open a terminal window (click on the background)
- Change to the location on your account containing your assignment, for example:
 cd private/cs368/assignments/p1
 Note: the private directory is already created for you;
        this example assumes you've created additional subdirectories
        (cs368, assignments, and p1) to organize your work.
- Copy your files to your "handin" directory as in this example:
 cp <FILE_NAME> /p/course/cs368-kuemmel/handin/<YOUR_CS_ACCOUNT_NAME>/in
 Note: your in handin directory has already been created for you.
- Verify that your files are in your handin directory as in this example:
 ls -l /p/course/cs368-kuemmel/handin/<YOUR_CS_ACCOUNT_NAME>/in
Trying to use the file browser on a lab computer
  to drag and drop your file into your handin directory will result in an error
  message.
  Remotely using SSH Client on Windows: You may also submit your work remotely by using
  an SSH client (SSH, Putty, SecureCRT, etc.) that has been configure to connect to one of the
  CS lab computers. Steps similar to these typically work.
  Assume you're turning in your first program:
  
    - Use your SSH client to remotely log into one of the CS lab computers (with your cs login)
- Use the file transfer feature of the SSH client to copy your files to your handin directory.
        You might need to use the terminal of the SSH client to change the location of your in handin directory as with this linux command:
 cd /p/course/cs368-kuemmel/handin/<YOUR_CS_ACCOUNT_NAME>/in
 
- Use the terminal of the SSH client to verify that your files are in your handin directory as in this example:
 ls -l /p/course/cs368-kuemmel/handin/<YOUR_CS_ACCOUNT_NAME>/in
Remotely using Macs: See these instructions for using SCP
  and SSH).
 
Assignment Grading:
  Assignments are graded by the course TA using specified grading
  standards. See the TA named in your grade report if you have questions
  about the grading of your assignments.
Re-Grades Requests:
  You may request a re-grade of your assignment,
  if you believe it wasn't correctly graded.  Contact the TA named in the
  assignment's grade report within one week after the graded
  assignment is returned.
Assignment Grade Reports
  A grade report is generated for each assignment and is named
  gradeReport.html found in the particular assignments handin
  subdirectory. For example:
  
/p/course/cs368-kuemmel/handin/seuss/p1/gradeReport.html
  
  contains the grade report for program 1 for the student whose CS
  account name is seuss. This is called the full Linux path name for
  gradeReport.html file.
Viewing Grade Reports
  There are several ways you can look at your reports depending on where you are:
  
    - CS Lab Computer: Enter the following in a terminal window: 
    
 firefox /p/course/cs368-kuemmel/handin/seuss/p1/gradeReport.html
- Remote Computer: Download the gradeReport.html file to
    your machine and use a web browser to view the downloaded file.
- Either CS Lab or Remote: Log into a CS
    lab computer (remote use SSH). View the contents of the file with the
    lynx terminal-based browser by entering the Linux command
    lynx <filename>
    where <filename> is the full Linux path name of the file you
    want to view.
 
  
  Rules of Pair Programming:
  
    - You may have only one partner for each programming assignment.
- You may have a different partner on different programming
        assignments.
- You may not pair program with multiple partners on the same
        assignment.
- Your partner must be currently enrolled in the same CS368 lecture.
- You must list your partner as a collaborator in the header comments of
        your source files (see Commenting
        Guide).
- Only one partner submits the program files, but both
        partners must submit and hand in the
        README.txt file.
- You must follow the principles of pair programming
        summarized below.
Submitting someone else's work as your own is
  academic misconduct, which will be dealt with in accordance with University
  Academic Misconduct procedures.
  
  Principles of Pair Programming:
  The following is a summary of successful pair programming principles taken
  from a paper by
  Williams and Kessler:
  
    - Pair programming involves two people working together at one
        computer, continuously collaborating on design, coding, and testing.
        One person types; the other either provides directions ("Now we need
        to write a new method that does ..., Now we need a loop to do ...")
        or constantly reviews what the typer is doing, and provides
        comments.
- Pair programming has proved successful both in classes and in
        industry.  Programmers usually report having more confidence in
        their solutions and enjoying programming more when working in
        pairs.
- It is important to switch roles often (slide the keyboard back and
        forth).  Because pair programming can be quite intense, it is also
        a good idea to take breaks (to check e-mail, go for a walk, have
        a snack).
- It is important to provide honest but friendly feedback.
        To be effective, there needs to be some healthy disagreement and
        debate, but pairs also need to be respectful of each other, and try
        to avoid becoming defensive when receiving criticism.
- Inevitably, programmers do some independent thinking/working. 
        For best results, that work should be reviewed by both
        partners (and perhaps revised) when they start working together
        again.
- To be successful, pair programmers must realize that the benefits
        of working together outweigh their usual preference for working
        alone, they must confidently share their work, accepting instruction
        and suggestions for improvement in order to improve their own skills
        and the code they are writing, and they must accept ownership of
        their partner's work and thus be willing to constructively
        express criticism and suggest improvements.