CS101 Style Guide

Getting the computer to understand your program is no guarantee that people will be able to follow it. Just as you would edit an English composition, you should spend time revising a computer program to make it elegant and readable. The following guidelines will help you write programs that are easy to read and modify. Beginning with Lab 2, the CS101 graders will expect your assignments to conform to these style and documentation conventions.

0. Put a cover sheet on your lab.

1. Include a header comment at the top of each file.

• The first lines of the header should include the following standard information:
  1. Your name (and the names of any people you worked with--see the CS101 collaboration policy)
  2. Your lab section (e.g., Lab E)
  3. Your email address
  4. The name of the lab assignment (e.g., CS101 Lab 1)
  5. The name of the file (e.g., lab1.java)
  6. The date of last modification to the file.

• After the standard header information, it's often useful to include a few lines to describing the contents of the file. This should include, for example a brief description of the purpose of the class defined in that file. Be brief and informative. Since the CS101 TAs are already familiar with the assignment, please don't repeat the assignment. Instead, communicate your approach to solving the problem.

• If you make any assumptions regarding the problem to be solved or about the kinds of inputs your program will accept, you must list these assumptions in a separate paragraph (labeled "ASSUMPTIONS:") at the end of the header comment. Deviations from the assignment should be listed as well. Keep in mind that any significant deviations should also be cleared with the instructor in advance. Specific assumptions regarding particular methods may be expressed as inline comments next to the relevant methods.

• If you complete an extra credit option for a lab assignment, include a separate paragraph (labeled "EXTRA CREDIT:") in the header comment for the file containing the procedure "main."

2. Write self-documenting code.

• Choose meaningful names for all variables, parameters, classes, and methods. Use complete words instead of abbreviations. For example, use width instead of w. (However, if an assignment specifies a particular name, please don't choose a different one.)

• Use named constants instead of sprinkling numbers throughout your code. This not only makes it easier to read the program, but also simplifies changing the values later because you only have to make the change in one place, where the constant is defined. (Test cases are an exception--use numbers there.) Rule of thumb: if a constant is used more than once, give it a name.

• The logic of your program should be clear from the text. Keep it simple. Avoid "clever" tricks that save a line of code at the expense of clarity.

• Avoid repetitious code by writing an appropriately named procedure and calling it multiple times.

• Be especially careful to keep boolean expressions simple. This will ensure readability and will help you avoid logic errors. Also, remember to simply return the value of a boolean expression, rather than testing it in a conditional statement that returns true or false:

  GOOD STYLE:	BAD STYLE:
  return (height >= level);	if (height >= level) return true; else return false;

3. Follow standard formatting conventions.

• Capitalization:

  variables and method names

  the first letter is lower case, with the first letter of each subsequent word capitalized
  for example, int caloriesFromFat = 18;

  class names

  the start of each word is capitalized
  for example, public class VelocityVector {

  constants

  the entire name is capitalized
  for example, public final double PI = 3.14159;

• Indentation:

  braces

  the open brace ({) goes at the end of the line before the start of the code block.
  the close brace goes on its own line, indented to match the beginning of the line containing the corresponding open brace

  code inside braces

  indent one level for each level of curly braces ({})

  code inside consequents

  use curly braces and indent one level for consequents in conditional statements (braces may be omitted if there is only one statement in a consequent, but some editors expect the braces in order to do automatic indentation properly)

  continued lines

  when a statement continues across two or more lines, indent the second and remaining lines an equal amount past the start of the first line of the statement. See the example.

  example:

  public static boolean withdraw (int requestedAmount) {
     if (balance < requestedAmount) {
        return false;
     }
     else {
        balance = balance - requested amount;
        Terminal.println("Withdrawl of $" + requestedAmount +
                         " successful, leaving $" +
                          balance + ".");
        return true;
     }
  }
  

• Order of variables and methods:

  constants

  if you define any constants, they should go first, with public constants before private ones

  class variables (static variables)

  if you define any static variables, put them immediately after the constants, listing the public variables first

  instance variables

  should follow the class variables, with the public ones first

  constructors

  should precede all other methods

  public accessors

  should immediately follow the constructors

  other methods, public and private

  can be listed in any logical order, with related methods near each other

  the toString method

  should be last so people can find it quickly

4. Use inline comments sparingly but whenever necessary.

• Use inline comments whenever the meaning of the code is not immediately obvious from the text. For example, inline comments can be useful to summarize cases in a conditional expression.

     if (xPosition < xLeft)               // left of box
        ...
     else if (xPosition > xLeft + width)  // right of box
        ...
     else if (yPosition < yBottom)        // below box
        ...
     else                                 // inside or above box
        ...
  

• Whenever possible, write self-documenting code to avoid the need for inline comments. The comment in the following example adds no information and should be omitted since it just wastes the reader's time.

     int RectangleWidth = 30;  // the width of the rectangle is 30
  

5. Present your test cases clearly and methodically.

• Test cases should be ordered logically, preferably in the same order as the code being tested.

• Whenever possible, choose test cases whose expected output be quickly computed in your head (without the need for a calculator).

• When there are only a few possible inputs, test them all. Otherwise, choose test cases that exercise all branches of the code (for example, one test case that satisfies the condition in an if statement and a second test case that doesn't satisfy the condition).

• Be thorough. Pretend that you are an adversary trying to "trick" the program into giving the wrong answer. For example, test cases should include zero or negative values even if the "normal" case is a positive number. However, you are not obligated to test inputs that violate your stated assumptions.

6. Use common sense.