Saturday, 1 October 2011

The Best Code is Written Twice

Recently myself and two colleges completed a new feature in an afternoon's programming session. Despite this we ended up binning the feature after all agreeing it was horribly complicated and in turn would cause far more problems down the road than it would solve.

We decided to rewrite the feature again, but applying all the lessons we had learned from the first attempt. A recent blog post by royvanrijn on this very topic made me appreciate what we had done. He points out that the best code occurs from several attempts, and unlike what people may expect, the repeat attempts need not take the same amount of time to deliver as the initial attempt.

The second time you write the code, it'll only take a fraction of the time it took initially.

This principle of repeating a task made me think of when I was decorating my old bedroom. I helped partake in the difficult task of wallpapering the ceiling. Prior to this I had experience wallpapering before, and would have no trouble repeating this exercise again. However, wallpapering a ceiling was something completely new. Me and my dad were reluctant to start, until I had a rather devious plan. We would decorate my brothers room first, followed by mine. That way, if our first attempt was a disaster I would not be the one living with the dodgy ceiling.

It turned out that our first efforts were not too bad. Granted it took a while, there was the odd rough patch and several obscenities were used, but we got the job done. For the second room we completed the task much quicker and with practically no problems.

The process of wallpapering the second ceiling was the DIY equivalent of scrapping our feature and rewriting the code. We never stripped the first ceiling afterwards, we just took everything we learned from the first round and used it to make the process of papering the second ceiling much easier. The interesting point to bare in mind with scrapping code and rewriting is the rewrite will not take the same amount of time to get back up to speed. Just because it takes n to implement a feature, the second time around you can often complete the feature in less time, at much higher quality.

I'm not suggesting all code should be rewritten multiple times. Spike solutions are often a more suitable process to ease the development process, but in certain cases practice makes perfect, even if it means you wait that little bit longer for the perfect ceiling.

Smalltalk Conversion mapped to C#

Lately the team has been making some rather drastic changes and re-designs to our codebase in an attempt to minimise friction to change. In other words, we've identified areas that are painful or tedious to work in and have hopefully rectified them by re-writing the code. The proof of this should be felt as we begin adding new features, the newly improved code is certainly faster and more optimised.

Regardless, one area that remains troublesome in my opinion is object mapping (or the correct term of conversion) code. While I've not personally been involved with this reworking of the codebase, I have recently just finished reading Kent Beck's - Smalltalk Best Practice Patterns. Many of the developers I follow on Twitter have been blogging about this book and I figured it was time to give it a go. After all it gets massive praise whether or not you use Smalltalk. While reading this book a few key points regarding object conversion are discussed and I found them incredibly relevant.

So should you read the book? I would say yes. I don't program in Smalltalk. I don't plan on programming Smalltalk. Nor had I read a line of Smalltalk before. But you should still read this book. The first half is incredibly relevant to any OO programming language. Granted I found the second half is less useful, but the gems I've picked up in the first half more than make up for this. In fact, pages 28 to 30 are so good I figured it would be worth sharing.

I've been convinced for a while that creating separate objects to convert objects is unnecessary, and in fact adds to the amount of code you need to write and maintain, thus increasing resistance for change. So if we remove this unecesary, intermediate object, how do we create a new object from another object? The answer is conversion. This answer strangely comes from a book all about Smalltalk. The answer also strangely comes from a book over ten years old. Pages 28 - 30 cover the topic of conversion. The following is quoted heavily from the book, but I recommend reading the pages in full.


Question - How do you convert information from one object's format to another's?
Answer - Convert from one object to another rather than overwhelm any one object's protocol.

What this is getting at is we could using C# extension methods do the following to the String class.

This would be abusing the String class. If we want a postcode from a string, we should have the Postcode object create us a Postcode from a string, not the other way around. There could be hundreds of conversions from strings to a new object, but we would violate the string class if we did this. In turn, Kent goes on to say "Conversions that return similar responsibilities should use a Convert Method. To convert to an object with different protocol use a Converter Constructor Method".

Converter Method

Question - How do you represent simple conversion of an object to another object with the same protocol but different format?
Answer - Provide a method in the object to be converted that converts to the new object. Name the method by pre-appending "as" to the class of the object returned.

In C# this would be:

In C# the convention is to use To rather than As for converter methods. For example we could do quotes.ToArray() on a List of Quotes. We still have the same protocol, a collection of quotes, we are just storing them in a different format. The rule for adding such methods is that there should only be one sensible way to perform this conversion, and the source and destination share the same protocol.

Converter Constructor Method

Question - How do you represent the conversion of an object to another with different protocol?
Answer - Make a constructor method that takes the object to be converted as an argument

In our codebase we have a RegistrationDate object. We have a constructor that takes a string representation of the date (from the outside world) and constructs a RegistrationDate . This very same principle can be applied to other, more complex objects. For example consider an active record style approach below. Here QuoteRecord represents our database object, with Quote representing a domain object. The following would be the converter constructor method. In other words, we create (or convert) our quote from the quote record. No separate mapper. No intermediate object. Less resistance for change.

The benefit here is that we have minimised friction. If the requirements for this code changes we will need up to update at worst, the record and the domain object. Had we used a separate object to perform the mapping we would end up with a third place to maintain if we decided to add a new property to our QuoteRecord.

I'll admit to having only used this technique for a week or so, though so far it has worked a treat and I expect it to continue working considering these techniques have stood the test of time.