Thanks for a very enlightened and may i say courageous post! I work for a small Java shop doing XP development and have personally witnessed many of the problems that your post mentions in our code base.

TDD is a major tenet in our process and it has served us very well over the years. However it seems that over time the drive to split the code upfront into easily testable chunks has produced areas with particularly low coherence, with things only getting worse over time.

This has actually become a problem with a large visibility in the company to the point that even the business people in the company now understand what “low coherence” means!

Personally I find this code with low coherence can sometimes be much harder to refactor in a meaningful way, especially if the refactoring is not of some relatively trivial kind (e.g. I am doing an architectural enhancement, even a very minor one.). In these situations I sometimes (but not always) find myself having little option but to turf all the old code together with all the unit tests because of how badly and counter-intuitively things are split-up.

Thanks again for the post, I am planning on using it to further shed some light on our cohesion problem in front of the business people in my company.

With that said, the benefits of TDD far outweigh the problems it can introduce, at least for our company. It would be great if the discussion this post has started crystallizes some way of evolving TDD to avoid the low cohesion/ravioli code pitfall. The way it is currently used out there is just too easy to get wrong IMHO.

Your use of Goebbels, even in passing, invokes Godwin’s Law. Any valid points that you may have made in your post are completely overshadowed by this.

I believe you have successfully demonstrated your inability to respectfully disagree and be civil to others in a public forum. If you wish to continue this behavior, I ask that do you do so on your own blog, and use its trackback/pingback system, instead of abusing the commenting privilege I have extended to you and the public-at-large.

Amr Elssamadisy, for example, shows the ability to disagree in a civil manner, and even goes to far as to make a blog entry of his own in relation to the disagreement:

http://www.infoq.com/news/2007/07/AgileBadForDesign

I hope that you will have the common courtesy and self-restraint necessary to act as a good guest on this blog; if not, I will attempt, at my discretion, various measures to prevent and/or remove any further inappropriate comments from you.

“Noel, if you want to find some dogmatists, maybe you should look at those who responded to this post.”

Whom do you mean? I see several people who have pointed out – perfectly politely and quite correctly – that Paul seems to misunderstand some of the ideas behind TDD.

That’s OK. Nobody should ever be attacked for not knowing something. Everybody should be encouraged to ask questions. At the same time you ought not to snipe at things which you do not understand simply because you don’t understand them. There’s too much of this in php (usually in OOP v procedural debates). What really bothers me is that this is harmful for those who are trying to learn and don’t yet know enough to see through it. I wouldn’t like anyone to go away from this thinking that TDD is an over-hyped dogma.

It’s all a bit Goebbells isn’t it? Making up non-existent threats, lashing out at people who challenge the.. er.. dogma about the dogma. I guess we can call that the metadogma.

It sounds like a reasonable thing to say. “I hate dogma!” “Yeah me too!” “Let’s get them!” Nobody is going to stand up and say well actually I quite like dogma and could I have some unfounded accusations to go with that please? In fact it’s completely meaningless. Lips are moving, words are coming out, but no information is actually being processed. There never were any dogmatists to begin with and it was simply dishonest to claim there were.

In the world of php I can think of only a tiny handful of people who give talks, write articles or answer forum posts about TDD. None of them are what I would call dogmatists. They are all people I admire because of the effort they put into helping others learn.

When I first saw the blog entry I thought: great! Something about testing; this should be interesting. I wish I’d been able to talk about that instead of the metadogma but, as Hamish McStalker has correctly pointed out you can sometimes find me dogmatically answering testing questions on sitepoint.com under the name of McGruff – when I’m not being rude about the good Dr Hamish.

I also find that those beating the loudest on the TDD drum state:
TDD is fine, and anyone who disagress with TDD simply does not understand what TDD is…

This is what I disagree with about TDD… (verbatum from Scott Ambler http://www.agiledata.org/essays/tdd.html)

“A programmer taking a TDD approach refuses to write a new function until there is first a test that fails because that function isn’t present. In fact, they refuse to add even a single line of code until a test exists for it. Once the test is in place they then do the work required to ensure that the test suite now passes (your new code may break several existing tests as well as the new one). “