Effective Programming

Mercurial HG on the wiki

2010-07-25T10:03:00.004-05:00

I spent the better part of the morning reading about hg from Joel's tutorial. Check my notes if you're interested in a quick hg reference.

Worse Case time complexity for binary search

2010-06-27T23:56:00.001-05:00

If we represent the time complexity of Binary Search as

W(n) = W(ⁿ⁄₂) + 1.

Prove the following:

W(n) = floor(lg n) + 1

Spring MVC Walkthroughs

2010-03-09T19:02:00.003-06:00

2 must-have links for Spring MVC:

Configuration Is Not Inherently Evil

2010-03-06T16:07:00.002-06:00

Personally, it's not that I don't like configuration or xml files. It's more that I don't like complicated configuration.

Web Xml Order

2010-03-06T14:16:00.008-06:00

I sort-a-knew this but nice to see it down on paper.

Despite some developers stating that the order of elements in web.xml must follow an exact order, for the most part this is incorrect. However, some elements must be defined before others. Filter and filter-mapping are one such example …

I think this used to be the case pre the 2.x spec maybe?

Exception Handling for Exceptional Handling

2010-03-06T12:46:00.007-06:00

Found an interesting writeup on Exception Handling. I agree with their assertion

Exceptions should be thrown only when there is no meaningful way of handling the situation. If these situations (conditions) can be handled programmatically in a meaningful manner, then throwing exceptions should be avoided. For instance if it is possible to handle the problem of withdrawal amount exceeding the balance in some other way, it has to be chosen over throwing an application exception.

but am particularly confused with one of their contradictory examples elsewhere in the expose:

A rule of thumb is to model application exceptions as checked exceptions and system exceptions as unchecked exceptions. The code below is an example of application exception.
    if (withDrawalAmt > accountBalance)
    {
        throw new NotEnoughBalanceException(
        “Your account does not have enough balance”);
    }
When the account does not have enough balance for requested withdrawal amount, the user gets a NotEnoughBalanceException. The user can decide to withdraw lesser amount. Notice that the application exception is not logged. In case of the application exceptions, the developer explicitly throws them in the code and the intent is very clear.

A Versioning Strategy

2010-03-05T17:08:00.002-06:00

Jackson versioning follows guidelines similar to [the] ones Eclipse project uses, so that:

Major version upgrade indicates incompatible changes.
- You MUST recompile (and re-test) your application or service when upgrading to a new major version
- Major version upgrades occur rarely
Minor version upgrade indicates added functionality, but without removing existing functionality
- It is possible that observed behavior changes, but this should usually not cause compatibility problems
- Changes are binary compatible so it is possible -- although not recommended -- to just upgrade jar. Instead, you should recompile application, and re-test code that uses Jackson
Patch version upgrades are strictly for bug fixes, and no new functionality is added
- Only changes to observed behavior is to fix broken behavior
- Upgrade by swapping jars should work without problems

Basic JEE Web Config

2010-03-04T22:02:00.008-06:00

web.xml (2.4):

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" 
    version="2.4">
   …
</web-app>

FindBugs vs PMD

2010-02-27T21:50:00.004-06:00

This post nicely distinguishes FindBugs, PMD and a few other static code checkers.

Each of them is mainly targeting a certain type of coding rules : conventions (Checkstyle), bad practices (PMD) and potential bugs (FindBugs).

Where Is JAVA_HOME On A Mac?

2010-02-27T13:02:00.002-06:00

The Java homes on Macs are in the /System/Library/Frameworks/JavaVM.framework directory.

Or, if you prefer, try ~/Libary/Java/Home or reading this.

HSQLDB Settings

2010-02-27T12:09:00.007-06:00

The home page docs aren't exactly the latest (1.8.x) so I had to download the project to find the new argument style.

Now, to get help, try:

java -cp ${CLASSPATH} org.hsqldb.Server -?

And here's a sample startup script:

!/bin/sh

REPO=$HOME/.m2/repository
CP=$REPO/org/hsqldb/hsqldb/1.8.0.10/hsqldb-1.8.0.10.jar

java -cp $CP org.hsqldb.Server \
        -database.0 file:agenda.hsqldb \
        -dbname agenda

Maven JDK Settings

2010-02-27T09:38:00.005-06:00

This is always such a pain to remember so I'm shamelessly copying it here for future reference.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.0.2</version>
    <configuration>
        <source>1.5</source>
        <target>jsr14</target>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.0.2</version>
    <configuration>
        <source>1.5</source>
        <target>1.5</target>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.0.2</version>
    <configuration>
        <source>1.6</source>
        <target>1.6</target>
    </configuration>
</plugin>

How Much Fun Can Web Development Be?

2010-02-27T08:46:00.004-06:00

Tired of complicated Java web frameworks that just get in your way?

Yes.

Calcuating Percentiles

2010-02-01T10:38:00.005-06:00

A simple proof-of-concept to better understand how to calculate percentiles.

public class PercentileTest
{
    public static void main(final String[] args)
    {
        final int[] scores = { 40, 50, 50, 66, 67, 67, 68, 69, 73, 75, 79, 79,
                81, 82, 82, 88, 89, 93, 93, 93, 99, 100
        };

        int outerCounter = 0;
        int repeatingCounter = 0;
        int lastScore = -1;

        for (final int s : scores) {
            if (s != lastScore) {
                outerCounter = outerCounter + 1 + repeatingCounter;
                repeatingCounter = 0;
            } else {
                repeatingCounter = repeatingCounter + 1;
            }
            final float percentile = (float) outerCounter / scores.length * 100;
            System.out.println("Score: " + s + "\tPercentile: " + percentile);
            lastScore = s;
        }
    }
}

