1

IS 247, Spring 2011, Coding Guidelines &
Pair Programming

• Suggestion: start homeworks early and send e-mail if you get stuck.
Cell phones & laptops off.
Reminder: if printing the notes, consider printing 4-up (4 pages per side) or
2-up or 6-up or some such.
Generated 2015-01-26, 08:25:40

2

Java Operators
++
-~
!
*
+
/
%
>
>>>
=
>
<
>=
>> 1; b = b >>> 1;
} // while something’s nonzero return count;
} // hammingDistance() public static void main(String[] args) {
System.out.println(
hammingDistance(Integer.parseInt(args[0]),
Integer.parseInt(args[1])));
} // main()
} // class HammingDistance

4

A Refinement
That version of Hamming Distance was fine, but can we take advantage of the fact the exclusive-or can be thought of as a not equals function?
So if we take the exclusive-or of two integers, the result has a one in every bit position in which the numbers differ, and zeroes everywhere else. public static int hammingDistance(int a, int b)
{
int count = 0;
// bits has a one wherever a and b differ int bits = a ^ b; while (bits != 0) { if ((bits & 1) == 1) // is the low bit one?
++count;
bits = bits >>> 1;
// done w/this bit
} // while something’s nonzero return count;
} // hammingDistance()
This simplified the loop condition and took one shift out of the loop body.

5

Hamming Distance—Final Version
It turns out we can simplify things a bit more through the use of the Java library. public static int hammingDistance(int a, int b)
{
// bits has a one wherever a and b differ int bits = a ^ b; return Integer.bitCount(bits);
} // hammingDistance()

6

Example: Separating Color Fields
Often color is represented using separate red, green, and blue (RGB) values.
For brevity, all three values are stored in three bytes of a single computer word, which from our point of view is an int. If each color value is a byte, then it’s 8 bits, which means there are 28 = 256 different values for each color component (and 224 = 16M different colors overall).
Each byte takes on an integer value in the range 0–255 decimal, or 0x00 – 0xff hexadecimal.
We’ll need a mask.

7

public class RGB { public static int redComponent(int color) { int value = color >>> 16; return value & 0xff;
} // redComponent() public static int greenComponent(int color) { int value = color >>> 8; return value & 0xff;
} // greenComponent() public static int blueComponent(int color) { return color & 0xff;
} // blueComponent() public static void main(String[] args) { int color = 0xfffdb975; // note top ff invalid
System.out.println(redComponent(color));
System.out.println(greenComponent(color));
System.out.println(blueComponent(color));
} // main()
} // class RGB

8

Java Coding Guidelines
These coding guidelines are pretty typical of standards one would encounter in industry—but minimal.
They are guidelines: for any particular guideline there may be occasions in which they can be violated.

9

Design Guidelines

• Think before you code.
Just because a program works doesn’t mean it’s good.
Design.
• Readable Structure
– Never use the continue statement.
– Use break only to terminate cases of switch statements.
– The book says a method should have just one return.
That depends—often multiple returns will simplify logic. • Modifiers
– No variables should be public unless they’re also final. – Write-once variables (“constants”) should be marked final. 10

• Use named constants rather than literals wherever possible. – 3.1415926, "lion" are literals.
– pi, feline are identifiers which could be named constants • A method should do exactly one thing.
If multiple things need to be done, use multiple methods.

11

Variable Scope
In general we don’t want a variable accessible from a wider range of places than necessary.
• This is why instance variables are almost never public.
• This is also why for loop control variables are usually local to the loop.
Consider instance variables vs. variables local to a method.
Local variables can only be accessed from within the method. What if an instance variable is only used within one method? • It should be declared within that method, and thus
• accessible only from within that method.
This is something a lot of people lose points on.
If it can be local, make it local.

12

Why Keep Local Things Local?
• Readability:
– a variable’s use is near its declaration
– the reader doesn’t have to wonder where else it’s used, for what, and how.
So limiting the scope of variables makes code more readable, maintainable, and reliable.
• Efficiency:
– If a variable’s not local, the compiler can’t tell whether its value will be needed again.
So the compiler can’t free up no-longer-needed memory.
– Variables local to a method are allocated when the method is called (at the earliest) and freed up when the method returns (at the latest).
– Instance variables are created when an object is created, and freed up if the object is collected.
– Many compiler optimizations are more practical with local variables than with instance variables, e.g., a local variable is much more likely to be kept in a register. So limiting the scope of variables saves memory and processing time.

13

Style Guidelines

