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.
- Homework 7: Huffman
- Homework 6: 20 Questions
- class design errors:
- 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 unless to produce one line of output with printf
- poor choice of constructor (e.g., setting fields immediately
after construction when they could have been set by using a
different constructor)
- Homework 5: Anagram Solver
- Homework 4: Grammar Solver
- control structure errors:
- method errors:
- Homework 3: Assassin
- commenting errors:
- method header does not describe the purpose of each parameter or
does not describe the meaning of the return value of a non-void
method
- commenting on a specific client of the class
(e.g. AssassinMain)
- readability errors:
- control structure errors:
- method errors:
- miscellaneous errors:
- Homework 2: Guitar Hero
- commenting errors:
- implementation details included in comments for a class or its
public methods
- readability errors:
- method errors:
- class design errors:
- miscellaneous errors:
- Homework 1: LetterInventory
-
commenting errors:
- class header missing or doesn't describe both student and
program
- method header missing or does not document pre and post-conditions
- method header does not describe exceptions that are thrown when
preconditions are violated, including the specific type of
exception and the conditions under which it is thrown
- method header does not document important behavior including
subtle cases like an empty structure or a search value not
found
- blind copying of text from assignment writeup
-
readability errors:
- bad indentation
- some method or constructor does not have a blank line before
it
-
control structure errors:
-
data structure errors:
-
extra data structures that aren't necessary
-
bad usage of arrays (e.g., funky/incorrect indexing/usage)
-
class design errors:
-
miscellaneous errors:
-
using a specific numerical value when the value can be obtained in
a more general way (e.g., even if an array called data is expected
to be of length 100, code to manipulate it after construction
should use data.length instead of 100)
-
performing unnecessarily inefficient operations eg. looping when not required
note: "e.g." should be read as "for example" and "i.e." should be read as "in
other words"
In general, once a class has been discussed, it is available for use by
students. For example, the String class and the Arrays class were covered in
the CSE142 course, so it is reasonable to assume that you can use methods
from those classes without asking permission. Student should realize,
however, that saying that you are not forbidden from using a certain
construct is not the same thing as saying that it is a good idea to use a
certain construct. We don't give advice to students about which constructs
to use. You have to use your best judgement to decide and you might lose
style points if you make a poor choice. In addition, there are some
constructs that you are not allowed to use, as described in the next
paragraph.
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, annotations
- Java 8 features (e.g., lambdas, streams, method references)
- toArray, clone
- StringBuilder, StringBuffer, StringJoiner, StringTokenizer, and String
methods toCharArray, join, matches
- Arrays.asList, Arrays.copyOf, Arrays.copyOfRange, Arrays.sort
- Collections.copy, Collections.sort
- package declarations
- System.console()
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."