A few days ago we discussed Object Calisthenics which where introduced by Jeff Bay in an article for the ThoughtWorks Anthology book. In case you have no idea what I’m talking about, here are again the 9 rules in short form (or your can study them in detail in the book):
1. One level of indentation per method
2. No else keyword
3. Wrap all primitives and strings
4. Use only one dot per line
5. Don’t abbreviate names but keep them short
6. Keep all entities small
7. No more than two instance variables per class
8. Use first-class collections
9. Don’t use any getters/setters or properties
Following the rules supposedly leads to more object-oriented code with a special emphasis on encapsulation. In his article, Jeff Bay suggests to do a new 1000 lines project and to follow the rules excessively without thinking twice. But hey, more object-oriented code can’t be bad for existing projects, either, can it?
Not only on the first look, many of the rules seem pretty hard to follow. For example, check your projects for compatibility with rule 7. How many of your classes have more than two instance variables? That’s what I thought. And sure, some primitives and collections deserve wrapping them into an extra class (rules 3 and 8), but do you really wrap all of them? Well, neither do we.
Other rules lead directly to more readable code. If you value good code quality like we do, rules 1, 2, 5 and 6 are more or less already in the back of your head during your daily programming work.
Especially rule 1 is what you automatically aim for when you want your crap load to remain low.
What really got my attention was rule 9: “Don’t use any getters/setters or properties”. This is the “most object-oriented” rule because it targets the heart of what an object should be: a combination of data and the behavior that uses the data.
But doing a little mental code browsing through our projects, it was easy to see that this rule is not easily retrofitted into an existing code base. The fact that our code is generally well covered with automated tests and considered awesome by a number of software metrics tools does not change that, either. Which is, of course, not surprising since committing to rule 9 is a downright big architectural decision.
So despite the fact that it is difficult to virtually impossible to use the rules in our existing projects right away, Object Calisthenics were certainly very valuable as motivation to constantly improving ourselves and our code. A good example is rule 2 (“No else”) which gets even more attention from now on. And there are definitely one or two primitives and collections that get their own class during the next refactoring.
3 thoughts on “Object Calisthenics On Existing Projects?”
Seems to me that 9 prevents me from separating UI from the model.
Suppose you want to create a human readable string for a book. A book has a name, chapters, one or more authors, a publisher and a publishedDate. Of course, these 4 properties are wrapped into other classes (doesn’t make it easier understanding, but that’s the rule).
Now try to create a label that says something like
Book Name (published on 1999-10-2 by PUBLISHER), 12 chapters; Author1, Author2
In the absense of getters you’ll end up with some visitor structure, but unluckily, there is (should be) no explicit order in that your visitor will see data. So you’ll end up replicating the data structure in the visitor.
I tried it. Don’t see how rule 9 improves anything. It does produce a lot of unreadable crap, though (although I suppose your metrics would be happy with it).