6 degrees of separation in understanding user queries

Be grateful. Be flattered. Be outright ecstatic. Why?

Because users think you’re a mind reader.

For some reason, they think telling you “I can’t do X. Please help.” is enough. They don’t tell you

• which application it is
• where or which screen in the application it is
• any error messages they see
• what they did (before they got the error message)

They sometimes just don’t tell you enough.

6 degrees of separation is already too much. Users expect you to make amazing leaps in intuitive logic from their pathetic amount of information to whatever is ailing them at that moment. That’s one giant step of deductive debugging.

How do you understand their queries better? Just ask. Ask for more information. This is where your people skills come into play. You’ve got to ask them in the way that makes them feel good about themselves. Basically, you want them to feel like they’ve done everything correctly and it’s really the fault of the software, even if you think they’re complete morons.

You’ve got to coax them into telling you stuff. And it doesn’t help if you keep calling them an idiot.

This brings us to the next problem. Users lie. They don’t lie outright. They just don’t tell the truth sometimes. And it’s not because they purposefully and specifically lie to you. Sometimes they just don’t know they’re telling a lie.

The spelling misunderstanding

For example, I recently had this user say he couldn’t use an application X because of an error. I probed further and managed to pry an error message out of him. Something about a missing file. There was this part “Pls check and proceed”.

Well, I thought, the more unique the error message is, the easier for me to locate where in the code the error occurred. Ever since I took over maintenance of legacy programs, I love it when there are unique error messages. Incorrect spellings, short forms of words, unusual text (like two consecutive spaces), incorrect grammar. Searching entire source code with unique search phrases means there are fewer search results, increasing the speed of finding the actual code.

So I typed in “Pls check” into the search box and ran the search. Nothing. What? I looked at the whole error message and nothing stood out as unique. So I got the user to give me a screenshot. The actual error message was “Please check and proceed”.

Did the user lie? Not really. He read and interpreted the error message correctly. It’s when he’s conveying the error message back to me that information was lost. For him, there’s no difference between “Please” and “Pls”. For me, it’s absolutely critical that every single letter was correct. Sometimes even letter casing matters.

This is the heart of understanding user queries: Understand the user.

I maintain many programs and applications, and I work with different sets of users. These sets of users usually don’t know that I work with other applications and users, so sometimes they ask me something expecting me to know the context of their query (when in fact I have no clue).

Here’s a list I use for probing

• Ask for screenshots
• Ask for error messages
• Ask which application they’re using
• Ask which screen or web page they’re on
• Ask which button they clicked to get the error

No information is redundant. Debug like a CSI because you should “Follow what cannot lie, the evidence”. In this case, any information you get is evidence. If their version of the error message contradicts the one in the screenshot, then you can ask further. One or the other must be wrong. Either way, you get more information.

When you’re trying to understand user queries, there’s no such thing as too much information.

Your lifesaver, the screenshot

There’s another case where the user was asking why the update button doesn’t work and the application keeps hanging. No error messages, and he told me which application and screen he’s using and even which button (the update button).

In the end, I asked for a screenshot. Everything looked to be in order. Then I looked at the taskbar in the screenshot. He opened 3 instances of the same application, performing the same task at the same screen. That was the problem. Due to data concurrency and locking, the application instances simply got stuck. I told him to use just one instance and everything was fine after that.

Did he lie? Yes, because he didn’t tell me that he’s running 3 instances of the application, which wasn’t designed for that. Was it really his fault? Not really. He thinks doing different updates with 3 separate instances will speed up his work. Like he’s multitasking or something (a mindset shared unfortunately by many of my users…).

What you should strive for is answering the user query with whatever the user first supplied. That’s ideal of course, and usually hard to reach. The next ideal case is this:

• User sends you email with query (with insufficient information)
• You understand whatever is given
• You formulate intelligent questions
• You call (or email) the user and ask those questions
• You finally understand what the user wanted
• You close off the query, whether it’s fixing bugs or answering questions

Calling is usually better than sending another email. You can save a lot of emails bouncing back and forth if you can just talk on the phone. Your ultimate goal is to minimise back and forth communication.

You may not be able to understand and answer user queries in 1 degree of separation. But with a little thinking first, you can do so within 6 degrees of separation.

My computer got sick

2 days ago, the computer at my work place got infected with a computer virus. It’s a fortune that I was able to get it out of the computer. It was a misfortune that I wasn’t able to get any work done since I was scanning my computer, and I didn’t want anything to disrupt the scan.

My computer housed practically all the source code ever written in my department. Alright, I’m exaggerating, but it’s not far from the truth. If the hard disk was wiped out, let’s just say either I will be assured of another year of contract, or I’ll be out of a job.

So anyway, a reminder for everyone reading this: Have you backed up your computer?

Round cornered images in Paint.NET

I’ve been experimenting with doing some simple image post processing for my posts. Rectangular images with sharp right-angled corners look a bit stark. I’m getting most of the images from iStockphoto (referral link), and it seemed a waste if I didn’t fit photos and text together nicely.

The easiest and fastest way to spruce up a stock photo is to create round corners in the image. I’ll be showing you how to do so in the freely available, fantastic and awesome image editor, Paint.NET (did I mention it was free?).

So, suppose here’s the original photo, after loading it into Paint.NET

Then you add a new layer by either clicking [Layers] -> [Add New Layer] option

or click on the “Add New Layer” button in the “Layers” panel (placed near bottom right by default)

Next, you want to focus on the 2nd layer for some editing first. On the “Layers” panel, uncheck the “Background” image.

On the 2nd layer, we wash it over with white colour first, because by default it’s in “transparent” colour. We can talk about the difference between white and transparent some other time… We’ll use the paint bucket tool

By default, if you haven’t changed the colour selection yet, then the primary colour is black and the secondary colour is white.

What this means is if you click and draw with the left mouse button, black is used. If you click and draw with the right mouse button, white is used.

So after selecting the paint bucket tool, go somewhere in the (transparent-coloured) image, and right-click. This will give you a nice clinical white patch.

We want to draw a rounded black rectangle on this white patch. We use the aptly named “Rounded Rectangle” tool

Some finger nimbleness will be needed here. Our test image is 160 pixels wide and 110 pixels tall. We’ll have to left-click (for black) in the image, at the cursor position of 0,0 and drag-move to cursor position 159,109. You can find out the cursor position by looking somewhere near the bottom of Paint.NET

We’re at cursor position 11,9 in this case.

You should then get this beauty

After that, go the “Layers” panel, and click on properties for the 2nd layer

and set the blending mode to “Additive”

Check the “Background” layer back (to make it visible again) and you should see this

Save and you’re done!

I think a video tutorial would have done a better job. Anyone want to sponsor the Camtasia software for me?

PS. That “Skyline gondola” sign was taken at the halfway point on my practically vertical climb up the hill in Queensland, New Zealand. I was the only one (stupid enough) climbing up. Everyone else was going down… A story for another time perhaps…