There’s been a lot of talk lately about how agile dev practices are hurting more than they’re helping. People complain that things like unit testing, TDD, CI, pairing, and code reviews limit developer creativity and create unnecessary work.

This is of course ironic since agile processes emerged precisely because people felt that non-agile processes which preceded them were hurting more than they were helping. So, what’s going on here?

Why Do Processes Exist?

Processes exist to ensure outcomes. If you didn’t care about how quickly you can make something, or about how well it works, you wouldn’t need processes. But you do care. So you figure out ways to ensure that you can deliver on time, with quality, and with whatever other characteristic you care about.

Processes also exist to get predictably good results out of groups of differently skilled workers. If I have an army of people making widgets, I want some guarantee that they’ll keep making good widgets no matter who is involved (provided they have some baseline level of skills).

But What About Software Development?

This should surprise no one, but software development needs processes too. Why wouldn’t it? After all, you care about delivering good software and you want predictably good results from the people who build it.

And what makes software good? Aside from the obvious (it works well and it does what you want it to do), good software is easy to live with. It’s easy to fix it if you needed to, it’s easy to change it if you wanted to.

Why Do Processes Tend to Suck?

It’s almost inevitable that processes will limit individual impulses (i.e. creativity). Taken too far, they will stifle passion, turn everyone into mindless drones, and generally suck the fun out of work. No one wants that. But we still need to get things done.

The trick is to not take things too far. Part of that is recognizing that the more able your devs are, the less process you need to guide them. And vice versa.

Imagine for a second that your dev team consists of ninjas who can bang out great code like it was going out of style. They can build anything you want, quickly and efficiently, with no bugs, and get it to end customers with minimal fuss as often as you want to. Would you still need elaborate processes to help guide them? Probably not.

But here’s the reality: most shops don’t have teams of ninjas writing code. This will sound harsh, but most developers are not great. In fact, most are not even especially good. Oh and most think they’re better than they actually are (myself included).

And it gets worse. Most teams also have to deal with hostile code bases, which make it that much harder to do good work. Even good devs can get tripped up by it.

Yet, is spite of this reality, you still need to get  things done. So, you find ways to get devs (great and not so great) to do good work. This is what most agile engineering practices are all about.

You unit test or TDD or pair because it helps you reduce bugs and write more maintainable code. You set up CI because it helps you find bugs quickly and teaches you how to deploy your app efficiently. And so on, and so forth.

Final Thought

If you think that agile engineering practices are painful or unnecessary, you may very well be right. But be that as it may, these practices are the best tools we have today to get devs to do good work. So, if you really want a change, there are two ways to go: either get much better devs or invent better practices.

You may also like:

tagged with:

Did you love / hate / were unmoved by this post?
Then show your support / disgust / indifference by following me on Twitter!

This post got 2 comments so far. Care to add yours?

  1. Tim says:

    Are you sure you haven’t got the ideas of “process” and “practice” mixed up? You seem to be using the words somewhat interchangeably?

Leave a Reply