This blog is all about helping you find the best software possible which is why we spend so much time reviewing and discussing specific products. However, we obviously can't review everything, so I'm going to start writing occassional posts about basic software design principles. It may seem like I'm writing these posts to help software designers, but my real goal is to help you identify great software design so that you'll be better at evaluating products on your own.
Today I want to talk about the way most designers deal with the balance between simplicity and power. To summarize the simlicity/power issue, it's generally difficult to build a product that has a lot of functionality but is also easy to use. Twitter is very easy to use, but it doesn't do anything useful. Photoshop can do just about anything you can imagine, but you need a doctorate just to perform basic tasks. When evaluating new software, this is one of the first issues you should focus on. Is it easy to use? Is it useful?
One of the most common tricks to blend power and simplicity is to have an "Advanced" section buried somewhere in the settings. The idea is that the software will start out nice and simple, and people can go enable complex features as they see fit. This strategy is based around the assumption that the non-tech savvy users need the simplicity and advanced users need the functionality, so this way everyone can get what they need.
But there's a major problem with this line of thinking. Just because I am an "advanced" user, that doesn't mean that I don't want a simple and easy user experience. And just because my grandma is still trying trying to wrap her head around computers, that doesn't mean that her software shouldn't be useful. By relying on an "advanced" section, designers are basically breaking their software into two different products, and neither of them perform well when evaluated individually.
Truly great software has a strong vision, and that means that the user experience needs to be consistent for all users. Power must be attained without the sacrifice of simplicity.
So what does this mean for you? When you're testing out software for the first time, look for indications of the design quality. I've already explained what to avoid (advanced settings). Here are some good design practices you should look for:
The fewer rules, the better
I've used this quote before on this blog, but it's fitting here: "Simple rules lead to complex behavior. Complex rules lead to stupid behavior"
The more restrictions put in place by the software designers, the harder it will be for you to use the software the way you want to. By keeping things very flexible and vague, designers can ensure that basic use is simple for all users, but more advanced users have the freedom to get creative.
A simple example of what not to do is require a lot of form fields. For some reason, software designers love to force you to fill out information that doesn't seem like it should be required. This is really common in CRM software when you're creating a new contact. If you don't want to fill out a company name, why in the world should you have to? The more limiting the software is, the less powerful it is because you can't use it for as many different things.
You should own your data
Good software lets you export your data, or access it through an API. When you own your own data, you can always use it for things that the software doesn't support. Hopefully you don't ever need to, but if you can't export your data, that means you're stuck with whatever functionality the designers think you need.
Settings should actually be settings
When I try out software for the first time, one of the first places I go is the settings section. I just skim through the different options and make sure they're actually settings and not hidden complexity. An example of a "setting" would be something like "enter your email address to sync contacts with gmail". An example of hidden complexity would be "click here to enable more advanced contact options".
Now, I'm not saying that there should never be settings intended specifically for advanced users. Sometimes that's an unfortunate necessity with software design, but it shouldn't be used as a crutch, and it shouldn't fundamentally change what the software is capable of.
So the next time you're evaluating new software, keep an eye out for designers hiding complexity instead of removing it entirely. That's the type of thing that makes software more annoying in the long run.