Programmers (hopefully) do their best when coding applications, but nobody is perfect. And that’s definitely evident when you look at some of today’s websites, desktop programs, and smartphone apps.
Whether by accident, due to management requirements, or because of a lack of understanding of what users really need, programmers often end up creating annoying interfaces for users. Let’s take a look at some of the stupid quirks that baffle, infuriate, and make us laugh.
1. Unhelpful Error Messages
There’s perhaps no element with more potential to confuse, anger, or otherwise elicit a strange emotional response than the error message. We’ve looked at some of the most ridiculous error messages in Windows, but these aren’t limited to just that platform.
You’ll find all kinds of examples of poor error messages; let’s look at a few common types. Many of these examples come from Microsoft’s extensive page on the do’s and don’ts of creating error messages, but apply to messages everywhere.
Too Much Technical Information
In this kind of error message, the dialogue provides technical details that confuse the user. If an error message sound like it was written by a robot, the average user has no idea what any it means — so they’re not going to read it. Thus, they have no starting point for fixing the problem.
A secondary type of this error occurs when programmers use the end-user dialog box to report programming errors. Errors that contain information about memory violations or variable problems are completely useless to the user and will only confuse them further.
Blaming the User
Another common mistake of error messages is making the user feel at fault. Even if they actually did perform an unwanted action, they shouldn’t feel bad because they made a mistake. Using harsh language is a bad idea and will frustrate the user more than they already are.
Being Too Vague
Why create an error message if you aren’t going to describe the issue properly? When a user hears the error sound and sees An unknown error occurred, what are they supposed to do? If you provide no information about why the error happened, they’re going to click OK and pretend nothing happened.
Windows 10 infamously featured this type with its Something happened error when updating to a new version.
Thanks to popup ads, most users are conditioned to getting rid of dialogue boxes as fast as they possibly can. While error messages are sometimes necessary, using them constantly means the user is more likely to ignore them. So triggering error messages for non-problems is not smart.
In the below example, if a user explicitly cancels a backup operation, they don’t need to see an error letting them know this. They requested the action, so while it might be an error from the software’s point of view, the user doesn’t need to see a dialogue.
Sometimes errors are so stupid that users will scoff at and/or ignore them. Here’s a great example:
Is anybody going to take a message like this seriously? We’re told this has an unspecified flaw, but only a potential one. If there’s a major problem, warn the user of it. And if there’s no problem, don’t throw an error message.
2. Atrocious Forms and Selection Boxes
Many users utilize the Tab key to quickly move between boxes when filling in their information. You’d think this would be universal (First Name > Last Name > Street > City > etc.) but sometimes programmers make it way harder than need be. Pressing Tab could jump you from First name to ZIP, then down to Submit. When you’re on mental auto-pilot entering your info, this is a huge pain.
Or how about selection boxes? Whether a programmer chooses a dropdown list, selection box, or ask the user to enter a value depends on the type of input you expect. In most dropdown boxes, ordering alphabetically makes the most sense so the list is easy to browse. But how about here, where the list of floors is in ABC order instead of numerical order? What a huge pain to browse through.
Another horrendous example of poor selection boxes is below. Instead of simply providing a text box for the user to type their phone number, here you must select from every possible combination. We don’t even want to think about how long this took to type out.
3. Lack of Inline Validation
Here’s a terrible feeling most users know all too well. You’ve gone through the dozens of fields on a page when signing up for a service, applying for a job, or similar. After you click Next, you’re greeted with an error that the email address fields don’t match or another such oversight.
The problem is that reloading the page removes all the data you entered! Now the user has to waste their time by going through and typing out all the same information again. If the programmer had simply implemented inline validation — checking to make sure input is valid before the user submits it — your page could avoid this.
4. Bloating and Bogging Down Software
You can almost hear the users crying when a once-great piece of software becomes bloated with so many extra features that it’s a nightmare to use. A great example of this is iTunes. It’s an important program to install if you own an iPad or iPhone, and it’s thankfully slimmed down a bit in recent months. But for a long time, using it has been confusing and overbearing.
When you install iTunes, it also includes a ton of other Apple software like Bonjour, QuickTime, and Apple Software Update. Once installed, iTunes has so much to offer it would make your head spin. You can browse the store for music, movies, audiobooks, and podcasts, check out Apple Music for streaming, view apps on the iOS App Store, sync your device, and more.
That’s not even mentioning how much space iTunes takes up on your system, its slow and confusing interface, and the nightmares that come with syncing music (including having it randomly deleted). iTunes tries to do ten things instead of doing one or two really well.
So if you only have it installed to occasionally back up your iPhone, you probably cringe whenever it’s time to open iTunes, wait forever, and then see what they’ve crammed in lately. Likewise, a user who wants to use iTunes to listen to music doesn’t care about all the other nonsense.
5. Ignoring Operating System Design Standards
Every major operating system (OS) has a set of standards developers should follow when creating apps for it. You expect an Android app to look different from an iOS app, for example. And these change over time! Compare popular Android apps from 2012 and now. Following guidelines, even if your app isn’t the most visually stunning, makes it at least presentable. But when you go against these, it drives users crazy.
For instance, take the Back button on Android. Tapping it is supposed to move you back one screen. So if you’re viewing an email in Gmail, tapping Back should return to your inbox. If your app ignores this and makes Back close the app, it goes contrary to everything Android users know. Equally annoying are Android apps that force iOS design patterns on users.
Forcing your users to learn some weird quirk of your app instead of doing what you should isn’t innovative, it’s frustrating. Whether you’re making a native Windows 10 app or iOS app, take a look at what the standard is and follow it.
6. Burying Options Inside Stacks of Menus
Menus are an unfortunate necessity in most programs. Unless your program is extremely simple and displays everything on one row of icons, it probably has menus for less-used features and options. And while you don’t need to have super obscure features of, say, Microsoft Word in plain sight, hiding oft-used tools makes for a lot of wasted time navigating.
If it takes a user six clicks to navigate to the tool they need, that’s going to get on their nerves quickly. Keyboard shortcuts can help with this, but the most convenient ones (Ctrl + S) are usually reserved for the biggest features (Save). Pressing Ctrl + Shift + Alt + 9 + K isn’t much fun either.
This also goes for websites. If you can only get to a specific page by following a trail of links from other pages, that’s bad design and makes it hard for the user to get back to where they were.
7. Making Changes for No Reason
Muscle memory and familiarity go a long way when using an app or OS. It’s one of the reasons why switching ecosystems is so tough. So developers can throw everyone off when they make a change to something that didn’t really need changed.
Remember when Windows 8 launched? People freaked out because they couldn’t figure out how to shut down their computers. Microsoft took the simplest task that had been in a fine location for over a decade and turned it into something people had to look up online. Yet this happens on a smaller scale, too.
— Danny Policarpo (@dannypolicarpo) June 6, 2017
Every new version of Android, iOS, or Windows 10 makes small changes to the names of menus. What was once Settings > About phone > Build number on Android is now Settings > System > About phone > Build number. It’s a small change, but when writing about these menus, you never know what version of Android people are using. Thus you have to describe every possible combination to reduce confusion.
Sometimes change is necessary. But change just for the sake of change is confusing and forces users to adjust to a new paradigm for seemingly no reason.
What UI Elements Do You Hate Most?
We’ve looked at seven super frustrating user problems that arise from stupid choices that programmers make. Whether from deadlines, incompetence, or laziness, these are the quirks we put up with but mutter about under our breath. At least we can have some fun with them.
Want to avoid making these mistakes in your own apps? Check out our tips for writing cleaner and better code.
What are your most-hated quirks in apps? Do you have any interesting examples of the categories we discussed? Share with us in the comments, and feel free to rage!
Image Credit: Feverpitch/Depositphotos