Great point, my mistake. Title and headline updated (was: Good code has few unit tests). I really wish it were "duh", but measuring code quality by "unit tests per line" [1] is frighteningly common, and seductive in its simplicity and intuition.
1. Not necessarily directly. It might be in the form of "I'll add more unit tests to improve this code" (unit tests either cover an interface or they don't; going in to 'add more unit tests' to 'improve' code means you didn't define a clear enough interface to begin with). Or "our open source project has more unit tests than another" (but I won't point fingers).
The easiest way to bump your unit-tests-per-line metric is to delete lines of code. That's a positive thing, in my book.
If you're writing something simple, abstractions are probably just extra typing.
If you're building something that actually has multiple parts, those parts should be abstracted from each other.
Pulling an example out of thin air, shorter total code:
var counter = 0;
function foo() {
log("Incremented");
counter++;
}
function bar() {
log("Incremented");
counter++;
}
Code with an abstraction which makes foo and bar shorter: var counter = 0;
function increment() {
log("Incremented");
counter++;
}
function foo() {
increment();
}
function bar() {
increment();
}
Even longer code, but which encapsulates the counter variable, possibly making it easier to reason about: var Counter = (function ()
{
var counter = 0;
return {
increment : function() {
log("Incremented");
counter++;
},
current : function() {
return counter;
}
};
});
function foo() {
Counter.increment();
}
function bar() {
Counter.increment();
}There are a surprisingly large number of programmers who learn "Oh yay, I can use abstractions to simplify this bit of code" and then turn that into "I think I'll make abstractions out of every bit of code". I was once one of them. In the process, they turn something that could've been a simple program, one that you could fit into your head, into an Enterprise Behemoth that you can't modify without implementing a half dozen interfaces and touching 30 files.
There's a cost to abstraction - it's (usually) extra code, it makes it harder to follow the logic of the program, and it makes your program less flexible in directions other than the intended use. So don't do it unless it actually gains you something in simpler code. Programs can become spaghetti-like through IFactoryFactories just as easily as they can become spaghetti-like through switch statements.
Also on Hacker News at the moment and fairly relevant:
http://coderoom.wordpress.com/2010/03/19/5-stages-of-program...
But. If you've defined nice clean interfaces, and a particular module has complex behavior that will have to evolve over time, then adding tests to certify that that behavior is correct shouldn't be too much of a chore -- and they save your bacon when you need to change it and track any regressions afterwards.
Which is basically isomorphic to "good code is tight code". Duh.