Tuesday, October 20, 2015

Programmers vs. Idiots

I found this image recently and shared it on Facebook.


Reactions from my friends was interesting. Most agreed with my saying that I didn’t think programmers were doing enough to make software easy to use. One person pointed out that this image shows an arrogance that software developers too often believe that everyone else is an idiot.

Programmers often tend to write software that works for them. In other words they think that what is easy and logical to them is easy and logical for everyone. Well except for, you know, idiots.  That is very often not the case. In fact one of the reasons we have different people test software other than the authors is that if you know too much about how something works you can easily sidestep the limitations of it.

Making user friendly applications can be hard. I’ve got a couple of applications I wrote for my own use that I would never hand off to others.I know they are not user friendly. They are usable only by someone who knows a lot of details. I wrote them to be easy for me to develop. They are easy to use once set up with data entered in proper formats. Setting up that data is not trivial for a non-computer geek. That’s not because non-computer geeks are idiots but just that a certain amount of domain specific knowledge is required to jump though the setup hoops.

And that, the setup hoops, is where a lot of software gets hard to use. I’m a pretty savvy computer user but there is some software I don’t use just because I’d have to learn too much new stuff to set it up and run it. Oh it would be easy, I think, to use once set up but it’s not worth my while to go though the setup pain right now. 

A lot of complexity has to do with adding more features, more power, and more flexibility. Ease of use seems to be one piece that gets set aside from time to time. Tools become more powerful and perhaps even more useable by the high end user but lose the ease of use for the low end or casual user. It is a sort of sliding bar where the difference between the low end and high end stays the same but everything moves towards the high end.   

This can be a particular problem for those of us teaching computer science. Integrated Development Environments and programming languages that are designed for professionals are becoming too hard for beginners to use. Special environments for beginners are available but often the jump between them and professional tools is large and getting larger. There is no easy answer.

There are teaching/educational environments that have stages with the early stages having fewer complications and less power than more advanced stages. The idea is to ease people into the complexity and power. It’s a great idea. I just wish we had more of them, especially in specific development domains. Of course getting the right features at each level can be tricky as well. One wants to walk the line between enough features to make for interesting projects and the too many features that might overwhelm beginners. We also have to keep the gap between levels manageable. It’s a hard balance.

We need to have the conversation about ease of use with students. One thing we have to remind them of is that the ability to write code comes with a responsibility to create easy to use code. We need to let them know that the users are not idiots and that they deserve the respect of the coders. After all those users likely have domain knowledge that the coders may need some day. We certainly don’t want those users to treat us like idiots when we need their expertise.

1 comment:

Garth said...

My brief foray into commercial programming taught me a lot on this topic. The company had three major departments. The people who designed the GUI interface, the programmers and the testers. If the designers got to the client first then things were pretty rosy. The client had a product they could use. If for some reason the client bypassed the designers and talked to a programmer the resulting GUI was not so hot. This was sort of my job. I would just stick fields all over the GUI just to get things to fit. I had no idea what the order of data entry should be or what fields should be linked. The testers really did not care. They were perfectly happy testing junk. What was really entertaining is when a programmer designed GUI got back to the GUI designers. That word "idiot" would come up. Always fun to be in those meetings. Programmers are not often the the people who should be designing the front end of a piece of software. Programmers are idiots sometimes when having to think like a normal person using the software.