Invert your logic part 2: For loops and while loops

I'm not sure how many people I've convinced or not convinced in my previous post about inverting your logic (I don't really think this is a good term, but so far I don't have a better one). The comments that were left lead me to believe I wasn't 100% successful in my quest.

It may have been that my example was too limited. I don't just apply this style to a single method, but every block of code I write.

Here's a real code sample from my Parallel Web Spider project. In the first version of the code, there was only one pre-condition test that checked to see if the link depth was too great.

Since posting the code early this week, I have made some minor updates to it, including the two extra condition checks you see below that prevent the spider from following binary content and URL protocols that aren't supported.

Here's the code:

...
while (processed != toDo) {
        // get result
        try {
            future = service.take();
            processed++;
            links = future.get();
        } catch (Exception e) {
            e.printStackTrace();
            continue;
        }
   
        // process result
        System.out.println("Processing " + links.size() + " link results.");
        for (PageLink link : links) {
            if (link.getDepth() >= config.getMaxDepth()) {
                continue;
            }
       
            // don't follow binary content links
            if (link.getUrl().endsWith(".pdf") ||
                link.getUrl().endsWith(".gz") ||
                link.getUrl().endsWith(".tgz") ||
                link.getUrl().endsWith(".zip") ||
                link.getUrl().endsWith(".doc") ||
                link.getUrl().endsWith(".ppt")) {
                continue;
            }
       
            // we're only going to support http and file for now
            if (!link.getUrl().startsWith("http") &&
                !link.getUrl().startsWith("file")) {
                continue;
            }

            submit(service, link.getDepth(), link.getUrl());
        }
    }

The style I am suggesting doesn't just apply to methods, it's for any form of a block.

The benefits to writing code in this stlye are

• loose coupling - blocks are not dependent. You can add/subtract sections of code without having to worry about the surrounding logic
  
• linear flow - mentally, it's easier to grok links in a chain because they require small, focused amounts of brain power. A stack (nested code blocks) requires you to keep state, so the brain power required is additive for each level of nesting you introduce.

Finally, extra credit if you noticed one more application of the same style -- the try/catch block. Notice how much more cleanly I can handle the Exceptions thrown by the take() and get() methods by judiciously using a continue. If I had left the continue out, I would have had to handle the exception way down in the code, nearly 60 lines away.