Blogging about underlying software engineering skills and work/life balance - you can work as a software engineer and still have a sane workweek!
(This was originally published on my blog).
Your software has bugs. Sorry, mine does too.
Doesn't matter how much you've tested it or how much QA has tested it, some bugs will get through. And unless you're NASA, you probably can't afford to test your software enough anyway.
That means your users will be finding bugs for you. They will discover that your site doesn't work on IE 8.2. They clicked a button and a blank screen came up.
Where is that feature you promised? WHY IS THIS NOT WORKING?!
As you know from personal experience, users don't enjoy finding bugs. Now you have buggy software and unhappy users. What are you going to do about it?
Luckily, in 1970 the economist Albert O. Hirschman came up with an answer to that question.
In his classic treatise Exit, Voice and Loyalty, Hirschman points out that users who are unhappy with a product have exactly two options. Just two, no more:
Someone who has given up on your software isn't likely to tell you about their issues. And someone who cares enough to file a bug is less likely to switch away from your software. Finally, loyal users will stick around and use their voice when otherwise they would choose exit.
Now, your software has no purpose without users. So chances are you want to keep them from leaving (though perhaps you're better off without some of them - see item #2).
And here's the thing: there's only two choices, voice or exit. If you can convince your users to use their voice to complain, and they feel heard, your users are going to stick around.
Now at this point you might be thinking, "Itamar, why are you telling me obvious things? Of course users will stick around if we fix their bugs." But that's not how you keep users around. You keep users around by allowing them to express their voice, by making sure they feel heard.
Sometimes you may not fix the bug, and still have satisfied users. And sometimes you may fix a bug and still fail at making them feel heard; better than not fixing the bug, but you can do better.
To make your users feel heard when they encounter bugs you need to make sure:
Let's go through these requirements one by one.
Once your users notice a problem you want them to communicate it to you immediately. This will ensure they choose the path of voice and don't contemplate exiting to your shiny competitor at the domain next door.
Faster communication also makes it much more likely the bug report will be useful. If the bug occurred 10 seconds ago the user will probably remember what happened. If it's a few hours later you're going to hear something about how "there was a flying moose on the screen? or maybe a hyena?" Remember: users are human, just like you and me, and humans have a hard time remembering things (and sometimes we forget that.)
To ensure bugs get reported quickly (or at all) you want to make it as easy as possible for the user to report the problem. Each additional step, e.g. creating an account in an issue tracker, means more users dropping out of the reporting process.
In practice many applications are designed to make it as hard as possible to report bugs. You'll be visiting a website, when suddenly:
"An error has occurred, please refresh your browser."
And of course the page will give no indication of how or where you should report the problem if it reoccurs, and do the people who run this website even care about your problem?
Make sure that's not how you're treating your users when an error occurs.
So let's say you include a link to the bug report page, and let's say the user doesn't have to jump through hoops and email verification to sign up and then fill out the 200 fields that JIRA or Bugzilla think are really important and would you like to tell us about your most common childhood nightmare from the following list? We'll assume that bug reporting is easy to find and easy to fill it out, as it should be.
But... you need some information from the user. Like, what version of the program they were using, the operating system and so on and so forth. And you do actually need that information.
But the user just wants to get this over with, and every additional piece of information you ask for is likely to make them give up and go away. What to do?
Here's one solution: include it for them.
I've been using the rather excellent Spacemacs editor, and as usual when I use new software I had to report a bug. So it goes.
Anyway, to report a bug in Spacemacs you just hit the bug reporting key combo.
You get a bug reporting page. In your editor. And it's filled in the Spacemacs version and the Emacs version and all the configuration you made. And then you close the buffer and it pre-populates a new GitHub issue with all this information and you hit Submit and you're done.
This is pretty awesome. No need to find the right web page or copy down every single configuration and environmental parameter to report a bug: just run the error-reporting command.
Also, notice that this is a lot better than automatic crash reporting. I got to participate and explain the bits that were important to me, it's not the "yeah we reported the crash info and let's be honest you don't really believe anyone looks at these do you?"-vibe that one gets from certain software.
You can do much the same thing with a command-line tool, or a web-based application. Every time an error occurs or the user is having issues (e.g. the user ran
The next thing you have to do is actually respond to the bug report. As I write this the Spacemacs issue I filed is sitting there all sad and lonely and unanswered, and it's a little annoying. I do understand, open source volunteer-run project and all. (This is where loyalty comes in.)
But for a commercial product I am paying for I want to know that my problem has been heard. And sometimes the answer might be "sorry, we're not going to fix that this quarter." And that's OK, at least I know where I stand. But silence is not OK.
Respond to your bug reports, and tell your users what you're doing about it. And unfortunately an automated response is not good enough.
If you've decided to fix the bug you can now proceed to do so... if you can figure out what the actual problem is. If diagnosing problems is impossible, or even just too expensive, you're not going to be able fix the problem. And that means your users will continue to be affected by the bug.
Let's look at a common bug report:
I clicked Save, and your program crashed and deleted a day's worth of my hopes and dreams.
This is pretty bad: an unhappy user, and as is often the case the user simply doesn't have the information you need to figure out what's going on.
Even if the bug report is useful it can often be hard to reproduce the problem. Testing happens in controlled environments, which makes investigation and reproduction easier. Real-world use happens out in the wild, so good luck reproducing that crash.
Remember how we talked about automatically including as much information as possible in the bug report? You did that, right? And included all the relevant logs?
If you didn't, now's the time to think about it: try to ensure that logs, core dumps, and so on and so forth will always be available for bug reports. And try to automate submitting them as much as possible, while still giving the user the ability to report their specific take on the problem.
(And don't forget to respect your user's privacy!)
So now you've diagnosed and fixed your bug: problem solved! Or rather, problem almost solved. If the user hasn't gotten the bug fix all this work has been a waste of time.
You need fast releases, and you need automated updates where possible. If it takes too long for fixes to reach your users then for for practical purposes your users are not being heard. (There are exceptions, as always: in some businesses your users will value stability over all else.)
If you've done this right:
There is more to be done, of course: many bugs can and should be caught in advance. And many users will never tell you their problems unless you ask.
But it's a good start at making your users happy and loyal, even when they encounter the occasional bug.
By the way, I'm not kidding about my software having bugs: I've written software that crashed every night in production at 4AM, software that was so broken that it was completely unusable, software that wasted users' time for no purpose... it's a long list.
If you'd like to avoid making these mistakes, and many other mistakes I've made over the past 20 years, I'm writing a weekly email with one my of mistakes and how you can avoid it. Sign up for the newsletter and avoid my many software and career mistakes!