Lately, I have touched a nerve with a few TechRepublic readers regarding the issue of user-friendliness — specifically, user-friendliness surrounding the Linux operating system. Of course, this debate isn’t limited to Linux. User-friendliness can be applied to every operating system, end-user application, proprietary in-house application, and more.
But what makes an application user-friendly? Here are10 criteria by which you should be judging everything you roll out to your end users, as well as anything you might be using yourself.
Note: This article is also available as a PDF download.
1: Simple to install
This applies to everything from operating systems to browser plug-ins. Installation is the first point of contact for users, so it had better be a friendly process. Otherwise, they’re going to be jaded the second they begin using your tool. It doesn’t matter whether it’s an operating system or a single-client user application, the installation should be simple and well documented. The second the installation becomes complicated, users will bail and move on to something easier.
2: Easy to update
As with the installation, an application’s update process should be easy. If updates are complex, users will more than likely skip the process. This can often leave behind a trail of bad results, as many updates patch security holes, memory leaks, and other problems. Updates need to be simple enough to ensure that users continue to benefit from the hard work of the creators of the software. When users don’t update, thus exposing issues, the software becomes less and less reliable and secure (as well as missing out on new features).
Software is only as good as its GUI. If the GUI is not well thought out and well executed, people will have issues with using the product. A well-designed GUI can often overcome a less-than-friendly underlying structure (or poor coding). But don’t bank all your hope on a good GUI — the software still needs to work as expected!
Not only should a piece of software work as expected, it should also be efficient. It should be optimized for specific architecture, it should have all memory leaks plugged, and it should work seamlessly with underlying structures and subsystems. From the users’ point of view, the software should be an efficient means to completing their jobs. Software should not get in the way of completing a task, nor should it set up any roadblocks for users. The efficiency of a piece of software is tied up with its intuitiveness. A good example is the change Microsoft made to the Office interface. Switching from the standard interface to the Ribbon interface caused end users to waste precious work time simply trying to figure out where features were located. This was an inefficient (and inefficiently executed) design choice.
5: Pleasant, easy-to-navigate GUI
You might be thinking, “The Microsoft Office Ribbon Interface is horribly NOT intuitive, but it certainly is pleasant looking.” However, the look and feel of a GUI is a slippery slope that designers tend to tumble down. When a designer opts to go with trends instead of what works, it makes for an unpleasant experience for the end user. Instead of going with trends, add your own take on what is proven. The tried-and-true drop-down menu design has worked for years but is long overdue for an update — but this update should not come at the expense of intuitiveness. A GUI’s primary purpose is to make an end user’s job easier… and little more. If that can be achieved with an edgier design, go for it. But if your edgy design is counterintuitive and inefficient, it fails the user-friendliness test.
6: Easy to remove
Along with being easy to install and use, a piece of software should be easy to remove. Without a simple removal process, that software becomes cumbersome. And cumbersome is not user-friendly. As much as developers don’t want their users to remove their software, the removal process might be the last impression your software makes. Don’t make that impression a negative one.
7: Doesn’t need third-party software
One of my biggest problems with the Windows operating system is that more often than not, it requires third-party software to keep it running. This third-party software comes in the form of antivirus, anti-spyware, and other protection-based tools. Without these tools, your computer is vulnerable to whatever the malevolent powers that be want to throw at you. This is not user-friendly, as it creates levels of complication that most average end users can’t deal with.
8: Easy to troubleshoot
No software is perfect. And when something goes wrong with a piece of software, it’s important that the end user can call support and that support can resolve the issue. If the software offers nothing in the way of troubleshooting, how is the end user or the administrator going to be able to keep the software running? Windows 7 attempts to help the user out when a program crashes and does a fairly good job with it. In Linux, if you have problems with an application, you can always run it from the command line to see some of the issues presented. There are also third-party tools that can be used. But again, depending upon a third-party debugging tool is not user-friendly.
9: Adheres to standards
Standards are created for a reason — to make interconnectivity between applications or hardware easy. Problems begin to arise when developers do not adhere to standards. This has never been so obvious than with Microsoft Office. Microsoft has practically shunned the world of universal standards in favor of its own standards. This causes issues with other applications communicating with its software. OpenOffice is one office suite that does follow standards, but it often suffers because Microsoft doesn’t comply with standards set by governing bodies. When users are affected by a lack of compliance to standards, they’ll face an unfriendly experience trying to get their tools to communicate with tools that do follow standards.
10: Effective error handling
What happens when a piece of software encounters an error? Does it just go away without warning? Does it try to rectify the issue? Does it simply time out and then go on about its business? When a program comes across an error, it should make the error known, at least to the developers. It’s not the end users’ responsibility to report bugs, but giving them the option to report bugs can go a long way toward helping that software improve. When a program runs into an error and simply bails without warning or recourse, users are left with their eyes bugged out and their hands in the air. At least let users know there was a problem and what they can do to help solve it — such as sending a bug report to the developers.
How do you define user friendly?
Do these criteria fulfill your idea of what makes for a user-friendly software experience? If not, what would you remove or add to this list? Share your thoughts with your fellow TechRepublic readers.