I must confess, I've realized that TDD is a must have
in a project. Though I don't even like TDD, right now there's no
better way of developing software. Writing software is like solving a
perverted salesman traveling problem where the destination keeps
changing and somehow the paths you took start to make less sense as the software progress. To
know if you ended up with the best solution, you'd have to build all
different versions of the problem to know if that's the best way of
doing it, and that's not a viable idea.
Given that you have different developers with
different backgrounds you must have something they know that somebody
else is producing something accordingly something they know will have
the same structure and background. And you'll have to keep doing it
throughout the project and if you stray off the methodology you'll
end up with inconsistencies in your code. And really in a project, you don't want to spend too much time (or any) discussing technical details related to pure code.
What I don't like with TDD
One important aspect of TDD is that I think TDD gets
credit for is things which is TDD cannot solve. One thing is that it
somehow creates layers, and this I think is deducted from the fact
that TDD help with creating better abstractions, and that is a
feature which is really nice with TDD, but it's really a side effect
of practicing TDD. And it's not really TDD's fault for not being able
to build layers because abstractions cannot be totally abstract,
because if they could, that would mean that you could send in any
data (or none) and get something which is exactly the data you want,
which would be an impossible thing to do. There's only one thing that
could pull that off, and I doubt that it actually exist, although
there are many believers out there.
Also TDD does different thing to different languages
so you get more from TDD in certain languages where others benefits
less of it (one could argue that those languages which needs more TDD
practices are bad languages).
TDD will influence your code and therefore your
solution, and this will inevitably to “test induced design damage”.
This means, as Conway's law states, your code will be tainted by TDD
and code written with TDD in mind will be easier to integrate in a
TDD project. That also means that code which is NOT written according
to TDD will be a hard to fit in a TDD project (and no it's not about
framework's abilities to be integrated). That also means that trying
to use TDD in a project which is not started as a TDD project, will
be very hard to start using the TDD practice. Most of the time, TDD
projects are not being consistent and this will hurt you in the end.
Also I think TDD is showing that your language is
failing describing what you really want, and you need to rely on
something external to somehow verify that you have written something
which is correct accordingly to your understanding. Instead of having
TDD as some sort of “document”, I'd rather have the power of have
all those assertions expressed by the code. I usually consider tests
which are large a code smell since they give away that the code
either does too many things or the code is not expressing enough
intention or is not powerful enough.
But most importantly TDD creates some sort of focus
on tests and unit tests, where TDD is not about those. It's about
dealing with information and always confirming to that information
and the test case is about verifying this, an sort of implementation
of the TDD abstraction, but also we should be able to get rid of it.
If one consider that TDD is language and tech
agnostic, meaning we need TDD to have a framework to actually deliver
working code, the amount of work needed to verify your code should
say something about the chosen language. If the language requires a
lot of test cases to verify that you did something you intended to do
would mean that that language is a poor choice. I'm not going to
point on specific languages here and I leave this to some future
discussion.
I really hope that we one day can get rid of TDD, but
as for now, there are simply no better ways to write software.
