• You will probably not agree
• That is ok...
• ...hopefully you still take away something
• This is a motivation to consider cleaner coding practices and turn them into law

There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.

C.A.R. Hoare, The 1980 ACM Turing Award Lecture

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Martin Fowler

If you are proud on the fact, that nobody gets your code despite the code being correct, you are working for the wrong company.

René Schwietzke

/**
 * The Intershop and Demandware Style
 *
 * Lookup the key in the map, returns the value if found, null otherwise.
 * Will throw an IllegalArgumentException when null is passed as key.
 *
 * @param k the key to look up in the map
 *
 * @return the value found or null otherwise
 */
@Override
public V get(final K key) throws IllegalArgumentException
{
    // prevent null from being used
    if (key == null)
    {
        throw new IllegalArgumentException("Get doesn't support null keys");
    }

    // where is our entry located
    final int pos = calculatePosition(key);

    // get the entry
    final Entry<K, V> entry = getEntry(key, pos);
    if (entry == null)
    {
        // does not exist
        return null;
    }
    else
    {
        // we know it, return value
        return entry.value;
    }
}

• It is not your code! It is our code!

• I don't need comments.
• It was hard work for me, why should it be easier for others?
• Smart people can read code without comments.

Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.

Rick Osborne

/**
 * Hash table based implementation of the <tt>Map</tt> interface.  This
 * implementation provides all of the optional map operations, and permits
 * <tt>null</tt> values and the <tt>null</tt> key.  (The <tt>HashMap</tt>
 * class is roughly equivalent to <tt>Hashtable</tt>, except that it is
 * unsynchronized and permits nulls.)  This class makes no guarantees as to
 * the order of the map; in particular, it does not guarantee that the order
 * will remain constant over time.
 *
 * <p>This implementation provides constant-time performance for the basic
 * operations (<tt>get</tt> and <tt>put</tt>), assuming the hash function
 * disperses the elements properly among the buckets.  Iteration over
 * collection views requires time proportional to the "capacity" of the
 * <tt>HashMap</tt> instance (the number of buckets) plus its size (the number
 * of key-value mappings).  Thus, it's very important not to set the initial
 * capacity too high (or the load factor too low) if iteration performance is
 * important.
 *
 * <p>An instance of <tt>HashMap</tt> has two parameters that affect its
 * performance: <i>initial capacity</i> and <i>load factor</i>.  The
 * <i>capacity</i> is the number of buckets in the hash table, and the initial
 * capacity is simply the capacity at the time the hash table is created.  The
 * <i>load factor</i> is a measure of how full the hash table is allowed to
 * get before its capacity is automatically increased.  When the number of
 * entries in the hash table exceeds the product of the load factor and the
 * current capacity, the hash table is <i>rehashed</i> (that is, internal data
 * structures are rebuilt) so that the hash table has approximately twice the
 * number of buckets.

 * <p>As a general rule, the default load factor (.75) offers a good
 * tradeoff between time and space costs.  Higher values decrease the
 * space overhead but increase the lookup cost (reflected in most of
 * the operations of the <tt>HashMap</tt> class, including
 * <tt>get</tt> and <tt>put</tt>).  The expected number of entries in
 * the map and its load factor should be taken into account when
 * setting its initial capacity, so as to minimize the number of
 * rehash operations.  If the initial capacity is greater than the
 * maximum number of entries divided by the load factor, no rehash
 * operations will ever occur.
 *
 * <p>If many mappings are to be stored in a <tt>HashMap</tt>
 * instance, creating it with a sufficiently large capacity will allow
 * the mappings to be stored more efficiently than letting it perform
 * automatic rehashing as needed to grow the table.  Note that using
 * many keys with the same {@code hashCode()} is a sure way to slow
 * down performance of any hash table. To ameliorate impact, when keys
 * are {@link Comparable}, this class may use comparison order among
 * keys to help break ties. ...

/**
 * Processes an uri and replace an encoded space (+) by %20.
 * There is no error handling defined, make sure you don't pass
 * null.
 *
 * This method is thread-safe and stateless.
 *
 * @param uri
 *            the uri as String to process, null is not permitted
 * @return a new uri as String with all spaces being encoded as %20
 *         instead of +
 */
public static String fixUrlSpaceEncoding(final String uri)
{
    // determine ?
    final int pos = uri.indexOf("?");
    if (pos < 0)
    {
        // nothing to do
        return uri;
    }

    // get the data before and after the ? pos, keep the ?
    final String path = uri.substring(0, pos);
    final String query = uri.substring(pos);

    // we assume that some replacements have to be made and hence ask
    // for a little more space (+16) already to avoid that the buffer grows
    // that is ok for our cases right now, because we mostly have only
    // 1-4 spaces in it, if you encounter more, you can start with more overhead
    // to keep it overall efficient
    final StringBuilder sb = new StringBuilder(uri.length() + 16).append(path);

    for (int i = 0; i < query.length(); i++)
    {
        final char c = query.charAt(i);

        // replace + with %20
        if (c == '+')
        {
            sb.append("%20");
        }
        else
        {
            sb.append(c);
        }
    }

    return sb.toString();
}

public boolean doIt(String s)
{
    // empty s cannot be processed, sort things out early
    if (s == null || s.length() == 0)
    {
        return false;
    }

    // That is BAD code here
    if (s.length() == 3 &&
            !"foo".equals(s) &&
            !("bar".equals(s) || "rab".equals(s)))
    {
        return false;
    }

    // final result (too obscure)
    return s.split(",").length() > 3 ?
                return true :
                s.split(";").length() < 3;
}