• Identifier names should indicate their use.
• Identifiers should be easy to read: dayOfYear is better than doy—and much better than x.
• Every class name:
– begins with a capital letter;
– is written in “CamelCase,” and
– is a noun.
• Method names and variable names start with lower case letters.
– And are written in “camelCase.”
• Indent 2–4 spaces; a full tab stop (8 spaces) is way too much. • Keep code to less than 80 columns—otherwise, it has to be printed in landscape mode, which wastes paper.
– Don’t print code in landscape mode:
∗ In addition to wasting paper, landscape encourages programmers to use wide, often less readable lines. – When printed, lines should not wrap.

14

Whitespace

• Use whitespace to enhance readability.
• A comma is generally followed by a space.
• Binary operators are usually separated from their operands by single spaces.
• No spaces immediately before a closing parenthesis or immediately after an opening parenthesis.
• No space between a method name and an opening parenthesis. • No spaces before a semicolon, comma, or square bracket.
• In array declarations, place the square brackets with the type, not the variable.

15

Messages, Prompts, Output

• Be informative, but succinct.
• Prompts should be clear and specific.
• Indicate default values, if any, in prompts.
• Output must be readable.
• Output must be labeled.

16

Internal Documentation

• Assume the reader knows Java.
• Assume the reader knows little to nothing about what the program’s supposed to do or how.
• Document blocks of code that might not seem obvious to a reader.
• Comments must be accurate—revising code usually leads to comment revisions.
• Be concise but thorough.
• Every file should begin with a header block that identifies the class(es) in the file, their purposes, the author, any assumptions made by the author.
• Use in-line comments rather than /* ...

*/ blocks.

• Insert comments as the code is written, not after.
• Using javadoc-style comments as appropriate is good, but not required for this course.

17

Pair Programming
Pair programming is often described as [Williams 2000]: a practice in which two programmers work side-byside at one computer, continuously collaborating on the same design, algorithm, code, or test. This method has been demonstrated to improve productivity and the quality of software products.

18

Pair Programming Rules

• Share. “In pair programming, two programmers are assigned to jointly produce one artifact (design, algorithm, code, among others). ... One person is typing or writing [driving], the other is continually reviewing the work [navigating]. ... Both partners own everything.”
Not only is this an effective learning technique, it is also more productive than splitting a task in two, working on each half separately, and then combining the two.
• Play fair. It is important to take turns typing or writing [driving], so that the other person gets a chance to review [navigate].
• Clean up. Defects belong to the pair. Having two sets of eye balls is much better than one.
• Hold hands and stay together. All programming should be done together; do not create things done alone. The literature of pair programming shows that most defects are traceable to things done singly.
It also inhibits learning.

19

• Say you’re sorry. “Ego-less programming ... is essential for effective pair programming.” Do not insist on having things your way or else. Do not get defensive about criticism. Work things out as a pair.
• Pairs should turn in only 1 copy of an assignment with both names on the assignment.
• Pairs, once formed, must be stable; your only other option is to revert to working alone for the semester.
Exception; to get an exception, you need to present your case to your instructor prior to beginning an assignment.
• Pairs may split for an assignment and then return to pairing.
• Pairs are required to work together; any form of splitting up the work is a violation of pair programming.

20

Violations of Pair Programming
• Taking turns doing the assignments.
• Splitting the assignment in two and each doing half.
• One person doing all (most of) the work and the other partner putting their name on it, as though the latter had contributed equally.
• One member of a pair coming to see me about an assignment without their partner.
Sources of Stress
• Disparity between experience levels.
• Scheduling difficulties.
• Reliability.
See Bob Noonan: http://www.cs.wm.edu/%7enoonan/pairprog.html Laurie A. Williams and Robert R. Kessler. “All I really need to know about pair programming I learned in kindergarten.” CACM, 43, 5 (May 2000), pp. 109-114.

21

A Little Review

• Variables
• Types
• Arrays
• Classes
• Fields, or data members, or member variables
• Methods

22

An Array Example
Suppose you were asked to write a method to remove duplicates from an array of strings.
• How would you do it?
One way would be to look for duplicates of the first thing in the array, then the second, then the third, and so forth. public static void deleteDuplicates(final String[] data) { for (int left = 0; left < data.length-1; ++left) if (data[left] != null) for (int right = left + 1; right < data.length;
++right)
if (data[left].equals(data[right])) data[right] = null;
} // deleteDuplicates()

This works, but leaves many null references in the array.

23

A second method could be written to return a new array with no nulls: public static String[] condense(final String[] data) { int nonNulls = 0; for (String s: data) if (s != null)
++nonNulls;
String[] result = new String[nonNulls]; int index = 0; for (String s: data) if (s != null) result[index++] = s; return result;
} // condense()

24

A simple test driver might simply create an array and display what the above methods do to the array: public static void main(String[] args) {
String[] a = { ... }; deleteDuplicates(a); for (String s: a)
System.out.println(s);
System.out.println("\n\n\n"); a = condense(a); for (String s: a)
System.out.println(s);
} // main()
} // class DuplicateDeleter