We can also submit our .net related links on http://www.dotnettechy.com to improve traffic.

The dotnettechy.com is a community of .Net developers joined together to learn, to teach, to find solutions, to find interview questions and answers, to find .net website / blog collection and to have fun programming.

Thanks for your comment! I have no choice but to offer a counter-argument:

“That TDD is a methogological smell is shown by the amount of people who move from writing code first, to writing tests first, and then back to writing code first.”

Do you have some data to back that up or is that just your personal belief?

Here are some links that show TDD adoption rate and it’s prevalence over the years:

http://www.agiledata.org/essays/tdd.html
http://c2.com/cgi/wiki?TenYearsOfTestDrivenDevelopment
http://codemanship.co.uk/parlezuml/blog/?postid=1066 – This link doesn’t contain any numbers but it is rather interesting because it talks about developer maturity – something you mentioned in your comment.

As pointed out in the links above, TDD has a been around for quite some time now and has been advocated by software experts like Ward Cunningham, Kent Beck, Martin Fowler, Robert Martin…I could go on. Stating that following TDD is a sign of an immature developer is…well, it’s a quite a statement! You may want to think it over again.

You see, here is the issue with the “just write the code, run it and see if it works” approach. The approach works fine when you’re writing something small – like a program that prints out a triangle. You simply look at the output and you can tell whether or not your program works. Things are not quite so simple when you’re dealing with an application of a sufficient amount of complexity that is built by a team of developers. Without tests you’ll have no way of knowing whether your code broke something else or whether the existing code was written the way it is written for a reason and if your change re-introduced a bug that was fixed earlier.

Or you look at a piece of code written by another developer and think “Hmm…that doesn’t look right. I wonder if it accounts for all the scenarios.”. No way to know expect to run the code and see it! Except that manual testing takes forever and requires a lot of initial setup because you have run the entire application. And you find yourself saying “Oh I wish I could just test this functionality in isolation!” You could if you had written unit-tests! And if you had then you could even add more unit-tests to the existing suite. And the next time another developer looks at the code and has the same question – well they can simply open up the unit-tests and see which scenarios are being tested! But, alas, you don’t have unit tests and now you’re stuck with having to setup initial data, configure third-party settings that your application interfaces with, bring up the application, go the specific area that you want to test, test it, and check the results. Rinse and repeat for the second scenario. Come back to it a few months later and rinse and repeat again. I know I am exaggerating a little – but just a little! This is actually something that developers that don’t have unit and integration tests for their applications have to do day-in/day-out. Compare this to a suite of automated tests that tell within minutes, if not seconds, whether you’ve broken something or discovered a bug and you just might start to see the benefits of TDD!

To sum up, TDD is more than just testing. It is about maintainability. It is about preserving/improving code quality. It is about documentation – documentation that is written in code and passes and hence it doesn’t lie and is forced to always stay current. It can even be used as a metric because you can’t improve what you can’t measure.

Hope that helps!

TDD is a methodological smell.

What you’re describing in your post is the normal way of writing code for a reason: writing all code (not just “production” code) is faster when you write the code, run it to see that it works and then – only then – write the tests.

Writing tests for code when you’re not sure that the code works is a bit silly: if it doesn’t work, then you’ve to change both code and tests.

Writing tests for code that works when you run it at least gives you a little more confidence that you haven’t wasted your time writing both code and tests.

There are those who say that TDD is about design, not tests; but that changes absolutely nothing. If you write tests first, this will ensure that the code you write is testable; nothing else. If it doesn’t give you the desired result, then you’ve got tests and testable code that you’ve to delete: you waste precisely the same about of time to deleting tested wrong code as untest wrong code. The only difference is that with TDD, you’ve also wasted your time writing useless tests.

That TDD is a methogological smell is shown by the amount of people who move from writing code first, to writing tests first, and then back to writing code first.

TDD just shows that you’ve not matured yet.

Thanks for your comment, Jim!