# Uncomment to disable the processing, it is enabled by default
# myapplication.processing.disable = true

/**
 * Horrible example
 */
public void test(final boolean disabled)
{
    if (!disabled)
    {
        // do stuff here
    }

    if (isEnabled())
    {
        setEnabled(disabled);
    }
}

/**
 * Remove all entries from the list
 *
 * But why purge, all of Java says clear()?!
 */
public void purge()
{
    final boolean globalState = getGlobalState();
    final String organisationName = getName();

    for (final char c : organisationName.toCharArray())
    {
        // more here
    }
}

// parameters and overloading
public void removeCarsFromStreet(final Street street)
public void removeCarsFromStreet(
                final Street street, final Car carType)
public void removeCarsFromStreetByType(
                final Street street, final Car carType)

public V getFromMap(final K key); // JDK says get()
public void put(List<V> list); // JDK says putAll or addAll!

public final static int NUMBER = 42; // I am a constant

public final static String DEFAULT_NAME = "Maria"; // So do I

/**
 * Demo
 */
public boolean demo(final String s)
{
    // ...

    // Comment and replaced with enhanced for, because it is
    // more compact code (FOO-987654)
    // for (int i = 0; i < s.length(); i++)
    // {
    //    final char c = s.charAt(i);
    //    if (c != ' ')
    //    {
    //        result.add(c);
    //    }
    // }

    for (final char c : s.toCharArray())
    {
        if (c != ' ')
        {
            result.add(c);
        }
    }

    // ...
}

public void test()
{
    try(InputStream is = new FileInputStream(new File("f.txt")))
    {
        int i = is.read();
    }
    catch (final FileNotFoundException e)
    {
        // do your stuff here
        // try to avoid other exceptions
    }
    catch (final IOException e)
    {
        // do your stuff here
        // try to avoid other exceptions
    }
    finally
    {
        // in case something is left to do after all that
        // trouble
    }
}

/**
 * Fill the battery if needed
 */
public void fillUpOfNeeded()
{
    if (getGlobal() < 42)
    {
        recharge();
    }
    else
    {
        // we don't need to recharge, we still have
        // enough juice
    }
}

public void test()
public void test(boolean a, String b)
public void test(boolean a, String b, String c)
public void test(String b, String c, String d, boolean a)

public void split(
                String line,
                char delimiter,
                boolean quotesPermitted)

public void limitedScope(final String s)
{
    // dont't do that
    char c;

    // make things final if possible
    final StringBuilder sb = new StringBuilder();

    for (int i = 0; i < s.length(); i++)
    {
        c = s.charAt(i);
        sb.append(c);
    }

    ...
}

public class DiceCup
{
    // list of dice to use
    private final List<Dice> dice = new ArrayList<>();

    /**
     * Constructor, takes a list of dice to be used
     */
    public DiceCup(final List<Dice> dice)
    {
        this.dice.addAll(dice);
    }

    /**
     * Rolls all dice
     */
    public List<Dice> roll()
    {
        for (final Dice d : dice)
        {
            d.roll();
        }

        // keep a copy for returning
        final List<Dice> result = new ArrayList<>(dice);

        // empty out cup
        dice.clear();

        // return result
        return result;
    }
}

public void test()
{
    try(
        InputStream  is = new FileInputStream(new File("foo.txt"));
        OutputStream os = new OutputStream(new File("bar.txt"));
        )
    {
        // your I/O code here
    }
    catch (final FileNotFoundException e)
    {
        // do special stuff for the exception case
    }
    // This is the virtual finally block.
    // Java will auto-close "os" first
    // "is" last
}

public void test()
{
    final List<Person> persons = persons.stream().filter(p -> {
        if (p.getGender() == Gender.MALE)
        {
            return true;
        }

        LocalDate now = LocalDate.now();
        Duration age = Duration.between(p.getBirthDate(), now);
        Duration adult = Duration.of(18, ChronoUnit.YEARS);

        if (age.compareTo(adult) > 0)
        {
            return true;
        }

        return false;
    }).map(p -> p.getFirstName() + " " + p.getLastName())
      .collect(Collectors.toList());
 }

/**
 * This method sorts incoming data and is using up the max
 * number of available CPU cores to be quick. The threads will
 * be automatically started and stopped.
 *
 * Tests have shown that is scales well up to 10 cpus and any
 * further CPU core up to 20 contribute about 80% more of the
 * theoretical limit. Beyond that, more cpus don't contribute
 * anything.
 * No tests with more than 40 cpus have been performed.
 */
public SomeStream sort(SomeStream inputData)
{
}

• If there is anything you can't know yet, explain how you handle the worst case
• No runtime errors due to proper testing
• Errors are logged and explained
• Known error states are handled correctly and not logged

• Be aware what resources are sparse: CPU, memory, disk...
• Measure under production condition and not on a single notebook

• White box next
• Check for assumptions made
• Check for hardcoded values
• Check for behavior that is not documented
• Check for all potential error conditions
• Check for state information
• Check for OS dependencies
• Check for multi-threading requirements

• If we touched the area, we should almost never have less tests, almost more
• Check changes of existing tests, because it might have broken the freeze-promise