Monday, June 20, 2011

That's the sentiment you can find in a lot of arguments between developers. It's too black and white, too absolute. The issue is that the focus leaves the goal. It artificially limits the solutions you can come up with.

In the case of TDD, you can most certainly write code before tests. What do all software development practices boil down to? Building easily maintained software. It isn't about creating beautiful code, it isn't about designing a family of classes, it isn't about creating a model that sounds like a spoken language. Building easily maintained software can be done in any number of ways. Something like TDD helps to reinforce proven practices for maintainable software but it's not the only solution. I'm a TDD practitioner but you know what? I've got no beef with writing code first. You don't always need to TDD.

In the case of agile development, for anyone adopting agile, there's a LOT of focus on the religious practices that come with it. You will, for a long time, follow these practices blindly, even when they don't improve your process and become a nuisance. The answer is that not all practices may make sense. Take a step back and look at what they are intending to achieve. A 5 minute scrum doesn't mean you're doing a good scrum. You may find that, for your group, have something like 8-10 minutes is more comfortable. Don't hate yourself because you're not following it to a T. You've done exactly what these practices were intended to do; maximize your productivity. That's the goal of this whole thing.

In the case of NOSQL, it's a poor musician to blame his instrument. People finally realized that they were using SQL as the hammer to nail everyone's persistence problems. With the host of new applications we build, SQL isn't always the answer. Maybe it's a document database. Maybe it's a key-value store. Maybe you need something that natively supports object graphs. Instead of recognizing the fact that applications and their persistence mechanisms come in all shapes and sizes, the sentiment has become that SQL is the scourge of software development. We have ourselves to blame on that one, trying to force an object model into a system that poorly represented it. Somehow this is SQLs fault? We stopped questioning why we did the things we did. Take a step back, ask yourself what you're really trying to do and then it becomes a no-brainer. That's what gave birth to all these new forms of persistence.

For some, it may take a while to see it but you'll get there. Don't fall into the trap of blindly doing things without re-evaluating constantly. There's more than one way to do something and you shouldn't let software purity or zealotry prevent you from considering it. It leads to the innovations that improve our lives as developers and the people who use our software.