Usually developers spend more time on reading code rather than writing code. Consistency makes the code more readable.
Is it better to do things consistently wrongly than erratically well? Maybe not in life but when it comes to software. Here are my ratings:
:-D consistently well
:-) consistently wrongly
:-| erratically well
:-( erratically wrongly
Consistency wins.
Sometimes particular anti-pattern consistently infests whole application. There is no point in throwing bodies in refactoring it because the cost may be little compared to the gain. Anti-pattern may be well-known and in general not extremely harmful. Refactoring it in one place may seem decent but introduces inconsistency with all the other places. I value overall consistency over single-shot elegance.
There’s no rule without exception, right? Sometimes the goal is to implement something in completely different way, to implement an eye-opener, to create “the new way”. Then one could relay on distributed-refactoring spirit of the team and let others join refactoring feast. If the spirit evaporated :(, one could always make using “the old way” deliberately embarrassing or just frikin’ difficult.
Consistency rule helps in all those hesitations a developer has on daily basis. Ever felt like two-headed ogre from Warcraft?
“This way, no that way!” – the heads argue.
Yes, you can implement stuff in multiple ways… My advice is: know your codebase and be consistent. Choose the way that was already chosen.
Being consistent is important but not when it goes against The Common Sense. Obviously ;)
Which head should I slay?
I am leaning towards elegance… Why?
Refactoring will fix it if you favor something for it’s elegance. If you favor consistency – you DON’T have a choice.