Least surprise, least paranoia

Imagine a software system where there is no need for you to spend your time programming defensively; your objects will be used responsibly, and your methods will always be passed sensible arguments.

This low-friction utopia can be approached by establishing some simple programming rules so that every class acts as a 'good citizen' in the society of classes collaborating at runtime.

This page outlines some rules that we, and others, believe lead to good citizenship. All are aimed at improving clarity, reducing surprise, and promoting basic consistency.

As a good citizen, I...

Keep a consistent state at all times - init() or populate() is a code smell.

Have no static fields or methods

Never expect or return null.

FailFast - even when constructing.

Am Easy to test- all dependent object I use can be passed to me, often in my constructor (typically as Mock Objects).

Accept dependent object that can easily be substituted with Mock Objects (I don't use Concrete Class Dependency).

Chain multiple constructors to a common place (using this(...)).

Always define hashCode() alongside equals()

Prefer immutable value objects that I can easily throw away.

Have a special value for 'nothing' - e.g. Collections.EMPTY_SET.

Raise checked exceptions when the caller asked for something unreasonable - e.g. open a non-existant file.

Raise unchecked exceptions when I can't do something reasonable that the caller asked of me - e.g. disk error when reading from an opened file.

Only catch exceptions that can be handled fully.

Only log information that someone needs to see.

Classes that are designed for Constructor Injection are better citizens than those that are not.