Method Name Guidelines

2010-01-23T11:17:00.016-06:00

As a general rule, do you prefer:

Account findAccount(String telephoneNumber);
Account findAccount(String company, String division, String accountNumber);

Account findAccountByTelephoneNumber(String telephoneNumber);
Account findAccountByCompanyAndDivisionAndAccountNumber(String company, 
                                                        String division, 
                                                        String accountNumber);

Take The Intellisense Challenge

2010-01-22T07:39:00.002-06:00

Try turning off intellisense for a day (or an hour) and realize how little (or much) you actually know!

What do these results imply?

2010-01-21T18:47:00.011-06:00

Response Time: 21801570 (iters=400000)
Exception Time: 281756916 (iters=400000)

// $Id$
package sandbox;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author Luther Baker
 */
public class ExceptionalPerformance
{
    private static final int ITERATIONS = 100000;

    public static class Response
    {
        public int code;
        public String message;

        public Response(final int code, final String message)
        {
            this.code = code;
            this.message = message;
        }
    }

    public static class TestException extends RuntimeException
    {
        private static final long serialVersionUID = 1L;

        // private final Response response;

        public int code;
        public String message;

        public TestException(final int code, final String message)
        {
            // response = new Response(code, message);
            this.code = code;
            this.message = message;
        }
    }

    public static void main(final String[] args)
    {
        // prime the pump
        final List list = new LinkedList();
        testResponse(list);
        testException(list);

        // time it
        final long start = System.nanoTime();
        testResponse(list);
        final long stop1 = System.nanoTime();
        testException(list);
        final long stop2 = System.nanoTime();

        // calculate it
        final long resTime = stop1 - start;
        final long excTime = stop2 - stop1;

        // make sure I use the results in an way 
        // such that methods are not optimized away
        final Iterator iter = list.iterator();
        int count = 0;
        while (iter.hasNext()) {
            iter.next();
            ++count;
        }

        // report it
        String res = resTime + " (iters=" + count + ")";
        System.out.println("Response Time:   " + res);
        String exc = excTime + " (iters=" + count + ")";
        System.out.println("Exception Time: " + exc);
    }

    public static void testResponse(final List list)
    {
        for (int i = 0; i < ITERATIONS; ++i) {
            final Response response = returnResponse(i);
            list.add(response.message);
        }
    }

    public static void testException(final List list)
    {
        for (int i = 0; i < ITERATIONS; ++i) {
            try {
                throwException(i);
            } catch (final TestException e) {
                // list.add(e.response.message);
                list.add(e.message);
            }
        }
    }

    public static Response returnResponse(final int id)
    {
        return new Response(id, "Message");
    }

    public static TestException throwException(final int id)
    {
        throw new TestException(id, "Message");
    }

}

Effective Exceptions

2010-01-20T18:51:00.001-06:00

Do you write code that throws Exceptions for expected events?

Did you do it because it made your your code cleaner or easier to understand?
How do you think Exceptions affect performance?
Is using Exceptions in a well-defined, expected scenario, abusing the Exception handling mechanism?

Guidelines - XSD Elements and Attributes

2010-01-20T10:10:00.000-06:00

What are your guidelines when defining an XML data model with respect to attributes and elements? Elements are arguably a bit more powerful - but can you specify a case where you'd prefer attributes?

The Case for Dependency Injection (Part 1)

2009-11-10T21:27:00.003-06:00

Let's begin by looking at this problem from 3 perspectives:

assumptions
decisions
scenarios

In any code you write you make certain assumptions. You also make certain decisions and your code runs in specific scenarios. Some common scenarios include localhost development, unit testing, nightly builds, manual testing, production, maintenance, integration testing, etc … while some decisions might include what to do, when and with whom to do it.

Let's take a look at some code from the original poster's question:

    Saw saw = new HandSaw();
    SawMill sawMill = new SawMill();
    sawMill.setSaw(saw);
    sawMill.run();

Assume that this code was compiled and running in production exactly as written. Can you construct a realistic scenario where this code block would present a problem?

The Case for Dependency Injection

2009-11-10T21:05:00.005-06:00

I noticed the following question on Stack Overflow and after about 5 minutes of drafting some ideas, I realized how complicated a good answer was.

Appreciating DI and IOR takes some perspective that I can't properly convey in a few paragraphs. Applying DI takes time. A good DI strategy can really be leveraged only when the larger family of problems it addresses is properly appreciated and understood.

How would you explain it?

Technical Docs

2009-11-06T21:48:00.000-06:00

How many times have you tried to outline or take technical notes only to lose them. Maybe github can help you too! Feel free to browse the wikis and offer suggestions.

Beautiful Graphs and Charts

2009-11-05T23:55:00.000-06:00

I recently came across this very good looking charting library. Not only are the results quite professional but many of them contain several interactive elements.

Justin Gets Sirius

2009-11-05T23:50:00.001-06:00

Nice article from Justin Williams as he redesigns the Sirius iPhone App and contemplates a UITabBarController-free Fitness Track 1.0.

YUI Does Reusable CSS

2009-11-05T23:46:00.000-06:00

+1 to the YUI team.

Their well-defined CSS library goes a long way to standardizing browser behavior and application structure.