CSE 143: Computer Programming II, Autumn 2017

General Style Deductions

Students in CSE143 are expected to demonstrate good programming style in their homework solutions. Every homework assignment will describe specific style requirements and expectations that students should keep in mind when writing their solutions. This page lists general style issues that are likely to be relevant to multiple assignments. This list includes common style mistakes but does not list every possible style mistake.

TAs provide feedback on graded homework assignments and often give a "-0" warning to indicate a style issue that is not being penalized but might be in a future assignment. Because of the timing of CSE143 assignments and duedates, students will not receive their graded homework solution prior to submitting the next solution. As a result, TAs will spend some time in each Thursday section discussing common style issues that they saw in the previous homework.

The list below indicates general style issues that will not be graded as "-0". Homework assignments are listed in reverse order because once a style issue is included for one homework, it is included for all future homeworks. The list is not meant to be exhaustive, although it includes the most common style issues. Students should not ask about the details of style grading on the message board, but can ask their TA or a TA at the IPL to explain any of these style categories.

• Homework 8: Huffman

  no new style errors

• Homework 7: 20 Questions
  • class design errors:
    • not using calls on this(...) to eliminate redundancy by having one constructor call another
  • data structure errors:
    • not using x=change(x) when appropriate to simplify code
    • poor choice of constructors for a node class (e.g., unused constructors or just a zero-argument constructor)
  • miscellaneous errors:
    • using \n to produce more than one line of output with a single print/println/printf
• Homework 6: Anagram Solver

  no new style errors

• Homework 5: Grammar Solver

  no new style errors

• Homework 4: Evil Hangman
  • method errors:
    • using if/else instead of if for exception code (non-exception code should not be in an else branch)
    • not decomposing complex methods into logical subtasks that each have their own method
  • data structure errors:
    • excessive inefficiency when using collections (e.g., using a foreach loop to find a value of a map when a call on get would return the value)
  • miscellaneous errors:
    • Incorrect use of type (e.g., double instead of int, int instead of boolean)
    • Computing a value multiple times when it could have been computed once and stored in a variable.
• Homework 3: Assassin
  • readability errors:
    • nondescriptive names for local variables or methods
  • control structure errors:
    • bad use of if/else (e.g., empty branch, if/if instead of if/else, poor factoring, unnecessary tests)
    • bad use of loops (e.g., including an unnecessary check before a loop that repeats the loop test)
  • method errors:
    • not throwing exceptions at the beginning of a method when detecting the error does not require significant computation
    • modifying a parameter to a method when such modification was not part of the intended behavior
  • miscellaneous errors:
    • failure to simplify code (e.g., not factoring out common code, extra tests or loops that aren't necessary)
• Homework 2: Guitar Hero
  • commenting errors:
    • implementation details included in comments for a class or its public methods
    • method header does not describe all parameters
  • readability errors:
    • lines over 100 characters
    • not following Java naming conventions (e.g., not using camel case, not using uppercase letters for constants)
    • one-letter or nondescriptive field names
  • method errors:
    • unused parameters or return value
    • reimplementing methods (i.e., writing code for a commonly used method such as Arrays.toString)
  • class design errors:
    • incorrect constant declaration (e.g., not final, not static)
    • extra public methods not in the specification
    • not including either "public" or "private" for a method declaration
  • miscellaneous errors:
    • redundant code
    • unnecessarily inefficient code (e.g., constructing a new object on every iteration of a loop when it could have been constructed once before the loop)
    • not using interfaces when possible to refer to variables, parameters, and return values
    • not using generic types properly (e.g., manipulating a Stack versus a Stack<Integer>)
• Homework 1: LetterInventory
  • commenting errors:
    • class header missing or doesn't describe both student and program
    • method header missing or does not document return value and post-conditions
    • method header does not document important behavior including subtle cases like an empty structure or a search value not found
    • method header does not document exceptions thrown including the specific type of exception and the conditions under which it is thrown
    • blind copying of text from assignment writeup
  • readability errors:
    • bad indentation
    • some method does not have a blank line before it
  • control structure errors:
    • bad Boolean Zen
  • data structure errors:
    • extra data structures that aren't necessary
    • bad usage of arrays (e.g., funky/incorrect indexing/usage)
  • class design errors:
    • extraneous data fields
    • initializing non-final data fields outside of a constructor
    • non-private data fields

Java has grown to be a complex language with many features. We don't have time to teach all of these features in CSE143. We have a general rule that students should not use "advanced" material that we have not covered in class. In addition, we have identified several Java features that we do not want students to use. It is not bad style to use these features, but we want to have a level playing field for all students. For any one of these features, we prefer that either everyone in the class knows about it and can use it or nobody is allowed to use it. The following features should not be used in CSE143 homework or exam solutions:

• break, continue, return from a void method
• try/catch
• the <> operator
• Java 8 features (e.g., lambdas, streams, method references)
• toArray, Arrays.copyOf, clone
• StringBuilder, StringBuffer, StringJoiner, and String methods toCharArray, join, matches
• Arrays.asList, Arrays.copyOf, Arrays.copyOfRange, Arrays.sort
• Collections.copy, Collections.sort

Many students find themselves wondering, "What is that feature you are describing?" If you don't recognize it, then you're unlikely to use it, so the best answer is, "Something that we have decided not to teach you in this class so that we will be able to focus on the really important concepts you need to learn."