C#

Refactoring away performance

Donald Knuth once said that "Premature optimization is the root of all evil (or at least most of it) in programming", something that the agile community advocates, and I myself agree with (for the most part).

The idea is that writing very fast tight code that performs amazingly well, but lacks readability, might be a waste of time. You might not need that amazing performance, or it could be that no matter how fast your code is the web service provider that it subscribes to or the database serving records is so slow that it doesn't really matter anyway. No, instead write readable, well designed and maintainable code. If you need to get more performance later then profile your software, find the slow bits and optimise them. After all, it's easier to optimise well structured easy to read code anyway.

This is all well and good, and most of the time is the right way to go. But I'm a little concerned that we might be building unnecessarily slow software. Take for example the refactoring technique "Replace temp with query". Replace temp with query states that this code:

string desc = MyObject.GetDescription ();

this.Text = desc;
AFileClass.SaveFile (desc);
AnoherClass.Description = desc;

should be replaced with:

this.Text = MyObject.GetDescription ();
AFileClass.SaveFile (MyObject.GetDescription ());
AnoherClass.Description = MyObject.GetDescription ();

So that rather than getting the description and storing it in a temporary variable we re-query the MyObject class each time.

This refactoring (as with some others) decreases performance and adds nothing to code readability. What is the cost to our application of a multitude of small performance degrading refactorings? Would we notice the drop in performance in our short code-deliver-test cycles? Or would we end up at the end of development with an application that just feels a bit sluggish?

If we did end up with an app that needed a performance boost it would be a long painful process to go through the code and remove all these small refactorings.

posted by Nick @ 10:40 pm