Talent vs Hard Work

I recently read an article by Chris Brecheen, I follow his page on Facebook and his post about dungeons and dragons caught my attention on a slow Sunday morning.

In it, he discusses a D&D player with an unbeatable magic sword who saunters up to a dragon and, through lack of preparation, is reduced to a pile of ash. Meanwhile the team who have battled against ogres, orcs, and trolls for the last three years eventually manage to bring down the monster after several hours of hard fighting.

The message was that having “talent” in something (or at least believing you do), makes you overconfidence, brittle, and actually limits what you can achieve.

In his book The Art of Learning Josh Waitzkin discusses how children are given positive reinforcement in one of two ways. Either they are told that they’re really good at something, maths for example, or they are told that they worked really hard.

The difference comes, Josh explains, when they meet a challenge they can’t overcome. The kid who is told that they’re good at maths immediately assumes when they face a question they cannot answer that they are not good enough. The child raised to believe that they succeeded because they work hard has a different outlook, they believe that they’re stuck because they’ve not worked hard enough. One child will continue to work the problem, the other will assume it is beyond them.

Believe it or not I’ve seen the same thing in developers, some with fifteen or more years of experience. When a developer is faced with a bug they cannot solve, either they assume they are not smart enough (or, far more often, that they have not been provided enough/correct information), or they simply shrug and say they’ve not found the problem… yet!

This behaviour, in my mind is one of the key differentiators between a good developer, and a great one. The outstanding developers on the team will continue to look at a problem without frustration, continually attacking it from different angles until they reach the next breakthrough. Even if that victory is only one small step to resolving it.

So what can we do to encourage this kind of behaviour in our teams? Try thanking people for their effort, rather than their smarts. Understand that real success comes from hard work, not from a bolt of inspiration.

Also, one more thing before I put aside my soap box. If we want to continue to grow then throw aside any delusions of being where you are by being the smart one, you got there through work – just like everyone else. You didn’t inherit a magical sword or extraordinary talent. So make sure you’re not relying on it the next time you meet a particularly scary dragon!

The Cost of Fixing Bugs Late

Have you ever been in a situation where you’ve written a piece of code and it’s almost there but there are a few niggling issues which “can wait for V2?”. Have you ever wished, maybe months later that you’d gone back and resolved them at the time? You’re not alone!

More and more developers and managers are beginning to realise the true cost of fixing bugs late, not only on their sanity but on the company’s time and money.

Let’s say for the sake of argument that you’ve finished a piece of code except for a few edge cases. You’re under a lot of time pressure so you decide it’s of a high enough quality and you push it through to QA. The cost to the business of fixing that issue actually increases dramatically the longer it’s left.

Let’s look at a few scenarios:

You fix the issue immediatly

  • Fix time – 30 minutes

You send to QA and it’s rejected there

  • Fix time – 30 minutes
  • Build time – 2 hours
  • QA deployment time – 1 hour
  • QA signoff testing – 24 hours
  • Fix time – 30 minutes

QA passes as an “edge case” but the customer disagrees

  • Fix time – 30 minutes
  • Build time – 2 hours
  • QA deployment time – 1 hour
  • QA signoff testing – 24 hours
  • Deploy to UAT – 3 hours
  • Customer UAT – 1 week

Missed in UAT but discovered as a significant issue in Live

  • Fix time – 30 minutes
  • Build time – 2 hours
  • QA deployment time – 1 hour
  • QA signoff testing – 24 hours
  • Deploy to UAT – 3 hours
  • Customer UAT – 1 week
  • Customer live deploy – 3 hours

 

As you can see, even with these rough estimates the time it takes to resolve the customer’s issue increases dramatically the longer it’s left. Not only that but the cost of time to the business of paying staff to run extra QA cycles or rounds of UAT spirals out of control. We haven’t even considered the final case where it goes to the bug queue to die and a completely different developer has to learn the feature and resolve the problem.

The graph is actually a very common shape*.

graph-2

I’m a big fan of practicality, no software is going to be perfect and it’s unrealistic to expect that you’re going to find and fix each and every issue before shipping to a customer.

However, hopefully this has made you stop and think and has provided a strong argument for making that extra 30 minutes to resolve the issue before it causes a real headache for the business!

*Thanks to fooplot.com for the graphing software.