Dynamacism

The Pragmatic Programmer contains the outstanding piece of advice that you should learn a new language every year. It not only gives you more tools to apply to problems, but it encourages you to think in different idioms. Every language has its own set of patterns and styles (the original Kernighan and Ritchie book on C, known affectionately as the "K&R" book) was as much about how C should look as what it did. People still talk about the "K&R style"; they defined the idioms of C along with the language. Learning new idioms and styles makes you a better developer, thus the efficacy of the Prags advice.

Here's a recent example that I perpetrated. After a stint in .NET and Ruby on Rails, I'm back on a Java project for a while (and coding again in my beloved IntelliJ, even if it is on Windows). I ran across some code that caused my refactoring alarm to go off. Here's a snippet:

  
public void record(String toBeRecorded) {
    MessageWriter messageWriter = null;
    try {
        messageWriter = new MessageWriter(_destination);
        messageWriter.write(toBeRecorded);
    } catch (RuntimeException rx) {
        throw rx;
    } finally {
        if (messageWriter != null)
            messageWriter.close();
    }
}
public void record(List<String> listToBeRecorded) {
    MessageWriter messageWriter = null;
    try {
        messageWriter = new MessageWriter(_destination);
        for (String s : listToBeRecorded)
            messageWriter.write(s);
    } catch (RuntimeException rx) {
        throw new RuntimeException("Cannot write list of messages");
    } finally {
        if (messageWriter != null)
            messageWriter.close();
    }
}

This is an overloaded method that does basically the same stuff before and after the important stuff (writing a single message or a list). Because I've been in languages with closures for a while, I refactored it thusly:

public void record(final String toBeRecorded) {
    recordMessage(new Runnable() {
        public void run() {
            _messageWriter.write(toBeRecorded);
        }   
    });                                                   
}
public void record(final List<String> listToBeRecorded) {
    recordMessage(new Runnable() {
        public void run() {
            for (String s : listToBeRecorded)
                _messageWriter.write(s);
        }
    });
}
private void recordMessage(Runnable recordingStrategy) {
    try {
        _messageWriter = new MessageWriter(_destination);
        recordingStrategy.run();
    } catch (RuntimeException rx) {
        throw new RuntimeException("Cannot write list of messages");
    } finally {
        if (_messageWriter != null)
            _messageWriter.close();
    }
}

This is basically just the Command Design Pattern. But before I was using closures on a daily basis, I never would have thought to implement it this way. I would have created some additional classes in their own files, created a formal implementation of the Command pattern, and a lot of other excessive ritual. Of course, if this got much more complex, it might need that ritual but, in this case, I was able to consoliate all that open and close code in a single place (which made things DRYer as well).